ffmpeg-skill 3.6.1 → 3.6.2

package/scripts/overlay.py

@@ -31,11 +31,11 @@ with libvpx-vp9, so its transparency reaches the composite (FFmpeg's own VP9 dec
 import argparse
 import re
 import sys
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, safe_margins_px, resolve as resolve_platform
 from _common import still_input_args  # noqa: E402
-from _common import STATE, script_font_for_text, drawtext_clean, drawtext_line_metrics, drawtext_text_opts, drawtext_draws_newline_glyph, is_multiline, needs_shaping, LANGUAGE_NAMES, has_emoji, detect_script, emoji_clusters, load_brand, drawn_chain, label_chain, layer_base_chain, matrix_chain, range_chain, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, escape_drawtext, ffmpeg_base, info, parse_time, probe, run, run_keeping_subtitles, validate_color, x264_args, X264_PRESETS, time_arg, fmt_secs
+from _common import STATE, script_font_for_text, drawtext_clean, drawtext_line_metrics, drawtext_text_opts, drawtext_draws_newline_glyph, is_multiline, needs_shaping, LANGUAGE_NAMES, has_emoji, detect_script, emoji_clusters, load_brand, drawn_chain, label_chain, layer_base_chain, matrix_chain, overlay_format, range_chain, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, escape_drawtext, ffmpeg_base, info, parse_time, probe, run, run_keeping_subtitles, validate_color, x264_args, X264_PRESETS, time_arg, fmt_secs
 from _common.emit import note, warn
 from _common.alpha import (add_alpha_args, audio_line, check_alpha_args, decoder_args_for, default_ext, finish_chain,
                            has_alpha_plane, report as alpha_report, source_alpha, tag_args, video_line)
@@ -428,7 +428,9 @@ def main() -> int:
             if end is not None and end > args.fade:
                 chain.append(f"fade=t=out:st={end - args.fade:.3f}:d={args.fade:g}:alpha=1")
         x, y = position_exprs(args.position, args.margin, text_mode=False, margins=safe_margins)
-        ov = f"overlay={x}:{y}:format=auto"
+        # a 10-bit main on a 10-bit line is composited at 10 bits in YUV: format=auto with an RGBA
+        # still took the whole picture through 8-bit RGB (overlay_format)
+        ov = f"overlay={x}:{y}" + (overlay_format(meta) or ":format=auto")
         if enable:
             ov += f":enable='{enable}'"
         # -loop 1 turns the still into a timed stream so fade/enable expressions see real timestamps
@@ -480,13 +482,18 @@ def main() -> int:
         elif args.scale:
             chain.append(f"scale={args.scale}:-2")
         # an alpha line composites at 4:4:4: the layer is not taken through 4:2:0 on the way
-        chain.append("format=yuva444p" if alpha_codec else "format=yuva420p")
+        # a 10-bit layer over a main overlay_format() composites at 10 bits stays 10-bit
+        deep = bool(overlay_format(meta)) and (pip_meta["video"].get("bit_depth") or 8) > 8
+        chain.append("format=yuva444p" if alpha_codec else "format=yuva420p10le" if deep else "format=yuva420p")
         if args.chromakey:
             chain.append(f"chromakey={args.chromakey}:{args.chromakey_similarity:g}:{args.chromakey_blend:g}")
         if args.opacity < 1:
-            chain.append(f"colorchannelmixer=aa={args.opacity:g}")
+            # the alpha is scaled in YUV: colorchannelmixer takes RGB only, so FFmpeg converted the
+            # layer to RGB and overlay=format=auto then composited the whole main picture in RGB,
+            # which came back BT.601 under the BT.709 tag (#333's defect, on this path)
+            chain.append(f"lut=y=val:u=val:v=val:a=val*{args.opacity:g}")
         x, y = position_exprs(args.position, args.margin, text_mode=False, margins=safe_margins)
-        ov = f"overlay={x}:{y}:format=auto"
+        ov = f"overlay={x}:{y}" + (overlay_format(meta) or ":format=auto")
         if enable:
             ov += f":enable='{enable}'"
         # a VP9 layer stored with an alpha layer is decoded with libvpx-vp9: FFmpeg's own decoder
@@ -501,7 +508,13 @@ def main() -> int:
             # converted to BT.709 YUV with its alpha plane: the 4:4:4 the conversion ends in had none,
             # and the layer covered the picture as an opaque rectangle
             pip = pip.replace("format=yuv444p", "format=yuva444p")
-        if base or pip:
+        # an untagged picture is labelled beside a converted one, and beside a tagged one too: FFmpeg
+        # 8.0's overlay negotiates one colorspace for both inputs, and a BT.709-tagged main under an
+        # untagged PiP was converted to the PiP's "unknown" (BT.601) matrix, away from the PiP too
+        # (C03028 at 80/110/192 came back 88/103/192 on 8.0.1). Two untagged pictures agree as they are.
+        def tagged(m: Dict[str, Any]) -> bool:
+            return ((m.get("video") or {}).get("color_space") or "unknown") not in ("unknown", "unspecified")
+        if base or pip or tagged(meta) != tagged(pip_meta):
             base, pip = base or label_chain(meta, meta), pip or label_chain(pip_meta, meta)
         # overlay mixes samples: a full-range picture is taken to limited range (#410)
         base, pip = base + range_chain(meta, meta), pip + range_chain(pip_meta, meta)

package/scripts/redact.py

@@ -27,7 +27,7 @@ Examples:
 import argparse
 import sys
 
-from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
+from _common import add_common, overlay_format, apply_common, aac_args, cfr_args, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
 from _common.emit import note
 from _common.probe import display_size, square_pixels, square_pixels_note
 
@@ -110,7 +110,7 @@ def main() -> int:
             region = f"{crop},boxblur={radius}:{radius}:{chroma}:{radius}"
         else:
             region = f"{crop},scale={max(1, args.width // args.block_size)}:{max(1, args.height // args.block_size)}:flags=neighbor,scale={args.width}:{args.height}:flags=neighbor"
-        fc = f"[0:v]{square + ',' if square else ''}split=2[base][region];[region]{region}[patched];[base][patched]overlay={args.x}:{args.y}[out]"
+        fc = f"[0:v]{square + ',' if square else ''}split=2[base][region];[region]{region}[patched];[base][patched]overlay={args.x}:{args.y}{overlay_format(meta)}[out]"
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", fc, "-map", "[out]"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]

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:
@@ -1260,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)
@@ -1407,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")
@@ -1464,7 +1471,7 @@ def main() -> int:
                     # 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 += [flag, str(value)]
+                argv += option_args(flag, value)
         argv += brand_args
         sh("waveform.py", *argv, stage="audiogram")
         current = nxt
@@ -1480,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":
@@ -1499,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")
@@ -1536,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")
@@ -1560,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)
@@ -1578,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
@@ -1601,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"])]
@@ -1611,7 +1618,7 @@ def main() -> int:
                         ("chromakey", "--chromakey"), ("chromakey_similarity", "--chromakey-similarity"), ("chromakey_blend", "--chromakey-blend")):
             if ov.get(k) is not None:
                 # font_file is a path: the same one project_input_files() guards
-                argv += [flag, rel(ov[k]) if k == "font_file" and ov[k] else str(ov[k])]
+                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
@@ -1647,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)
@@ -1672,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")
@@ -1687,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]