@dsh-gis/dsh-video-studio-skill 0.6.0 → 0.8.1

package/tools/estimate.py

@@ -40,23 +40,54 @@ import unicodedata
 from pathlib import Path
 
 # ============================================================================
-# 基准常量（唯一出处：SKILL.md §12 本机实测；换机请重测）
+# 基准常量（v0.7.2 重新校准：换机请重测后回填，别把这里的数字当通用真理）
 # ============================================================================
 
 W, H, FPS = 1920, 1080, 30          # filmkit.W/H/FPS：本项目写死，film.json 改不了
-PIL_FPS = (40.0, 80.0)              # PIL 逐帧：中等复杂度 40–54 fps / 模板片 68–82 fps
+PIL_FPS = (40.0, 80.0)              # PIL 逐帧渲染速度：中等复杂度 40–54 fps / 模板片 68–82 fps
+PARALLEL_EFF = 0.5                  # 分块并行的**实测效率**：2 进程只快 1.5×，不是 2×（见 CALIBRATION）
 WEB_SEC_PER_FRAME = (0.080, 0.130)  # web 引擎：Edge 无头 PNG 截图 80–130 ms/帧
 WEB_STARTUP_SEC = 6.0               # 浏览器冷启动 + CDP 连接（12 s 片 28–30 s 含启动）
-X264_FPS = 141.0                    # libx264 -preset medium -crf 17 ≈ 4.7× 实时
-TTS_SEC_PER_LINE = 4.0              # edge-tts：单句 4 s 语音约 4 s 合成（联网）
-SCORE_REFS = ((60.0, 2.0, 4.0), (389.0, 4.0, 8.0))  # (片长 s, 耗时低, 耗时高)：两个实测点
+X264_FPS = 141.0                    # libx264 -preset medium -crf 17 ≈ 4.7× 实时（仅 reencode_video 用）
+TTS_SEC_PER_LINE = (2.0, 4.0)       # edge-tts：每句每 worker 的墙钟（联网，波动大）：实测 2.2 s，留到 4.0
+SCORE_REFS = ((29.0, 3.6, 6.5), (58.0, 4.5, 6.5), (389.0, 8.0, 18.0))
+#           ^ (片长 s, 耗时低, 耗时高)：前两个点是本机实测（29 s / 58 s 各 3 次），
+#             第三个点是片长外推锚点（不是本机实测），只用来保证长片不会被系统性算小
 SFX_SEC_PER_CUE = 0.20              # 单条短音效 合成+落位（24 配方单次 ≤1.5 s 是上限口径）
-SFX_MIN_SEC = 0.5
-LAYOUT_BASE, LAYOUT_PER_LINE = 0.4, 0.02   # 排轴 + srt/ass + 安全区/字形自查
-CUES_BASE, CUES_PER_LINE = 0.2, 0.02       # 提示点落盘 + 排序
+SFX_MIN_SEC = 0.8                   # 实测 18 条 cue 的模板片 sfx 墙钟 0.8 s（含 ffmpeg 写盘）
+LAYOUT_BASE, LAYOUT_PER_LINE = 0.05, 0.01  # 排轴 + srt/ass + 安全区/字形自查（实测 29 s 片 <0.15 s）
+CUES_BASE, CUES_PER_LINE = 0.05, 0.005     # 提示点落盘 + 排序（实测 29 s 片 <0.15 s）
 AUDIO_BASE, AUDIO_PER_SEC = 0.6, 0.012     # numpy 总线按采样点叠加 + 写 wav
-QA_SEC_PER_SEC = 1.0 / 30.0                # 30 s 片全量深检 ≈ 1 s（160×90 流式解码）
-QA_MIN_SEC = 0.8
+# mux 默认是 -c:v copy + 两遍 loudnorm：实测 29 s 片 1.7–1.9 s，与帧数无关、跟片长弱相关。
+MUX_BASE_SEC = 0.6                  # 起 ffmpeg 两遍 + 封装
+MUX_PER_SEC = 0.045                 # 每片长秒（两遍 loudnorm 解码音频）
+# QA：实测 29 s 片 6.2–6.8 s（含联系表 + 锐度参考帧重渲染 + 帧级深检）。原来的 1/30 把 qa 算了 6 倍小。
+QA_BASE_SEC = (1.0, 3.0)            # 固定开销：联系表 + 参考帧重渲染
+QA_SEC_PER_SEC = (0.12, 0.25)       # 随片长：帧级深检流式解码 + 响度曲线
+UNMEASURED_BAND = 0.30              # 没有实测的阶段（layout/cues/sfx/audio）给 ±30% 的区间，别假装精确
+# v0.8 G11（全片 VMAF/SSIM）：参考帧由场景函数**重渲一遍**再喂 libvmaf，成本跟帧数走、
+# 与 frames 阶段同量级。实测口径差异极大：qavmaf 作者 29 s 片 12.0 s（≈0.40× 片长）；
+# SKILL.md §12 同一部模板片 14.2 s；同机另一轮负载下 28.8 s。这里取 0.40–1.00× 片长
+# （下限=干净机、上限=争 CPU 的长片外推），固定开销单独列 1–2 s。
+# 注：v0.7.2 那套 1.0–1.6× 的系数没有 v0.8 实测支撑，把 29 s 片算成 31–50 s（实际 12–29 s），
+# 预演总量因此系统性偏大近 2 倍——这类"拍脑袋的悲观系数"比低估更糟：排期会按假的数字走。
+VMAF_BASE_SEC = (1.0, 2.0)          # 起渲染进程 + 参考帧管线搭建
+VMAF_SEC_PER_SEC = (0.40, 1.00)     # 每片长秒（参考帧重渲 + libvmaf 逐帧比）
+
+# 校准出处：换成你自己的机器前，请按 SKILL.md §12 重测并回填——这些数字决定预演准不准。
+CALIBRATION = dict(
+    machine=("AMD64 Family 26 Model 36 Stepping 0（24 逻辑核）/ Windows；"
+             "SKILL.md §12 记录的作者机是 Ryzen AI 9 HX 370 / 12C24T / Radeon 890M"
+             "（是否同一台未核实，只保证这些数字是在上述 24 逻辑核机器上测的）"),
+    measured_at="2026-11-10",
+    sdk="video-studio v0.7.1 scripts（ffmpeg 自带 x264）",
+    film="29.011 s / 870 帧 / 模板片（assets/film.json + assets/scenes.py）",
+    method="render.py --stage all --jobs 2，逐 stage 取 [time] 行墙钟；同片重复 2 次",
+    observed=dict(tts=2.2, layout=0.0, cues=0.0, score=6.3, sfx=0.8, audio=0.7,
+                  frames=9.7, mux=1.9, qa=6.8, total=28.4),
+    extra="frames: 870 帧 jobs=1 14.37 s / jobs=2 9.53 s（并行效率 1.51×）;"
+          " score 58 s 片 4.5–5.0 s; qa 6.2–6.8 s",
+)
 CPS = 4.2                            # 每秒约 4.2 字（voicekit 校准 3.84–4.61 cps 的中位口径）
 DEFAULT_LEAD, DEFAULT_TAIL, DEFAULT_MIN_DUR = 0.62, 0.92, 3.0  # v0.5 body 基准
 CORES = 12                           # HX 370：12C/24T；jobs > 12 不再线性加速
@@ -65,8 +96,8 @@ WAV_BYTES_PER_SEC = 48000 * 2 * 2    # 48 kHz 立体声 PCM16 = 192 KB/s
 VIDEO_MBPS = (1.2, 3.0)              # crf17 @1080p30 图文内容（暗底大字 0.5–1 Mbps 属正常）
 AUDIO_MBPS = 0.192                   # AAC 192 kbps
 QA_DISK_BYTES = 12 * 1024 * 1024     # 联系表 + 静帧 + deep.png
-BASELINE_NOTE = ("区间来自作者机器实测（SKILL.md §12：Ryzen AI 9 HX 370 / 12C24T / "
-                 "Radeon 890M 无 CUDA）；换机请先重测再采信")
+BASELINE_NOTE = ("区间来自 v0.7.2 本机实测（机型/样本见下方 calibration；"
+                 "SKILL.md §12 记录的作者机是 Ryzen AI 9 HX 370 / 12C24T）；换机请先重测再采信")
 
 STAGE_LABELS = {
     "tts": "旁白 edge-tts",
@@ -78,6 +109,10 @@ STAGE_LABELS = {
     "frames": "逐帧渲染+编码",
     "mux": "合成成片",
     "qa": "质检+抽帧",
+    # v0.8：交付前的三道新门禁单独列（它们的成本不能藏进 qa 里）
+    "preflight": "渲染前预检",
+    "vmaf": "全片VMAF/SSIM",
+    "asr": "ASR回读",
 }
 
 
@@ -186,6 +221,31 @@ def _fmt_span(lo, hi):
     return "%.1f–%.1f s" % (float(lo), float(hi))
 
 
+def _qavmaf_sample_step(vcfg=None):
+    """qavmaf 的抽样步长（sample 模式每 N 帧取 1 帧）。
+
+    优先级与 render.py 的 _qa_vmaf_gate 一致：先读 film.json 的 qa.vmaf.sample_step，
+    没写才用 qavmaf.SAMPLE_STEP。预演不另抄一份常量，否则改一处漏一处；而"用户显式
+    写了 sample_step=20 却按默认 5 预演"会把这道门禁的成本高估 4 倍。
+    读不到 qavmaf 时按 1（=full）保守估——那种环境下 render.py 的 G11 本来也会记
+    skipped（没有模块），多估不会误导排期，少估才会。
+    """
+    try:
+        if isinstance(vcfg, dict) and vcfg.get("sample_step") is not None:
+            return max(1, int(vcfg["sample_step"]))
+    except (TypeError, ValueError):
+        pass
+    try:
+        scripts = str(Path(__file__).resolve().parent.parent /
+                      "skills" / "video-studio" / "scripts")
+        if scripts not in sys.path:
+            sys.path.insert(0, scripts)
+        import qavmaf
+        return max(1, int(qavmaf.SAMPLE_STEP))
+    except Exception:                                       # noqa: BLE001
+        return 1
+
+
 # ============================================================================
 # 估算核心
 # ============================================================================
@@ -245,25 +305,41 @@ def score_seconds(total):
     return max(0.3, lo), max(0.5, hi)
 
 
-def frames_seconds(frames, jobs, engine, rerender):
-    """frames 阶段墙钟（只算画面生成，编码单列在 mux 行）。
+def _speedup(jobs):
+    """分块并行的**有效加速比**：不是 jobs 倍。
 
-    PIL：帧数 ÷ 渲染 fps ÷ 并行度；web：启动开销 + 帧数 × 每帧截图耗时 ÷ 并行度。
-    render.py 的分块 worker 是"边渲染边编码"，所以真实成本 ≈ 本行 + mux 行。
+    实测（870 帧模板片）：jobs=1 → 14.37 s、jobs=2 → 9.53 s，只有 1.51×。
+    原因很实在：父进程要 spawn 子进程、每段都要重新 import scenes.py / 解析主题、
+    落盘 mux 串行、磁盘写带宽争用。按 jobs 线性折算会持续低估长片（越长的片分块越多）。
+    这里用 1 + (jobs-1)*PARALLEL_EFF 的线性模型：比理论值保守，实测 2 进程刚好对上。
     """
     jobs_eff = max(1, min(int(jobs), CORES))
+    return 1.0 + (jobs_eff - 1) * PARALLEL_EFF
+
+
+def frames_seconds(frames, jobs, engine, rerender):
+    """frames 阶段墙钟（只算画面生成；不重编码时封装成本在 mux 行）。
+
+    PIL：帧数 ÷ 渲染 fps ÷ 有效加速比；web：启动开销 + 帧数 × 每帧截图耗时 ÷ 加速比。
+    render.py 的分块 worker 是边渲染边编码，所以这里的 fps 已经含了编码开销。
+    """
+    sp = _speedup(jobs)
     if engine == "web":
-        base = [WEB_STARTUP_SEC + frames * spf / jobs_eff for spf in WEB_SEC_PER_FRAME]
+        base = [WEB_STARTUP_SEC + frames * spf / sp for spf in WEB_SEC_PER_FRAME]
     else:
-        base = [frames / rfps / jobs_eff for rfps in PIL_FPS]
+        base = [frames / rfps / sp for rfps in PIL_FPS]
     base = sorted(base)
     return base[0] * rerender, base[-1] * rerender
 
 
-def encode_seconds(frames, jobs):
-    """x264 编码墙钟：141 fps（medium/crf17），分块并行时按 --jobs 摊到各进程。"""
-    jobs_eff = max(1, min(int(jobs), CORES))
-    return frames / X264_FPS / jobs_eff
+def mux_seconds_pair(frames, jobs, total, script):
+    """mux 阶段区间：默认 -c:v copy 只跟片长有关；reencode_video=true 才跟帧数有关。"""
+    reencode = bool(script.get("reencode_video", False))
+    if reencode:
+        v = frames / X264_FPS / _speedup(jobs)
+        return v * 0.8, v * 1.6
+    base = MUX_BASE_SEC + MUX_PER_SEC * max(0.0, float(total))
+    return base * 0.75, base * 1.35
 
 
 def chunk_plan(frames, fps, jobs, explicit):
@@ -292,7 +368,6 @@ def disk_estimate(frames, total, n_lines, n_cues, crf, music_on):
     factor = 2.0 ** ((17.0 - crf) / 6.0)          # crf 每降 6 体积约翻倍（x264 经验值）
     vlo = max(0.3, VIDEO_MBPS[0] * factor)
     vhi = max(0.3, VIDEO_MBPS[1] * factor)
-    vid_lo = total * vlo * 1e6 / 8.0
     vid_hi = total * vhi * 1e6 / 8.0
     out_lo = total * (vlo + AUDIO_MBPS) * 1e6 / 8.0
     out_hi = total * (vhi + AUDIO_MBPS) * 1e6 / 8.0
@@ -345,16 +420,39 @@ def build_report(script_path, script, args):
         _warn("engine=%r 不认识（只能是 pil / web），按 pil 预演" % engine)
         engine = "pil"
 
+    # v0.8：画幅/帧率可以按片配置（只允许 16:9 横屏 + 下采样输出，见 filmkit.video_plan）。
+    # 预演必须跟着走，否则 720p 片会被按 1080p 估帧数与磁盘。
+    try:
+        import sys as _sys
+        _sys.path.insert(0, str(Path(__file__).resolve().parent.parent /
+                               "skills" / "video-studio" / "scripts"))
+        import filmkit as _FK
+        _vp = _FK.video_plan(script)
+    except ImportError as e:
+        # 只把"缺 filmkit"当降级：那是能用模板常量继续估的环境问题。
+        _warn("装载不了 filmkit（%s），画幅/帧率按 %dx%d@%d 估" % (e, W, H, FPS))
+        _vp = dict(fps=FPS, w=W, h=H, out_w=W, out_h=H,
+                   label="%dx%d" % (W, H))
+    except Exception as e:                                  # noqa: BLE001
+        # video 块写错（非 16:9 / 非法 fps / 上采样）时 render.py 会在 st_layout 直接报错，
+        # 预演却静默按默认值算并打印 ok:true——那等于告诉用户"能渲"，必须显式说清楚。
+        _warn("film.json 的 video 块不合法（%s: %s）：render.py 会拒绝这部片子，"
+              "下面的画幅/帧率只是占位估算" % (type(e).__name__, e))
+        _vp = dict(fps=FPS, w=W, h=H, out_w=W, out_h=H,
+                   label="%dx%d" % (W, H))
     tl, tl_path = read_timeline(args.work)
     if tl is not None:
         total = _num(tl.get("total"))
-        fps = int(_num(tl.get("fps"), FPS)) or FPS
+        fps = int(_num(tl.get("fps"), _vp["fps"])) or _vp["fps"]
         frames = int(_num(tl.get("frames"), round(total * fps)))
         source = "timeline"
         source_note = "真实帧数：%s" % tl_path
     else:
         total, _scenes = estimate_timeline(script)
-        fps = FPS
+        # v0.8：没有 timeline.json 时也必须用 film.json 的 video.fps —— 定死 30 会让
+        # 24/25/50/60 fps 的片子帧数、磁盘、分块全部按 30 fps 算（24 fps 高估 25%，
+        # 60 fps 低估一半），而 render.py 的 build_timeline(fps=vp["fps"]) 用的是真实值。
+        fps = int(_vp["fps"])
         frames = int(round(total * fps))
         source = "script_estimate"
         source_note = ("粗估（等效字数 ÷ %.1f 字/秒 + lead/tail + hold；没有 %s）"
@@ -390,49 +488,115 @@ def build_report(script_path, script, args):
     preset = script.get("preset", "medium")
 
     # ---- 各阶段 ----
+    # 没有实测的阶段一律给区间（正负 UNMEASURED_BAND），别把经验公式输出当精确值。
+    def _band(v):
+        # 下界永远让它摸到 0：这些阶段实测常常 <0.1 s（render.py 的 [time] 行按 0.1 s 打印，
+        # 于是显示 0.0），下界写成正值会让"实测值落在区间外"这种假告警出现。
+        return min(0.0, v * (1.0 - UNMEASURED_BAND)), v * (1.0 + UNMEASURED_BAND)
     workers = int(_num(script.get("tts_workers", 4), 4) or 4)
     workers = max(1, min(workers, max(1, n)))
-    tts_lo = tts_hi = n * TTS_SEC_PER_LINE / float(workers)
-    layout = LAYOUT_BASE + LAYOUT_PER_LINE * n
-    cues = CUES_BASE + CUES_PER_LINE * n
+    # TTS 按每句每 worker 摊：实测 4 句 / 4 workers = 2.2 s（串行口径 8.8 s）。
+    tts_lo = n * TTS_SEC_PER_LINE[0] / float(workers)
+    tts_hi = n * TTS_SEC_PER_LINE[1] / float(workers)
+    layout_lo, layout_hi = _band(LAYOUT_BASE + LAYOUT_PER_LINE * n)
+    cues_lo, cues_hi = _band(CUES_BASE + CUES_PER_LINE * n)
     if score_on:
         score_lo, score_hi = score_seconds(total)
     else:
         score_lo = score_hi = 0.0
-    sfx = max(SFX_MIN_SEC, n_cues * SFX_SEC_PER_CUE) if sfx_on else 0.0
-    audio = AUDIO_BASE + total * AUDIO_PER_SEC
+    sfx_lo, sfx_hi = _band(max(SFX_MIN_SEC, n_cues * SFX_SEC_PER_CUE)) if sfx_on else (0.0, 0.0)
+    audio_lo, audio_hi = _band(AUDIO_BASE + total * AUDIO_PER_SEC)
     fr_lo, fr_hi = frames_seconds(frames, jobs_eff, engine, rerender)
-    mux = encode_seconds(frames, jobs_eff)
-    qa = max(QA_MIN_SEC, total * QA_SEC_PER_SEC)
+    mux_lo, mux_hi = mux_seconds_pair(frames, jobs_eff, total, script)
+    qa_lo = max(0.5, QA_BASE_SEC[0] + total * QA_SEC_PER_SEC[0])
+    qa_hi = max(qa_lo, QA_BASE_SEC[1] + total * QA_SEC_PER_SEC[1])
+    # v0.8 的三个新门禁：预检（固定小开销）、全片 VMAF/SSIM、ASR 回读。
+    # 实测口径（29.0 s 模板片）：preflight 0.4 s；VMAF full 12–29 s（0.40–1.00× 片长，
+    # 参考帧重渲与 libvmaf 都在里面，见 VMAF_* 常量注释）；ASR small ≈ 6–10 s。
+    # 这三项全在**交付前**跑，不写进预演就等于"预演说 40 s、实际 90 s"——所以单独列 stage。
+    qcfg = script.get("qa") or {}
+    if not isinstance(qcfg, dict):
+        qcfg = {}
+    # render.py 的 _qa_vmaf_gate / _qa_asr_gate 都用 isinstance 兜住了非 dict 的配置块；
+    # 预演以前直接 .get()，于是 "qa": {"vmaf": "off"} 这种（用户以为写了个开关）
+    # 会在 --json 下甩 AttributeError traceback、退出码 1——比 render 还不宽容。
+    vcfg = qcfg.get("vmaf")
+    if not isinstance(vcfg, dict):
+        if vcfg is not None:
+            _warn("qa.vmaf 不是对象（收到 %r）：按默认 full 预演（render.py 会忽略这个值）"
+                  % (vcfg,))
+        vcfg = {}
+    vmaf_mode = str(vcfg.get("mode") or "full").lower()
+    vmaf_on = vmaf_mode != "off" and engine == "pil"      # web 路线没有可重渲参考帧
+    # sample 模式（qavmaf 每 SAMPLE_STEP 帧取 1 帧）只渲/比 1/step 的帧，固定开销不变。
+    # 预演以前不看 mode，于是 --vmaf sample 的真实成本被按全片算：29 s 片实测 sample
+    # 2.95 s vs full 12.0 s，而预演两边都给同一个数（片长越长错得越多）。
+    vmaf_step = 1
+    if vmaf_mode == "sample":
+        vmaf_step = _qavmaf_sample_step(vcfg)
+    # sample 只压缩"逐帧"那一半，固定开销照付。
+    vmaf_lo = (VMAF_BASE_SEC[0] + total * VMAF_SEC_PER_SEC[0] / vmaf_step) if vmaf_on else 0.0
+    vmaf_hi = (VMAF_BASE_SEC[1] + total * VMAF_SEC_PER_SEC[1] / vmaf_step) if vmaf_on else 0.0
+    acfg = qcfg.get("asr")
+    if not isinstance(acfg, dict):
+        if acfg is not None:
+            _warn("qa.asr 不是对象（收到 %r）：按默认（开）预演" % (acfg,))
+        acfg = {}
+    asr_on = bool(acfg.get("enabled", True)) != False    # noqa: E712  默认开
+    asr_lo = (total * 0.18 + 3.5) if asr_on else 0.0
+    asr_hi = (total * 0.35 + 6.5) if asr_on else 0.0
+    pre_lo, pre_hi = (0.3, 0.8)
+    if not vmaf_on:
+        vmaf_note = "本次不跑（--vmaf off 或 engine=web）"
+    elif vmaf_mode == "sample":
+        vmaf_note = ("sample 模式每 %d 帧取 1 帧：逐帧成本只算 1/%d，参考帧管线固定开销照付。"
+                     "同机负载不同实测能差近 2×（SKILL.md §12：14.2 s / 另一轮 28.8 s）"
+                     % (vmaf_step, vmaf_step))
+    else:
+        vmaf_note = ("全片逐帧比较（参考帧=场景函数重渲染，不是成片抽帧）。同机负载不同"
+                     "实测能差近 2×（SKILL.md §12：14.2 s / 另一轮 28.8 s）")
 
     stages = [
         dict(stage="tts", lo=tts_lo, hi=tts_hi, measured=True,
-             note=("%d 句 × %.1f s ÷ tts_workers=%d（串行口径 %.1f s；需联网，edge-tts 免费端点）"
-                   % (n, TTS_SEC_PER_LINE, workers, n * TTS_SEC_PER_LINE))),
-        dict(stage="layout", lo=layout, hi=layout, measured=False,
-             note="排轴 + sub.srt/ass + 安全区/字形自查（经验值，未单测）"),
-        dict(stage="cues", lo=cues, hi=cues, measured=False,
-             note="%d 条 sfx.cues 落位 + 排序（经验值，未单测）" % n_cues),
+             note=("%d 句 ÷ tts_workers=%d，每句每 worker %.1f–%.1f s（实测 2.2 s/4 句；"
+                   "需联网，edge-tts 免费端点波动大）"
+                   % (n, workers, TTS_SEC_PER_LINE[0], TTS_SEC_PER_LINE[1]))),
+        dict(stage="layout", lo=layout_lo, hi=layout_hi, measured=False,
+             note="排轴 + sub.srt/ass + 安全区/字形自查（经验模型，给 ±%d%% 区间）"
+                  % int(UNMEASURED_BAND * 100)),
+        dict(stage="cues", lo=cues_lo, hi=cues_hi, measured=False,
+             note="%d 条 sfx.cues 落位 + 排序（经验模型，给 ±%d%% 区间）"
+                  % (n_cues, int(UNMEASURED_BAND * 100))),
         dict(stage="score", lo=score_lo, hi=score_hi, measured=bool(score_on),
-             note=("按 60 s≈2–4 s / 389 s≈4–8 s 线性折算" if score_on
-                   else ("mode=%s：不跑 scorekit（%s）"
-                         % (mode or "-", "外部配乐/和弦床/关掉配乐")))),
-        dict(stage="sfx", lo=sfx, hi=sfx, measured=False,
-             note=("%d 条音效 ≈ %.1f s（上限口径：单条 ≤1.5 s；长环境声 wind/rain 另计）"
-                   % (n_cues, sfx) if sfx_on else "没有 sfx.cues：跳过（whoosh 兼容路径除外）")),
-        dict(stage="audio", lo=audio, hi=audio, measured=False,
-             note="旁白+配乐+音效三总线混音 + 写 audio.wav（经验值：%.2f s + %.3f×片长）"
+             note=("以实测点 29 s≈3.6–6.3 s / 58 s≈4.5–5.0 s 为锚（--stage all 里与其它阶段争 CPU 会更慢；389 s 只是外推锚点）"
+                   if score_on else
+                   ("mode=%s：不跑 scorekit（%s）"
+                    % (mode or "-", "外部配乐/和弦床/关掉配乐")))),
+        dict(stage="sfx", lo=sfx_lo, hi=sfx_hi, measured=False,
+             note=("%d 条音效（实测 18 条 0.8 s；单条上限口径 ≤1.5 s，长环境声 wind/rain 另计）"
+                   % n_cues if sfx_on else
+                   "没有 sfx.cues：跳过（whoosh 兼容路径除外）")),
+        dict(stage="audio", lo=audio_lo, hi=audio_hi, measured=False,
+             note="三总线混音 + 写 audio.wav（实测 29 s 片 0.7 s；模型 %.2f + %.3f×片长）"
                   % (AUDIO_BASE, AUDIO_PER_SEC)),
         dict(stage="frames", lo=fr_lo, hi=fr_hi, measured=True,
-             note=("%s：%s，--jobs %d（本机 12 核）× 返工系数 %.2g；编码成本单列在 mux 行"
+             note=("%s：%s，--jobs %d → 有效加速比 %.2f×（实测 2 进程 1.51×），"
+                   "返工系数 %.2g；不重编码时封装成本在 mux 行"
                    % (engine, "PIL 40–80 fps" if engine == "pil"
-                      else "web 80–130 ms/帧 + 启动 6 s", jobs_eff, rerender))),
-        dict(stage="mux", lo=mux, hi=mux, measured=True,
-             note=("x264 medium crf17 ≈%d fps，按 --jobs %d 摊（分块 worker 边渲染边编码）；"
-                   "render.py 的 mux 本身是 -c:v copy + 两遍 loudnorm，通常 <1 s"
-                   % (int(X264_FPS), jobs_eff))),
-        dict(stage="qa", lo=qa, hi=qa, measured=True,
-             note="30 s 片全量深检 ≈1 s，按片长线性折算 + 联系表/静帧"),
+                      else "web 80–130 ms/帧 + 启动 6 s", jobs_eff,
+                      _speedup(jobs_eff), rerender))),
+        dict(stage="mux", lo=mux_lo, hi=mux_hi, measured=True,
+             note=("-c:v copy + 两遍 loudnorm（实测 29 s 片 1.7–1.9 s，与帧数无关）；"
+                   "reencode_video=true 才走 x264 %.0f fps" % X264_FPS)),
+        dict(stage="preflight", lo=pre_lo, hi=pre_hi, measured=True,
+             note="渲染前资源预检（缺字形/坏音频/缺字体；实测 0.4 s，渲一帧之前就失败）"),
+        dict(stage="qa", lo=qa_lo, hi=qa_hi, measured=True,
+             note=("联系表 + 锐度参考帧重渲染 + 帧级深检（实测 29 s 片 6.2–6.8 s，不是 1 s）")),
+        dict(stage="vmaf", lo=vmaf_lo, hi=vmaf_hi, measured=False, note=vmaf_note),
+        dict(stage="asr", lo=asr_lo, hi=asr_hi, measured=False,
+             note=("ASR 回读（faster-whisper small / CPU int8，RTF≈0.17 + 加载 2–3 s；"
+                   "实测 29 s 片 6–10 s）"
+                   if asr_on else "本次不跑（qa.asr.enabled=false）")),
     ]
     total_lo = sum(s["lo"] for s in stages)
     total_hi = sum(s["hi"] for s in stages)
@@ -443,9 +607,13 @@ def build_report(script_path, script, args):
     disk = disk_estimate(frames, total, n, n_cues, crf, music_on)
 
     # ---- 分块（render.py 规则）----
+    # 这里必须传**用户请求的 jobs**，不能传 jobs_eff：render.py 的 chunk_frames 公式用的是
+    # --jobs 原值（它不按核数封顶），而 jobs_eff 是给"加速比模型"封顶到 CORES 的。
+    # 传错的话 --jobs 16（24 线程机器上合法）会算出 chunk=120/8 段，render 实际是
+    # chunk=60/15 段——预演与实现"逐字一致"的承诺当场失效。
     explicit = int(_num(script.get("chunk_frames"), 0))
-    chunk, nseg = chunk_plan(frames, fps, jobs_eff, explicit)
-    chunk = dict(jobs=jobs_eff, jobs_requested=jobs_req, chunk_frames=chunk,
+    chunk, nseg = chunk_plan(frames, fps, jobs_req, explicit)
+    chunk = dict(jobs=jobs_req, jobs_requested=jobs_req, chunk_frames=chunk,
                  segments=nseg, explicit=bool(explicit),
                  rule="chunk = chunk_frames 或 round(frames/jobs/fps/4)*4*fps，"
                       "再按 fps 取整、最小 2×fps")
@@ -456,7 +624,10 @@ def build_report(script_path, script, args):
         "source": source,
         "source_note": source_note,
         "video": {"title": script.get("title"),
-                  "width": W, "height": H, "fps": fps, "frames": frames,
+                  # v0.8：内部构图恒为 1080p，交付尺寸可以更小（_vp 从 film.json 的 video 块来）
+                  "width": _vp["w"], "height": _vp["h"],
+                  "out_width": _vp["out_w"], "out_height": _vp["out_h"],
+                  "fps": fps, "frames": frames,
                   "duration_s": round(total, 3), "engine": engine,
                   "crf": crf, "preset": preset, "bpm": mus.get("bpm", script.get("bpm")),
                   "style": script.get("style", None)},
@@ -482,14 +653,24 @@ def build_report(script_path, script, args):
                        "share": round(share, 3),
                        "advice": bottleneck_advice(worst["stage"], engine, jobs_eff)},
         "assumptions": [
-            "分辨率 1920x1080@%d 由 filmkit.W/H/FPS 写死，film.json 改不了" % FPS,
+            "内部构图恒为 1920x1080；交付尺寸/帧率可写 film.json 的 video 块"
+            "（v0.8，只允许 16:9 横屏且只能下采样；本次按 %d fps 估）" % fps,
             "lead=%.2f / tail=%.2f / min_dur=%.1f（v0.5 body 基准；剧本写了就以剧本为准）"
             % (DEFAULT_LEAD, DEFAULT_TAIL, DEFAULT_MIN_DUR),
-            "tts 耗时按 %d 句 × %.1f s ÷ workers；实际受网络波动影响" % (n, TTS_SEC_PER_LINE),
-            "frames 的 jobs 并行按线性折算且封顶 %d 核（超过不再线性）" % CORES,
-            "layout/cues/audio/sfx 的耗时为经验模型（无单阶段实测），量级可信、小数位不可信",
+            "tts 耗时按 %d 句 ÷ workers × %.1f–%.1f s（每句每 worker）；实际受网络波动影响"
+            % (n, TTS_SEC_PER_LINE[0], TTS_SEC_PER_LINE[1]),
+            "frames 的并行不是 jobs 倍：有效加速比 = 1 + (jobs-1)×%.2f，封顶 %d 核"
+            % (PARALLEL_EFF, CORES),
+            "mux 默认 -c:v copy，只跟片长有关；reencode_video=true 才按帧数重编",
+            "layout/cues/audio/sfx 给 ±%d%% 经验区间（无单阶段实测）" % int(UNMEASURED_BAND * 100),
+            "v0.8 新增门禁口径：preflight 0.4 s 固定；vmaf ≈ %.2f–%.2f× 片长 + %.1f–%.1f s"
+            "（参考帧重渲染 + libvmaf；同机负载不同实测差近 2×）；asr ≈ 0.18–0.35× 片长 + "
+            "3.5–6.5 s（faster-whisper small / CPU int8）"
+            % (VMAF_SEC_PER_SEC[0], VMAF_SEC_PER_SEC[1], VMAF_BASE_SEC[0], VMAF_BASE_SEC[1]),
+            "基准来源见 calibration 字段（机型/日期/样本）；换机请重测后回填顶部常量",
         ],
         "baseline": BASELINE_NOTE,
+        "calibration": dict(CALIBRATION),
     }
     return report
 
@@ -545,6 +726,15 @@ def print_report(rep):
           % (bn["stage"], bn["seconds_hi"], bn["share"] * 100, bn["advice"]))
     print()
     print("  基准说明：%s" % rep["baseline"])
+    cal = rep.get("calibration") or {}
+    if cal:
+        print("  校准出处（换机请重测后回填 tools/estimate.py 顶部常量）：")
+        print("    机型   %s" % cal.get("machine", "-"))
+        print("    实测   %s · 样本 %s" % (cal.get("measured_at", "-"), cal.get("film", "-")))
+        print("    方法   %s" % cal.get("method", "-"))
+        obs = cal.get("observed") or {}
+        if obs:
+            print("    实测值 " + " · ".join("%s %.1fs" % (k, v) for k, v in obs.items()))
     print("  假设：")
     for a in rep["assumptions"]:
         print("    - %s" % a)