ffmpeg-skill 3.8.20 → 3.8.22

package/scripts/freeze.py

@@ -18,8 +18,9 @@ Examples:
 """
 import argparse
 import sys
+from fractions import Fraction
 
-from _common.decision import av_trim, delivered_rate, frame_durations, frame_rate, grid_at_or_after, silence_filter, stream_starts, tpad_length
+from _common.decision import av_trim, cfr_at_input, cfr_filter, delivered_rate, frame_durations, frame_rate, grid_at_or_after, silence_filter, stream_starts, tpad_length
 from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, time_arg, fmt_secs, run
 from _common.emit import input_length
 
@@ -63,6 +64,15 @@ def main() -> int:
     # starts 0.1 s late 0.1 s early (147 frames for 150).
     v0 = stream_starts(meta)[0]
     rate = frame_rate(meta) or fps
+    if cfr_filter(meta):
+        # A VFR source is put on the delivered grid as it is decoded (the graph's cfr_at_input
+        # below), and every frame time is on that grid (#523): on the source's own frames the
+        # head ended at its last frame's nominal duration, so with --at inside a gap the hold, and
+        # everything after it, started the rest of the gap early against the sound, which is cut
+        # at --at (56 ms at --at 0.15, 93 ms at --at 2.2 on a 27 fps average clip with gaps from
+        # 0.1 and 2.1 s). A hold is then counted in frames of that rate, the rate its frames are
+        # cloned at.
+        rate = delivered_rate(meta) or rate
     cut_at = grid_at_or_after(at, v0, rate)
     # no frame at or after --at (no --at holds at the clip's end): the insert tail would be empty
     # and the hold lost, so hold the last frame as --mode extend does (#416 review)
@@ -98,8 +108,11 @@ def main() -> int:
         # the video actually holds for, a permanent A/V drift from this point on. Pad audio by
         # the same, frame-rounded duration the video actually gets.
         actual_hold = n / rate
-        head_v, head_a = av_trim(v0, cut_at, rate)
-        tail_v, tail_a = av_trim(cut_at, None, rate)
+        # a conformed VFR picture starts at 0 on the graph's clock (cfr_at_input's origin), so its
+        # trims are counted from its own start; the sound's stay on the input's clock
+        vo = v0 if cfr_filter(meta) else 0.0
+        head_v, head_a = av_trim(v0 - vo, cut_at - vo, rate)[0], av_trim(v0, cut_at, rate)[1]
+        tail_v, tail_a = av_trim(cut_at - vo, None, rate)[0], av_trim(cut_at, None, rate)[1]
         # The hold is its own segment: the frame at cut_at, cut on the input's clock and cloned to
         # n frames there (tpad's stop clone), then shifted like the tail. From FFmpeg 7.0 setpts
         # leaves its output's frame rate unknown and its frames' durations 0, so the earlier tpad
@@ -114,11 +127,27 @@ def main() -> int:
         half = 0.5 / rate
         # the graph closes on the rate the encoder line delivers (a VFR source is conformed to its
         # average): closed on r_frame_rate, -r then resampled it and the picture ran late (#512)
-        hold_v = (f"trim=start={cut_at - half:.6f},trim=end_frame=1,"
+        hold_v = (f"trim=start={cut_at - vo - half:.6f},trim=end_frame=1,"
                   f"tpad=stop_mode=clone:stop={n - 1},setpts=PTS-STARTPTS")
+        # Every segment is a whole count of frames on one grid, so the joined picture's timestamps
+        # are rebuilt from its running frame count before the closing fps: FFmpeg 6.1.1's video
+        # concat gives a one-frame segment no length (it ends a segment at its last frame's
+        # timestamp), so a hold of one frame (--hold 0.04 at 30 fps) was dropped and the rest of
+        # the picture ran a frame before its sound, as speedramp.py's one-frame segments did
+        grid = frame_durations(meta, delivered_rate(meta) or rate)
+        q = Fraction(grid[len("fps="):]) if "/" in grid else Fraction(delivered_rate(meta) or rate).limit_denominator(1001)
         vf = (f"[0:v]split=3[a][b][c];[a]{head_v}[head];"
               f"[b]{hold_v}[hold];[c]{tail_v}[tail];"
-              f"[head][hold][tail]concat=n=3:v=1:a=0,{frame_durations(meta, delivered_rate(meta) or rate)}[outv]")
+              f"[head][hold][tail]concat=n=3:v=1:a=0,setpts=N*{q.denominator}/({q.numerator}*TB),{grid}[outv]")
+        # the grid is laid from the picture's start (the picture moved to 0 ahead of the fps
+        # filter, and the trims above counted from there), on a microsecond time base: laid from
+        # the clock's 0, a picture that starts 50 ms in came out a frame early after the hold, and
+        # on the fps filter's base of one frame the trim's half-frame bound 3.907407 (--at 3.9)
+        # became frame 105 itself, which was cut from the head and held in place of frame 106.
+        # It is not moved back after the conform: from FFmpeg 7.0 a setpts leaves its frames no
+        # duration and no rate, and the hold's tpad after it cloned nothing (109 frames for 135
+        # on 7.1)
+        vf = cfr_at_input(vf, meta, origin=v0)
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", vf, "-map", "[outv]"]
         if has_audio:
             af = (f"[0:a]asplit[aa][ab];[aa]{head_a}[ahead];"

package/scripts/render.py

@@ -75,9 +75,9 @@ from typing import Any, Dict, List, Optional, Sequence
 from export import PRESETS, PLATFORM_OF
 from _platforms import PLATFORMS, caption_defaults, resolve as resolve_platform
 from _common import guard_sidecar, STATE, add_common, aspect_ratio, brand_caption_style, load_brand, apply_common, child_args, die, emit as _emit, info, option_args, probe, require_tool, run, run_tool, place_output, refuse_output_is_input, _check_existing_output, _check_output_path, fingerprint, PLAN_VERSION, ffmpeg_version, X264_PRESETS
-from _common.runner import HW_ENV, HW_FORCED_ENV, add_hw_orchestrator_args, child_exit_code, found_exe, kept_clause, kept_deliverables, mark_delivered, owned_identity, read_json, remember_written
+from _common.runner import HW_ENV, HW_FORCED_ENV, add_hw_orchestrator_args, child_exit_code, found_exe, kept_clause, kept_deliverables, mark_delivered, owned_identity, read_json, refuse_missing_components_first, remember_written, with_flags, kept_output, unwatch_destination, watch_destination
 from _common.emit import absorb_stage, audit, is_output_shape_flag, record_fallback, record_skip, refuse, stderr_records, warn
-from _common.decision import rebase_project_paths
+from _common.decision import brand_asset_files, rebase_project_paths
 import subprocess
 from _contract import CONTRACT_VERSION
 from batch import file_key
@@ -803,6 +803,14 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
         info(f"    {os.path.basename(str(dest))} is an earlier render's own stage file in {_OWN_STAGES['dir']}, unchanged since: replaced")
     cmd = [str(HERE / script)] + [str(a) for a in argv] + (extra or []) + own + child_args() + ["--json"]
     info("→ " + " ".join(os.path.basename(c) if i < 1 else c for i, c in enumerate(cmd[:-1])))
+    # a stage that writes outside the work directory (the export writes the delivery itself): what
+    # is there now, so a stop while it runs reports a file the stage wrote as kept, not "nothing
+    # was written", and never claims the caller's own file (#510)
+    # the delivery itself is watched wherever --work is (a --work that holds the output's folder
+    # made the export look like an intermediate, #510 review)
+    outside = bool(dest) and (not _in_work(dest) or _is_delivery(dest))
+    if outside:
+        watch_destination(dest)
     proc = run_tool(cmd)
     for is_command, line in stderr_records(proc.stderr):
         if is_command:
@@ -825,7 +833,7 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
             # a stage after the delivery (chapters, check): the stage's own "nothing was written"
             # is about its own file, while the delivery is on disk (#415)
             why = why.replace("; nothing was written", "") + f" ({kept_clause()})"
-            extra_fields.setdefault("output", kept_deliverables()[-1])
+            extra_fields.setdefault("output", kept_output())
         elif err.get("kind") in ("timeout", "interrupted") and doc.get("output") and os.path.isfile(str(doc["output"])):
             # the stage was stopped after writing its own deliverable and kept it (export.py's
             # --normalize pass): its message says so, and the file is this run's output too
@@ -843,11 +851,64 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
         # otherwise refuse as an existing file without --overwrite (#415).
         remember_written(out_path, dest)
         _record_own_stage_file(dest)
+    if outside:
+        unwatch_destination(dest)
     if key:
         cache_store(stage, key, out_path or (dest or ""), time.time() - started, doc)
     return out_path
 
 
+WORK_DIR: Dict[str, Optional[str]] = {"path": None}
+DELIVERY: Dict[str, Optional[str]] = {"path": None}  # the render's output path, set in main()
+
+
+def _is_delivery(path: str) -> bool:
+    return bool(DELIVERY["path"]) and os.path.realpath(path) == os.path.realpath(str(DELIVERY["path"]))
+
+
+def _in_work(path: str) -> bool:
+    """Whether `path` is inside this render's work directory."""
+    work = WORK_DIR["path"]
+    if not work:
+        return False
+    return os.path.realpath(path).startswith(os.path.realpath(work) + os.sep)
+
+
+SRT_TRIM_TOLERANCE = 0.25  # seconds the delivery may be shorter than the captioned stage before its SRT is called off-timeline
+
+
+def deliver_caption_srt(target: Optional[str], made: Optional[Dict[str, Any]], output: str) -> Optional[str]:
+    """Put the captions stage's generated SRT at `target` (<output>.srt, guarded before the first
+    stage) and return the path, or None with a skip record when it is not delivered: the stage was
+    served from the cache (the cache keeps the video only), or a later stage changed the timeline
+    (the export trimmed the delivery to a platform's maximum), where the SRT's times are no longer
+    the delivery's (#510). Under --dry-run the planned path."""
+    if not target or not made:
+        return None
+    if STATE.dry_run:
+        info(f"[dry-run] would deliver the captions' SRT as {target}")
+        return target
+    if made.get("cached") or not os.path.isfile(made["srt"]):
+        record_skip(f"the captions stage's SRT is not delivered: the stage was served from --cache, which keeps its video only",
+                    "caption_srt_not_delivered", reason="cached", path=target)
+        return None
+    trimmed = _LAST_DOC.get("trimmed") if _LAST_DOC.get("trimmed") else None
+    if not trimmed:
+        before = (probe(made["video"], role="output").get("duration") if os.path.isfile(made["video"]) else None) or 0.0
+        after = probe(output, role="output").get("duration") or 0.0
+        if before and after and before - after > SRT_TRIM_TOLERANCE:
+            trimmed = {"from": round(before, 3), "to": round(after, 3)}
+    if trimmed:
+        record_skip(f"the captions stage's SRT is not delivered: a later stage changed the timeline (the delivery was trimmed: "
+                    f"{trimmed}), so its cue times are not the delivery's", "caption_srt_not_delivered",
+                    reason="timeline_changed", path=target, trimmed=trimmed)
+        return None
+    place_output(made["srt"], target)
+    mark_delivered(target, side=True)  # kept after a stop, but not the run's `output` (#510 review)
+    info(f"delivered the captions' SRT as {target}")
+    return target
+
+
 def _stage_failure_hw(doc: Any) -> Dict[str, Any]:
     """A failed stage's `encoder` -- the command that failed -- for render's own failure document
     (absorb_stage() has already joined the stage's `hw` to the earlier stages'; a fallback before
@@ -974,9 +1035,26 @@ def cache_key(stage: str, script: str, argv: "Sequence[Any]", inputs: "Sequence[
         "hw": [os.environ.get(HW_ENV, "").strip().lower() in ("1", "true", "yes", "on"), os.environ.get(HW_FORCED_ENV) == "1"],
         "ffmpeg": CACHE.get("ffmpeg"), "skill": SKILL_VERSION, "contract": CONTRACT_VERSION,
     }
+    named = _brand_files_key(argv)
+    if named:
+        payload["brand_files"] = named  # only with --brand: every other stage's key is unchanged
     return hashlib.sha1(json.dumps(payload, sort_keys=True, ensure_ascii=False).encode(), usedforsecurity=False).hexdigest()
 
 
+def _brand_files_key(argv: "Sequence[Any]") -> List[Any]:
+    """The files a stage's --brand file names (its logo and font_file, resolved as load_brand()
+    resolves them): the key hashes the brand file's own bytes, so a font or a logo replaced under
+    the same name was served from the cache with the old one drawn (#510's sweep)."""
+    out: List[Any] = []
+    args = [str(a) for a in argv]
+    for i, a in enumerate(args[:-1]):
+        if a != "--brand" or not os.path.isfile(args[i + 1]):
+            continue
+        for key, path in brand_asset_files(args[i + 1]):
+            out.append([key, _content_hash(path) if os.path.isfile(path) else None])
+    return out
+
+
 def _cache_miss(stage: str, reason: str, **facts: Any) -> bool:
     """Record why `stage` was not served from the cache (`cache.miss_reasons`); a damaged entry
     (unreadable sidecar, artifact of the wrong size) is also a warning and an audit line in the
@@ -1225,7 +1303,7 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
              unbound_inputs=unbound)
         return 0
     info(f"executing plan {path}: {tool} " + " ".join(argv))
-    proc = run_tool([str(script)] + argv + child_args() + ["--json"])
+    proc = run_tool([str(script)] + with_flags(argv, child_args() + ["--json"]))  # before a `--` in the plan's argv
     for is_command, line in stderr_records(proc.stderr):
         if is_command and not line.startswith("[dry-run]"):
             STATE.commands.append(line)
@@ -1545,6 +1623,8 @@ def main() -> int:
     args = ap.parse_args()
     apply_common(args)
     PROJECT_SOURCE.update(src=None, timecode=[])
+    WORK_DIR["path"] = None
+    DELIVERY["path"] = None
     STATE.audit_log = os.path.abspath(args.audit_log) if args.audit_log else None
 
     if args.list_templates:
@@ -1675,6 +1755,9 @@ def main() -> int:
         passthrough = c0 is not None and c0.get("in") is None and c0.get("out") is None
         if not passthrough:
             refuse_copied_container(mid, output)
+    # #510: a filter or an encoder this build lacks is found by the stage that needs it; the dry run
+    # finds it before anything is encoded, so a real render runs its own dry run first
+    refuse_missing_components_first(str(HERE / "render.py"), "stage's filters and encoders")
     # A77: the default work directory is new for every run (mkdtemp), not named by the PID alone and
     # reused with exist_ok -- a later run that got the same PID deleted an earlier run's kept preview.
     # An explicit --work is the caller's: created when missing, never emptied.
@@ -1703,6 +1786,19 @@ def main() -> int:
         # a --work directory it created too, --keep or not (A99: a plan leaves nothing behind)
         import atexit
         atexit.register(lambda: shutil.rmtree(work, ignore_errors=True))
+        STATE.temp_dirs.append(str(work))  # removed at exit: a stop does not call its files kept (#510)
+    WORK_DIR["path"] = str(work)
+    DELIVERY["path"] = output
+    # #510: the captions stage's generated SRT is delivered beside the output, so its guards are
+    # the output's, once the output's folder exists (created above, as for the output) and
+    # before the first stage: an existing one, an input, the output itself
+    caption_srt = None
+    cap_cfg = proj.get("captions")
+    if (isinstance(cap_cfg, dict) and cap_cfg.get("text") and _reaches("captions", args.stop_after)
+            and (not args.stop_after or args.stop_after == "export")):
+        caption_srt = os.path.splitext(output)[0] + ".srt"
+        guard_sidecar(caption_srt, *([os.path.abspath(args.project)] if args.project else []), *project_input_files(proj, rel),
+                      siblings=(output,))
     frame = dict(proj.get("frame") or {})
     trans = proj.get("transition") or {}
     frame_from_preset(frame, proj.get("export") or {})
@@ -1720,6 +1816,7 @@ def main() -> int:
             and args.stop_after in (None, "export") and args.intermediate_preset != "medium" and not STATE.fast):
         INTERMEDIATE["preset"] = args.intermediate_preset
     stages_done: List[str] = []
+    captioned_srt: Optional[Dict[str, Any]] = None
     # what the caption stage reported (wrapped/split counts and the fit-size keys), so a caller
     # reading render.py's JSON can see whether the type was shrunk to fit or a cue was split.
     caption_report: Optional[Dict[str, Any]] = None
@@ -1948,6 +2045,9 @@ def main() -> int:
             if cap.get(k):
                 argv.append(flag)
         sh("caption.py", *(argv + brand_args + platform_args), stage="captions")
+        # the SRT caption.py generated from the cue file, beside its intermediate (#510); a cache hit
+        # places the video only, so there is none then
+        captioned_srt = {"srt": os.path.splitext(nxt)[0] + ".srt", "video": nxt, "cached": bool(_LAST_DOC.get("cached"))}
         if isinstance(_LAST_DOC.get("caption"), dict):
             caption_report = dict(_LAST_DOC["caption"])
         current = nxt
@@ -2093,13 +2193,14 @@ def main() -> int:
     current = output
     if not STATE.dry_run:
         mark_delivered(output)  # the chapters and check stages run on it: a stop from here keeps it, and says so (#415)
+    caption_srt = deliver_caption_srt(caption_srt, captioned_srt, output)
     if args.stop_after == "export":
         # A87: the chapters and check stages ran after "--stop-after export", and a "check" this
         # run never reads (validate_project() skips it) was then read with .get(): a traceback
         if not args.keep and not args.work:
             shutil.rmtree(work, ignore_errors=True)
         emit(output, stages=stages_done, check=None, cache=cache_report(args.cache),
-             intermediate_preset=_intermediate_used())
+             intermediate_preset=_intermediate_used(), caption_srt=caption_srt)
         return 0
 
     # ---- chapters (metadata.py on the delivered file: streams copied, markers written)
@@ -2191,7 +2292,7 @@ def main() -> int:
         snap_report = dict(snap_reports[0])
         snap_report["clips"] = snap_reports
     emit(output, stages=stages_done, check=check_result, snap=snap_report, cache=cache_report(args.cache),
-         caption=caption_report, intermediate_preset=_intermediate_used(),
+         caption=caption_report, intermediate_preset=_intermediate_used(), caption_srt=caption_srt,
          verification=[{"step": "check", "ok": True, "platform": ck.get("platform")}] if check_result else [])
     return 0
 

package/scripts/reverse.py

@@ -15,7 +15,7 @@ import argparse
 import math
 import sys
 
-from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, emit, ffmpeg_base, info, probe, run, video_args, X264_PRESETS, fmt_secs
+from _common import add_common, apply_common, aac_args, cfr_args, cfr_filter, default_output, die, emit, ffmpeg_base, info, probe, run, video_args, X264_PRESETS, fmt_secs
 from _common.emit import warn
 from _common.decision import (HELD_FRAMES_WARN_BYTES, av_clip_length, av_trim, delivered_rate, frame_durations, frame_rate,
                               held_frames_bytes, stream_starts)
@@ -49,6 +49,17 @@ def main() -> int:
              f"({vdur:.0f}s of {v['width']}x{v['height']}) -- cut the part to reverse first (cut.py) if RAM is tight",
              "memory_heavy", duration=meta.get("duration"), bytes=held)
     cmd = ffmpeg_base() + ["-i", args.input]
+    # A VFR source is put on the delivered grid before the reversal (#523). `reverse` hands its
+    # frames the forward timestamps in order, so a reversed VFR picture kept its gaps where they
+    # were in forward time: every flash of the 27 fps average clip came 0.19 s late against the
+    # reversed sound (0.23 s without sound). On a constant grid the reversed picture is the forward
+    # one mirrored. Each slot takes the last frame that starts before the slot ends (round=down),
+    # which is the frame the reversed slot opens on: the nearest frame to its start (the forward
+    # conform's choice) dropped a last frame that starts after the last slot's middle, and the
+    # reversal then opened on the frame before it. The conformed picture's time base is one frame,
+    # and a trim rescales its bound to it (a half-frame bound can round onto a frame and cut it:
+    # freeze.py), so a microsecond base follows.
+    reversed_conform = f"{cfr_filter(meta)}:round=down,settb=AVTB" if cfr_filter(meta) else ""
     if has_audio:
         # Both streams are reversed about one end (#409); each reversed about its own end put a sound
         # 0.6 s longer than its picture 0.396 s off. As in a join, both start at the first frame (the
@@ -73,13 +84,14 @@ def main() -> int:
         vlen = meta["video"].get("duration") or length
         end = math.ceil(length * rate - 1e-6) / rate
         vtrim, atrim = av_trim(stream_starts(meta)[0], None)
+        conform = f"{reversed_conform}," if reversed_conform else ""
         cmd += ["-filter_complex",
                 f"[0:v:0]tpad=stop_mode=clone:stop_duration={max(0.0, end - vlen) + 2 / rate:.6f},{vtrim},"
-                f"trim=end={end - 0.5 / max(rate, frame_rate(meta) or rate):.6f},reverse,{frame_durations(meta, rate)}[v];"
+                f"{conform}trim=end={end - 0.5 / max(rate, frame_rate(meta) or rate):.6f},reverse,{frame_durations(meta, rate)}[v];"
                 f"[0:a:0]{atrim},apad=whole_dur={end:.6f},atrim=end={end:.6f},areverse,asetpts=N/SR/TB[a]",
                 "-map", "[v]", "-map", "[a]"]
     else:
-        cmd += ["-vf", "reverse"]
+        cmd += ["-vf", f"{reversed_conform},reverse" if reversed_conform else "reverse"]
     cmd += video_args(meta, args.crf, args.preset)
     cmd += cfr_args(meta)
     if has_audio:

package/scripts/speedramp.py

@@ -18,9 +18,9 @@ Examples:
 import argparse
 import sys
 from fractions import Fraction
-from typing import List, Tuple
+from typing import Any, List, Tuple
 
-from _common.decision import av_trim, conform_filter, delivered_rate, frame_durations, frame_rate, grid_at_or_after, stream_starts
+from _common.decision import atempo_chain_with_lead, av_trim, conform_filter, delivered_rate, frame_durations, frame_rate, grid_at_or_after, stream_starts
 from _common import add_common, apply_common, aac_args, default_output, die, emit, ffmpeg_base, info, probe, run, video_args, X264_PRESETS, fmt_secs, time_arg
 from _common.emit import input_length
 
@@ -28,18 +28,20 @@ MAX_SPEED = 20.0
 MIN_SPEED = 0.05
 
 
-def atempo_chain(factor: float) -> str:
-    """atempo accepts 0.5..100 per instance; chain for factors outside that range."""
+def atempo_chain(factor: float, sample_rate: Any = 0) -> str:
+    """atempo accepts 0.5..100 per instance; chain for factors outside that range. The chain is
+    led by the samples atempo leaves out (atempo_chain_with_lead, at the track's `sample_rate`):
+    without them every segment's sound came out 21 ms early at 1x and 40 ms at 0.5x (#523)."""
     parts: List[str] = []
     remaining = factor
     while remaining < 0.5:
-        parts.append("atempo=0.5")
+        parts.append("0.5")
         remaining /= 0.5
     while remaining > 100.0:
-        parts.append("atempo=100.0")
+        parts.append("100.0")
         remaining /= 100.0
-    parts.append(f"atempo={remaining:.6f}")
-    return ",".join(parts)
+    parts.append(f"{remaining:.6f}")
+    return atempo_chain_with_lead(parts, sample_rate)
 
 
 def parse_segment(raw: str) -> Tuple[float, float, float]:
@@ -118,7 +120,8 @@ def main() -> int:
         # leaves at the unscaled 1/rate, so every 2x segment pushed the rest of the picture two
         # frames late against the sound (and added those frames)
         vchain = f"[0:v]{vtrim},setpts=PTS/{factor:.6f},{frame_durations(meta, out_rate)}"
-        achain = f"[0:a]{atrim},{atempo_chain(factor)}"
+        # a 1x segment is not retimed: atempo would place its sound by windows for nothing (#541)
+        achain = f"[0:a]{atrim}" if factor == 1.0 else f"[0:a]{atrim},{atempo_chain(factor, srate)}"
         if out_rate:
             # Each segment holds the frames (and samples) between its retimed ends on the whole
             # output's grid, not its own length rounded: eight 0.5 s segments at 27 fps rounded

package/scripts/waveform.py

@@ -42,6 +42,7 @@ from _common import (add_common, apply_common, aac_args, color_hex, default_outp
                      info, load_brand, pad_filters, probe, rgb_chain_to_bt709, run, STATE, validate_color, video_args, X264_PRESETS,
                      fmt_secs, child_args, run_tool, measured_level_dbfs, sibling_temp)
 from _common.emit import absorb_stage_hw, note, warn
+from _common.runner import refuse_missing_components_first
 from _common.decision import length_output_t
 from _common.probe import AUDIO_MEDIA_EXT
 
@@ -261,6 +262,10 @@ def main() -> int:
         drawn_track = audio_streams[args.audio_stream] if audio_streams else meta["audio"]
         cmd += ["-t", length_output_t(float(meta["duration"]), drawn_track.get("sample_rate"))]
     cmd += ["-shortest", render]
+    if args.title or args.srt or args.text:
+        # #510: the title and captions are later stages; one that needs a filter this build lacks
+        # (drawtext, subtitles) is refused before the visualisation is encoded, as the dry run is
+        refuse_missing_components_first(os.path.abspath(__file__), "stage's filters and encoders")
     titled_tmp = sibling_temp(output, "titled")
     intermediates = [p for p in (render, titled_tmp) if p != output]
     try: