ffmpeg-skill 3.6.0 → 3.6.2

package/scripts/render.py

@@ -74,9 +74,10 @@ 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, info, 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 import guard_sidecar, STATE, add_common, aspect_ratio, brand_caption_style, load_brand, apply_common, child_args, die, 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, remember_written
 from _common.emit import absorb_stage, audit, record_fallback, record_skip, refuse, warn
+from _common.decision import rebase_project_paths
 import subprocess
 from _contract import CONTRACT_VERSION
 from batch import file_key
@@ -362,7 +363,7 @@ def render_pack(names: List[str], args) -> int:
                             ("--chapters", args.chapters), ("--image", args.image),
                             ("--intermediate-preset", args.intermediate_preset)):
             if value:
-                argv += [flag, str(value)]
+                argv += option_args(flag, value)
         info(f"→ pack: {name}")
         proc = run_tool(argv + child_args() + ["--json"])
         try:
@@ -464,6 +465,64 @@ def check_overlay(ov: Any, label: str) -> None:
         die(f"{label}: scale sizes an image, logo or video layer; text size is font_size", kind="input")
 
 
+def project_input_files(proj: Dict[str, Any], rel: Any) -> List[str]:
+    """Every file a project names as an input: clip sources, music/replace/effects, the brand,
+    caption files (a --text value that names an existing file), overlay images, videos and fonts, the
+    audiogram image, a beat grid's source and the chapters file. Values of the wrong type are left
+    to the stage that reads them."""
+    found: List[str] = []
+
+    def add(value: Any, must_exist: bool = False) -> None:
+        if isinstance(value, str) and value:
+            p = rel(value)
+            if not must_exist or os.path.isfile(p):
+                found.append(p)
+
+    for c in proj.get("clips") or []:
+        if isinstance(c, dict):
+            add(c.get("src"))
+            if isinstance(c.get("snap"), dict):
+                add(c["snap"].get("source"))
+    for key in ("audio", "captions", "audiogram", "snap"):
+        if not isinstance(proj.get(key), dict):
+            continue
+        obj = proj[key]
+        if key == "audio":
+            for k in ("music", "replace", "effects"):
+                add(obj.get(k))
+        elif key == "captions":
+            add(obj.get("srt"))
+            add(obj.get("ass"))
+            add(obj.get("text"), must_exist=True)  # inline cue text is not a path
+        elif key == "audiogram":
+            add(obj.get("image"))
+        else:
+            add(obj.get("source"))
+    add(proj.get("brand"))
+    brand = proj.get("brand")
+    if isinstance(brand, str) and brand:
+        # the brand's own logo and font_file are read by the overlay and caption stages, resolved
+        # against the brand file as load_brand() resolves them; an unreadable brand is left to them
+        try:
+            data = json.loads(Path(rel(brand)).read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            data = None
+        if isinstance(data, dict):
+            base = Path(rel(brand)).resolve().parent
+            for k in ("logo", "font_file"):
+                v = data.get(k)
+                if isinstance(v, str) and v and "://" not in v:
+                    found.append(v if os.path.isabs(v) else str(base / v))
+    add(proj.get("chapters"), must_exist=True)
+    overlays = proj.get("overlays")
+    for ov in (overlays if isinstance(overlays, list) else []):  # any other type is the overlay stage's to refuse
+        if isinstance(ov, dict):
+            add(ov.get("image"))
+            add(ov.get("video"))
+            add(ov.get("font_file"))
+    return found
+
+
 def require_object(obj: Any, label: str) -> None:
     """Refuse a value that is not an object where the run reads it with .get(): "export": "reels"
     in a render, a string frame, a clip written as a bare path. 2.2.1 died there with a traceback
@@ -1202,6 +1261,12 @@ def main() -> int:
         emit(args.write_project, template=args.template, stages=[], check=None)
         return 0
 
+    # every file the project names is read against the project file's directory (a template's,
+    # the working directory): the same keys batch.py and multicam.py rebase on a copy they write
+    # elsewhere, including the two rel() below never saw (audiogram.image, overlays[].font_file
+    # were read against the working directory)
+    proj = rebase_project_paths(proj, base)
+
     def rel(p: Any) -> str:
         p = str(p)
         return p if os.path.isabs(p) else str(base / p)
@@ -1216,8 +1281,13 @@ def main() -> int:
     if not clips:
         die("project.clips is empty")
     output = rel(proj.get("output") or "final.mp4")
-    # the final stage is a copy from the work dir, so run()'s own guard never sees the sources (review 5)
-    refuse_output_is_input(output, *[rel(c.get("src")) for c in clips if c.get("src")])
+    # the final stage is a copy from the work dir, so run()'s own guard never sees the sources
+    # (review 5): every file the project names is passed here, not only the clips, or --overwrite
+    # replaced a music bed or a brand file named as the output
+    if not args.stop_after or args.stop_after == "export":
+        # only a run that ends in the final copy writes `output`; a --stop-after preview writes
+        # its stage file inside the work directory and leaves `output` alone
+        refuse_output_is_input(output, *([os.path.abspath(args.project)] if args.project else []), *project_input_files(proj, rel))
     if _reaches("overlays", args.stop_after):
         # #326: an overlay video is the caller's file, never an earlier stage's output, so a
         # missing one is refused here, under --dry-run too, not after every stage before it ran
@@ -1344,17 +1414,17 @@ def main() -> int:
         if needs_cut:
             argv: List[Any] = [src, "-o", part, "--accurate"]
             if c.get("in") is not None:
-                argv += ["--start", c["in"]]
+                argv += option_args("--start", c["in"])
             if c.get("out") is not None:
-                argv += ["--end", c["out"]]
+                argv += option_args("--end", c["out"])
             clip_snap = dict(snap_spec)
             clip_snap.update(c.get("snap") or {})
             if str(clip_snap.get("to") or "none") == "beats":
                 argv += ["--snap", "beats"]
                 if clip_snap.get("tolerance") is not None:
-                    argv += ["--snap-tolerance", str(clip_snap["tolerance"])]
+                    argv += option_args("--snap-tolerance", clip_snap["tolerance"])
                 if clip_snap.get("min_confidence") is not None:
-                    argv += ["--min-confidence", str(clip_snap["min_confidence"])]
+                    argv += option_args("--min-confidence", clip_snap["min_confidence"])
                 if clip_snap.get("source"):
                     argv += ["--snap-source", rel(clip_snap["source"])]
             sh("cut.py", *argv, stage="clips")
@@ -1396,7 +1466,12 @@ def main() -> int:
                           ("color", "--color"), ("background", "--background"),
                           ("width", "--width"), ("height", "--height"), ("fps", "--fps")):
             if ag.get(key) is not None:
-                argv += [flag, str(ag[key])]
+                value = ag[key]
+                if key == "image" and isinstance(value, str) and "://" not in value:
+                    # against the project file, as every other path here and as the output guard
+                    # checks it; it used to reach waveform.py as written, against the cwd
+                    value = rel(value)
+                argv += option_args(flag, value)
         argv += brand_args
         sh("waveform.py", *argv, stage="audiogram")
         current = nxt
@@ -1412,11 +1487,11 @@ def main() -> int:
         current = str(work / f"joined{mid}")
         argv = list(parts) + ["-o", current, "--transition", trans.get("type", "fade"), "--duration", str(trans.get("duration", 0.5))]
         if frame.get("width"):
-            argv += ["--width", str(frame["width"])]
+            argv += option_args("--width", frame["width"])
         if frame.get("height"):
-            argv += ["--height", str(frame["height"])]
+            argv += option_args("--height", frame["height"])
         if frame.get("fps"):
-            argv += ["--fps", str(frame["fps"])]
+            argv += option_args("--fps", frame["fps"])
         sh("join.py", *argv, stage="join")
         stages_done.append("join")
     if args.stop_after == "join":
@@ -1431,7 +1506,7 @@ def main() -> int:
         for k, flag in (("threshold", "--threshold"), ("min_silence", "--min-silence"), ("margin", "--margin"),
                         ("margin_lead", "--margin-lead"), ("margin_tail", "--margin-tail")):
             if sil.get(k) is not None:
-                argv += [flag, str(sil[k])]
+                argv += option_args(flag, sil[k])
         sh("silence.py", *argv, stage="silence")
         current = nxt
         stages_done.append("silence")
@@ -1468,7 +1543,7 @@ def main() -> int:
         argv = [current, "-o", nxt]
         for k, flag in (("duration", "--duration"), ("method", "--method"), ("aspect", "--aspect"), ("fit", "--fit"), ("width", "--width"), ("height", "--height"), ("fps", "--fps"), ("smooth", "--smooth")):
             if fit.get(k) is not None:
-                argv += [flag, str(fit[k])]
+                argv += option_args(flag, fit[k])
         sh("fit.py", *argv, stage="fit")
         current = nxt
         stages_done.append("fit")
@@ -1492,7 +1567,7 @@ def main() -> int:
         for k, flag in (("font", "--font"), ("size", "--size"), ("color", "--color"), ("position", "--position"), ("margin", "--margin"), ("animate", "--animate"), ("highlight_color", "--highlight-color"), ("outline", "--outline"), ("lang", "--lang"), ("offset", "--offset"), ("max_lines", "--max-lines"), ("min_duration", "--min-duration"),
                         ("fit_size", "--fit-size"), ("min_size", "--min-size"), ("fit_size_scope", "--fit-size-scope")):
             if cap.get(k) is not None:
-                argv += [flag, str(cap[k])]
+                argv += option_args(flag, cap[k])
         for k, flag in (("karaoke", "--karaoke"), ("bold", "--bold"), ("box", "--box")):
             if cap.get(k):
                 argv.append(flag)
@@ -1510,11 +1585,11 @@ def main() -> int:
         nxt = str(work / f"graphics{i:02d}{mid}")
         if not g.get("template"):
             die(f"graphics[{i}] needs a template")
-        argv = [current, "-o", nxt, "--template", g["template"]]
+        argv = [current, "-o", nxt] + option_args("--template", g["template"])
         for k, flag in (("name", "--name"), ("title", "--title"), ("subtitle", "--subtitle"), ("start", "--start"), ("end", "--end"), ("position", "--position"), ("from", "--from"), ("scale", "--scale"), ("primary", "--primary"), ("text_color", "--text-color"), ("lang", "--lang"),
                         ("text", "--text"), ("top", "--top"), ("bottom", "--bottom"), ("duration", "--duration"), ("margin", "--margin"), ("platform", "--platform")):
             if g.get(k) is not None:
-                argv += [flag, str(g[k])]
+                argv += option_args(flag, g[k])
         # the entry's own "platform" is the more specific statement than the template's destination
         sh("graphics.py", *(argv + brand_args + ([] if g.get("platform") else platform_args)), stage="graphics")
         current = nxt
@@ -1533,7 +1608,7 @@ def main() -> int:
         elif ov.get("image"):
             argv += ["--image", rel(ov["image"])]
         elif ov.get("text"):
-            argv += ["--text", ov["text"]]
+            argv += option_args("--text", ov["text"])
         elif ov.get("video"):
             # #326: sized and placed here, after fit, against the frame that ships
             argv += ["--video", rel(ov["video"])]
@@ -1542,7 +1617,8 @@ def main() -> int:
         for k, flag in (("position", "--position"), ("start", "--start"), ("end", "--end"), ("fade", "--fade"), ("opacity", "--opacity"), ("scale", "--scale"), ("font_size", "--font-size"), ("font", "--font"), ("font_file", "--font-file"), ("margin", "--margin"), ("platform", "--platform"),
                         ("chromakey", "--chromakey"), ("chromakey_similarity", "--chromakey-similarity"), ("chromakey_blend", "--chromakey-blend")):
             if ov.get(k) is not None:
-                argv += [flag, str(ov[k])]
+                # font_file is a path: the same one project_input_files() guards
+                argv += option_args(flag, rel(ov[k]) if k == "font_file" and ov[k] else ov[k])
         if ov.get("box"):
             argv.append("--box")
         # review 12: the overlay stage was the one stage that never heard which destination this
@@ -1578,10 +1654,10 @@ def main() -> int:
                 argv += [flag, rel(au[k])]
         for k, flag in (("music_volume", "--music-volume"), ("effects_volume", "--effects-volume"), ("fade_in", "--fade-in"), ("fade_out", "--fade-out"), ("music_fade_out", "--music-fade-out"), ("gain", "--gain"), ("duck_amount", "--duck-amount"), ("duck_threshold", "--duck-threshold"), ("duck_attack", "--duck-attack"), ("duck_release", "--duck-release"), ("stereo_widen", "--stereo-widen")):
             if au.get(k) is not None:
-                argv += [flag, str(au[k])]
+                argv += option_args(flag, au[k])
         # "voice": true is the medium chain; "voice": "light"|"medium"|"strong" names one
         if au.get("voice") is not None and au.get("voice") is not False:
-            argv += ["--voice"] + ([] if au["voice"] is True else [str(au["voice"])])
+            argv += ["--voice"] if au["voice"] is True else option_args("--voice", au["voice"])
         for k, flag in (("denoise", "--denoise"), ("duck", "--duck"), ("music_loop", "--music-loop"), ("stereo", "--stereo"), ("mono", "--mono"), ("downmix", "--downmix")):
             if au.get(k):
                 argv.append(flag)
@@ -1603,9 +1679,9 @@ def main() -> int:
         nxt = str(work / f"loudnorm{mid}")
         argv = [current, "-o", nxt]
         if ld.get("lufs") is not None:
-            argv += ["-I", str(ld["lufs"])]
+            argv += option_args("--lufs", ld["lufs"])
         if ld.get("tp") is not None:
-            argv += ["--tp", str(ld["tp"])]
+            argv += option_args("--tp", ld["tp"])
         sh("loudness.py", *argv, stage="loudness")
         current = nxt
         stages_done.append("loudness")
@@ -1618,9 +1694,9 @@ def main() -> int:
     if ex and ex.get("preset"):
         argv = [current, "--preset", ex["preset"], "-o", output]
         if ex.get("fit"):
-            argv += ["--fit", ex["fit"]]
+            argv += option_args("--fit", ex["fit"])
         if ex.get("crf") is not None:
-            argv += ["--crf", str(ex["crf"])]
+            argv += option_args("--crf", ex["crf"])
         normalize = ex.get("normalize")
         if normalize is None and ex["preset"] in PLATFORM_OF and not proj.get("loudness"):
             # eval 8: a reels project without the key rendered fully, failed the loudness check and

package/scripts/silence.py

@@ -82,14 +82,17 @@ def silence_positions(silences: List[Tuple[float, float]], words: "list",
     of the word after (on demos/footage/ai_talk_en.mp4 three word starts sit 0.45 to 0.5 s before
     the sound does), and a word's midpoint stays on its own side of the pause either way. A
     silence with no word before it is `inside`."""
+    import bisect
     timed = sorted(words, key=lambda w: w["start"] + w["end"])
+    mids = [(w["start"] + w["end"]) / 2 for w in timed]
     out: List[str] = []
     for s, e in silences:
         if e == float("inf"):
             e = max(s, duration) if duration is not None else s
-        ref = (s + e) / 2
-        before = [w for w in timed if (w["start"] + w["end"]) / 2 < ref]
-        out.append("sentence_end" if before and ends_sentence(before[-1]["word"]) else "inside")
+        # the last word whose midpoint is before the silence's: a binary search, not a scan of the
+        # whole transcript per silence (an hour of speech has thousands of each)
+        k = bisect.bisect_left(mids, (s + e) / 2)
+        out.append("sentence_end" if k and ends_sentence(timed[k - 1]["word"]) else "inside")
     return out
 
 

package/scripts/speedramp.py

@@ -19,7 +19,7 @@ import argparse
 import sys
 from typing import List, Tuple
 
-from _common.decision import av_trim, frame_rate, grid_at_or_after, stream_starts
+from _common.decision import av_trim, 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
 
 MAX_SPEED = 20.0
@@ -106,7 +106,11 @@ def main() -> int:
             die(f"--segment {start:g}-{end:g}:{factor:g} holds no frame: both ends fall on the frame at "
                 f"{bounds[i]:.3f}s; widen it or merge it into a neighbour")
         vtrim, atrim = av_trim(bounds[i], seg_end, rate)
-        vparts.append(f"[0:v]{vtrim},setpts=PTS/{factor:.6f}[{vlabel}]")
+        # the closing fps puts the sped-up frames back on the source's grid with its frame
+        # duration: concat starts the next segment after the last frame's duration, which setpts
+        # 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)
+        vparts.append(f"[0:v]{vtrim},setpts=PTS/{factor:.6f},{frame_durations(meta, rate)}[{vlabel}]")
         labels.append(f"[{vlabel}]")
         if has_audio:
             aparts.append(f"[0:a]{atrim},{atempo_chain(factor)}[{alabel}]")

package/scripts/sync.py

@@ -35,7 +35,8 @@ from typing import Dict, List
 from _common.runner import fail_if_classified
 from _common import video_args, add_common, apply_common, emit, aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, x264_args, decode_pcm_mono, rms_envelope
 from _common.emit import record_skip, warn
-from _common.decision import stream_starts
+from _common.decision import SEEK_MARGIN, frame_rate, grid_at_or_after, stream_starts
+from _common.timeline import output_timecode_args
 
 SR = 8000  # decode sample rate
 
@@ -385,7 +386,12 @@ def main() -> int:
                 cmd = cmd[:-1] + video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf) + [output]
                 run(cmd)
         else:
-            if head_trim > 0 and not drift_af:
+            # A picture is never stream-copied here: a copy starts at the keyframe at or before -ss
+            # and -avoid_negative_ts make_zero shows the frames from it, so the output started
+            # early by up to a GOP (a 5 s GOP: nothing trimmed at all) and was reported as synced.
+            # Even a keyframe on the trim point moved the picture by its B-frame delay (+69 ms).
+            # The re-encode below starts on the frame itself; a sound-only file is still copied.
+            if head_trim > 0 and not drift_af and not has_video:
                 cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second, "-c", "copy"]
                 if os.path.splitext(output)[1].lower() in (".mp4", ".mov", ".m4v"):
                     cmd += ["-movflags", "+faststart"]
@@ -396,10 +402,20 @@ def main() -> int:
                     cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + (video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf) if has_video else []) + audio_codec_for(output) + [output]
                     run(cmd)
             else:
+                # Seek SEEK_MARGIN early and drop the margin on the output side, as cut.py's
+                # re-encode does: an input seek straight to head_trim can land (the MP4 demuxer
+                # seeks over raw decode times) on a keyframe whose picture comes after it, and a
+                # B-frame HEVC file lost the frames before it. The output-side -ss decodes and
+                # drops the margin from both streams alike; it counts on the output's clock, which
+                # a drift fix runs faster by drift_ratio (setpts and asetrate alike).
                 cmd = ffmpeg_base()
+                out_seek: List[str] = []
                 if head_trim > 0:
-                    cmd += ["-ss", f"{head_trim:.4f}"]
-                cmd += ["-i", args.second]
+                    m = min(SEEK_MARGIN, head_trim)
+                    cmd += ["-ss", f"{head_trim - m:.6f}"]
+                    if m > 0:
+                        out_seek = ["-ss", f"{m / (drift_ratio if drift_af else 1.0):.6f}"]
+                cmd += ["-i", args.second] + out_seek
                 af_parts = on_clock + drift_af
                 if delay_ms > 0:
                     af_parts.append(f"adelay={delay_ms}:all=1")
@@ -412,6 +428,14 @@ def main() -> int:
                     if vf:
                         cmd += ["-vf", ",".join(vf)]
                     cmd += video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf)
+                    # the output's first frame is the second file's frame at head_trim, or (padded)
+                    # one `offset` before its first: its start timecode moves with it
+                    v0, rate = stream_starts(second_meta)[0], frame_rate(second_meta)
+                    # (a trim before a picture that starts after the file's origin starts on its
+                    # first frame; only the padded head counts back before it)
+                    first = (grid_at_or_after(max(round(head_trim, 4), v0), v0, rate) - v0 if head_trim > 0
+                             else -offset if delay_ms > 0 else 0.0)
+                    cmd += output_timecode_args(second_meta, first)
                 if af_parts:
                     cmd += ["-af", ",".join(af_parts)]
                 cmd += audio_codec_for(output) + [output]