Files

281 lines
9.5 KiB
Python
Raw Permalink Normal View History

# -*- coding: utf-8 -*-
"""
Text 1 讲解视频 —— 配音与时间轴生成
流程:
1. 解析 讲解脚本_Text1.md(## 场景key | 场景名 + 以 "- " 开头的口播行)
2. 用 edge-tts 逐场景合成配音(走新端点 api.msedgeservices.com)
3. 用返回的 SentenceBoundary 时间戳,按字符对齐算出每一条字幕的精确起止
4. 输出 public/vo/<key>.mp3 与 src/timing.generated.ts
"""
import asyncio
import os
import re
import subprocess
import sys
import time as _time
# ---------- edge-tts 新端点补丁(2026-10 起旧域名返回 403)----------
import edge_tts
import edge_tts.constants as K
K.WSS_URL = (
"wss://api.msedgeservices.com/tts/cognitiveservices/websocket/v1"
f"?Ocp-Apim-Subscription-Key={K.TRUSTED_CLIENT_TOKEN}"
)
import edge_tts.communicate as CM
CM.WSS_URL = K.WSS_URL
HERE = os.path.dirname(os.path.abspath(__file__))
PROJ = os.path.join(HERE, "remotion-text1")
SCRIPT_MD = os.path.join(HERE, "讲解脚本_Text1.md")
VO_DIR = os.path.join(PROJ, "public", "vo")
OUT_TS = os.path.join(PROJ, "src", "timing.generated.ts")
FFMPEG = os.path.join(HERE, ".venv", "Lib", "site-packages",
"imageio_ffmpeg", "binaries", "ffmpeg-win-x86_64-v7.1.exe")
VOICE = "zh-CN-YunjianNeural"
RATE = "-4%"
FPS = 30
LEAD_PAD = 0 # 场景开头留白(帧)
TAIL_PAD = 0.7 # 场景结尾留白(秒),给转场淡出
# ---------------- 1. 解析脚本 ----------------
def parse_script(path):
scenes = []
cur = None
with open(path, encoding="utf-8") as f:
for raw in f:
line = raw.rstrip("\n")
if line.startswith("## "):
head = line[3:].strip()
if "|" in head:
key, label = [x.strip() for x in head.split("|", 1)]
else:
key, label = head, head
cur = {"key": key, "label": label, "lines": []}
scenes.append(cur)
elif line.startswith("- ") and cur is not None:
t = line[2:].strip()
if t:
cur["lines"].append(t)
return [s for s in scenes if s["lines"]]
# ---------------- 2. 时间戳对齐 ----------------
NORM_RE = re.compile(r"[^0-9A-Za-z\u4e00-\u9fff]+")
def norm(s: str) -> str:
"""只保留字母、数字与汉字,去掉空白与标点。"""
return NORM_RE.sub("", s).lower()
def build_char_map(full_text: str):
"""返回 (full_norm, 映射:原文字符下标 -> 归一化下标)。"""
out = []
idx_of = []
for ch in full_text:
n = norm(ch)
for _ in n:
idx_of.append(len(out))
if n:
out.append(n)
else:
idx_of.append(len(out)) # 标点/空白:映射到当前位置
idx_of.append(len(out))
return "".join(out), idx_of
def cue_times(full_text, cue_spans, boundaries, audio_dur):
"""把每条字幕的字符区间换算成时间(秒)。
cue_spans: [(start_char, end_char)] 相对 full_text
boundaries: [(norm_text, start_sec, end_sec)]
"""
full_norm, idx_of = build_char_map(full_text)
n = len(full_norm)
times = [None] * (n + 1)
p = 0
matched = 0
for btxt, bstart, bend in boundaries:
bn = norm(btxt)
if not bn:
continue
pos = full_norm.find(bn, max(0, p - 2))
if pos < 0:
pos = full_norm.find(bn)
if pos < 0:
continue
matched += len(bn)
L = len(bn)
for k in range(L):
t = bstart + (bend - bstart) * (k / L if L else 0)
gi = pos + k
if gi <= n and (times[gi] is None):
times[gi] = t
if pos + L <= n:
times[pos + L] = bend if times[pos + L] is None else times[pos + L]
p = pos + L
coverage = matched / n if n else 0
# 已知锚点线性插值补全
known = [i for i, t in enumerate(times) if t is not None]
if known:
if times[0] is None:
times[0] = 0.0
for a, b in zip(known, known[1:]):
if b - a > 1:
t0, t1 = times[a], times[b]
for k in range(a + 1, b):
times[k] = t0 + (t1 - t0) * (k - a) / (b - a)
tail = times[known[-1]]
for i in range(known[-1] + 1, n + 1):
times[i] = tail
out = []
for (cs, ce) in cue_spans:
ns = idx_of[max(0, min(cs, len(idx_of) - 1))]
ne = idx_of[max(0, min(ce, len(idx_of) - 1))]
t0 = times[min(ns, n)] if ns <= n else 0.0
t1 = times[min(ne, n)] if ne <= n else audio_dur
if t0 is None:
t0 = 0.0
if t1 is None or t1 <= t0:
t1 = min(audio_dur, t0 + 0.4)
out.append((max(0.0, t0), max(t0 + 0.2, t1)))
return out, coverage
# ---------------- 3. 音频工具 ----------------
def ffprobe_duration(path):
r = subprocess.run([FFMPEG, "-hide_banner", "-i", path],
capture_output=True, text=True, errors="replace")
m = re.search(r"Duration: (\d+):(\d+):(\d+\.\d+)", r.stderr)
if not m:
raise RuntimeError("无法读取时长: " + path + "\n" + r.stderr[-500:])
h, mi, s = m.group(1), m.group(2), m.group(3)
return int(h) * 3600 + int(mi) * 60 + float(s)
# ---------------- 4. 合成 ----------------
async def synth(text, out_path, tries=4):
last = None
for i in range(tries):
try:
c = edge_tts.Communicate(text, VOICE, rate=RATE)
buf = b""
bounds = []
async for ch in c.stream():
t = ch.get("type", "")
if t == "audio":
buf += ch["data"]
elif t.endswith("Boundary"):
bounds.append((ch.get("text", ""),
ch.get("offset", 0) / 1e7,
(ch.get("offset", 0) + ch.get("duration", 0)) / 1e7))
if len(buf) < 2000:
raise RuntimeError(f"音频过短 ({len(buf)} bytes)")
if not bounds:
raise RuntimeError("未收到时间戳事件")
with open(out_path, "wb") as f:
f.write(buf)
return bounds
except Exception as e: # noqa: BLE001
last = e
print(f" 重试 {i+1}/{tries}: {type(e).__name__} {str(e)[:80]}")
await asyncio.sleep(2.0 + i * 1.5)
raise RuntimeError(f"合成失败: {last}")
def ts_escape(s):
return s.replace("\\", "\\\\").replace("'", "\\'")
async def main():
scenes = parse_script(SCRIPT_MD)
os.makedirs(VO_DIR, exist_ok=True)
print(f"共 {len(scenes)} 个场景,语音={VOICE},语速={RATE}\n")
result = []
cursor_frames = 0
for idx, sc in enumerate(scenes, 1):
key, label, lines = sc["key"], sc["label"], sc["lines"]
full = "".join(lines)
# 每条字幕的字符区间
spans, p = [], 0
for ln in lines:
spans.append((p, p + len(ln)))
p += len(ln)
out_mp3 = os.path.join(VO_DIR, f"{key}.mp3")
print(f"[{idx:02d}/{len(scenes)}] {key:<11} {len(lines):>2} 句 / {len(full):>4} 字 ...")
t0 = _time.time()
bounds = await synth(full, out_mp3)
dur = ffprobe_duration(out_mp3)
cts, cov = cue_times(full, spans, bounds, dur)
print(f" 音频 {dur:.2f}s · 边界 {len(bounds)} · 对齐覆盖 {cov*100:.0f}% · 耗时 {_time.time()-t0:.1f}s")
start_frame = cursor_frames
scene_dur = round((dur + TAIL_PAD) * FPS)
cues = []
for (a, b), txt in zip(cts, lines):
cues.append({
"text": txt,
"start": start_frame + round(a * FPS),
"end": start_frame + round(min(b, dur) * FPS),
})
result.append({
"key": key, "label": label,
"audio": f"vo/{key}.mp3",
"start": start_frame, "dur": scene_dur,
"cues": cues,
})
cursor_frames = start_frame + scene_dur
# ---- 写 TS ----
L = []
L.append("// 本文件由 build_voice.py 自动生成,请勿手工修改。")
L.append("export type Cue = { text: string; start: number; end: number };")
L.append("export type SceneTiming = {")
L.append(" key: string; label: string; audio: string;")
L.append(" start: number; dur: number; cues: Cue[];")
L.append("};")
L.append("")
L.append("export const SCENES: SceneTiming[] = [")
for r in result:
L.append(" {")
L.append(f" key: '{ts_escape(r['key'])}',")
L.append(f" label: '{ts_escape(r['label'])}',")
L.append(f" audio: '{r['audio']}',")
L.append(f" start: {r['start']},")
L.append(f" dur: {r['dur']},")
L.append(" cues: [")
for c in r["cues"]:
L.append(" { text: '%s', start: %d, end: %d },"
% (ts_escape(c["text"]), c["start"], c["end"]))
L.append(" ],")
L.append(" },")
L.append("];")
L.append("")
L.append(f"export const TOTAL_FRAMES = {cursor_frames};")
L.append(f"export const TOTAL_SECONDS = {cursor_frames / FPS:.2f};")
L.append("")
with open(OUT_TS, "w", encoding="utf-8") as f:
f.write("\n".join(L))
print(f"\n完成:{len(result)} 个场景,总时长 {cursor_frames/FPS/60:.1f} 分钟({cursor_frames} 帧)")
print("输出:", OUT_TS)
for r in result:
print(f" {r['key']:<11} start={r['start']:>6} dur={r['dur']:>6} ({r['dur']/FPS:>5.1f}s) cues={len(r['cues'])}")
if __name__ == "__main__":
sys.exit(asyncio.run(main()))