ffmpeg-skill 3.6.4 → 3.6.6

package/scripts/render.py

@@ -75,7 +75,7 @@ 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, 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.runner import HW_ENV, HW_FORCED_ENV, add_hw_orchestrator_args, child_exit_code, found_exe, kept_clause, kept_deliverables, mark_delivered, read_json, remember_written
 from _common.emit import absorb_stage, audit, record_fallback, record_skip, refuse, warn
 from _common.decision import rebase_project_paths
 import subprocess
@@ -182,7 +182,7 @@ def load_template(name: str) -> Dict[str, Any]:
     if not path.is_file():
         die(f"unknown template {name!r}", hint="templates: " + ", ".join(template_names()) + " (or 'all')")
     try:
-        return json.loads(path.read_text(encoding="utf-8"))
+        return read_json(path)
     except (OSError, ValueError) as exc:
         die(f"cannot read template {path}: {exc}")
     return {}
@@ -504,7 +504,7 @@ def project_input_files(proj: Dict[str, Any], rel: Any) -> List[str]:
         # 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"))
+            data = read_json(rel(brand))
         except (OSError, ValueError):
             data = None
         if isinstance(data, dict):
@@ -565,6 +565,14 @@ def validate_project(proj: Dict[str, Any], timeline: bool = False, stop_after: O
             require_object(proj.get(name), name)
         check_keys(proj.get(name), name, name)
     check_keys((proj.get("audio") or {}).get("stems"), "audio.stems", "audio.stems")
+    # the values the run reads with .get() or as a dict key: a list there was a traceback (A13)
+    audio = proj.get("audio")
+    if "audio" in read and isinstance(audio, dict):
+        require_object(audio.get("stems"), "audio.stems")
+    export = proj.get("export")
+    if "export" in read and isinstance(export, dict) and export.get("preset") and not isinstance(export["preset"], str):
+        die(f"export.preset: must be a preset name (a string), got {type(export['preset']).__name__} "
+            f"{export['preset']!r:.60}")
     if isinstance(proj.get("chapters"), list):
         # Every other project error is raised here, before the first ffmpeg call; a chapter typo
         # found inside the last stage costs a whole render and leaves an unchaptered file behind.
@@ -590,6 +598,14 @@ def validate_project(proj: Dict[str, Any], timeline: bool = False, stop_after: O
             # every clip stage starts from rel(c["src"]): without one it was a KeyError traceback
             if not item.get("src"):
                 die(f"clips[{i}]: no src")
+            if item.get("speed") and not timeline:
+                # the clips stage reads float(speed): "fast" or [2] was a traceback there (A13)
+                try:
+                    spd = float(item["speed"])
+                except (TypeError, ValueError):
+                    spd = float("nan")
+                if not (0 < spd < float("inf")):
+                    die(f"clips[{i}]: speed must be a positive number, got {item['speed']!r:.60}")
             if item.get("snap") is not None:
                 # the render reads a clip's snap only on a clip it cuts (in/out), the export never
                 if not timeline and (item.get("in") is not None or item.get("out") is not None):
@@ -984,6 +1000,19 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
         _reject_plan(path, digest, "plan_version_unsupported",
                      f"{path}: plan_version {plan.get('plan_version')!r} is not {PLAN_VERSION}",
                      plan_version=plan.get("plan_version"), supported=[PLAN_VERSION])
+    # the fields below are walked as lists of objects or strings: a wrong type was a traceback
+    # with no audit record (A14), and is refused like every other plan error
+    for field, want, item in (("inputs", list, None), ("unbound_inputs", list, None), ("verify", list, dict),
+                              ("commands", list, str), ("cwd", str, None)):
+        value = plan.get(field)
+        if value is None:
+            continue
+        bad = not isinstance(value, want) or (item is not None and not all(isinstance(v, item) for v in value))
+        if bad:
+            shape = {"inputs": "a list", "unbound_inputs": "a list", "verify": "a list of objects",
+                     "commands": "a list of strings", "cwd": "a string"}[field]
+            _reject_plan(path, digest, "plan_field_invalid", f"{path}: {field} must be {shape}, got {type(value).__name__}",
+                         field=field, field_type=type(value).__name__)
     tool = str(plan.get("tool") or "")
     script = HERE / f"{tool}.py"
     if not re.fullmatch(r"[a-z][a-z0-9_]*", tool) or not script.exists() or tool == "render":
@@ -1238,9 +1267,10 @@ def main() -> int:
             if value:
                 die(f"{flag} belongs to --template NAME INPUT; a project.json states it in the project itself")
         try:
-            proj = json.loads(Path(args.project).read_text(encoding="utf-8"))
+            # read_json(): nesting too deep is a ValueError too, refused here, not a RecursionError
+            proj = read_json(args.project)
         except (OSError, ValueError) as exc:
-            die(f"cannot read project: {exc}")
+            die(f"cannot read project: {exc}", kind="input")
         if not isinstance(proj, dict):
             die(f"{args.project}: not a project or plan object (top level is {type(proj).__name__})")
         if "plan_version" in proj:

package/scripts/report.py

@@ -126,7 +126,7 @@ def pack_report(args) -> int:
     text = read_text_or_die(args.pack, "--pack")
     rows: List[List[str]] = []
     header: List[str] = []
-    for line in text.splitlines():
+    for line in text.split("\n"):
         line = line.strip()
         if not line.startswith("|"):
             continue
@@ -233,7 +233,9 @@ def main() -> int:
             if meta and meta.get("video"):
                 sheets[which], why = sheet_b64(path)
                 section("contact_sheet", which, why, f"{which} contact sheet")
-    commands = read_text_or_die(args.commands, "--commands").splitlines() if args.commands else []
+    # one per line, split at "\n" only (a command may hold U+2028 or \f; splitlines() split it)
+    command_text = read_text_or_die(args.commands, "--commands") if args.commands else ""
+    commands = command_text.removesuffix("\n").split("\n") if command_text else []
     notes = read_text_or_die(args.notes, "--notes") if args.notes else ""
     title = args.title or f"Delivery report — {Path(args.after).name}"
 

package/scripts/scenes.py

@@ -30,7 +30,7 @@ from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
 from _common.color import bt709_label_filter  # noqa: E402
-from _common.probe import square_pixels  # noqa: E402
+from _common.probe import PROBED_VIDEO, square_pixels  # noqa: E402
 from _common import dry_run_input_pending  # noqa: E402
 
 SHOT_FPS = 4.0          # frames/second sampled for --shots' flow estimate
@@ -348,7 +348,7 @@ def main() -> int:
         vf = (f"select='{expr}'," + (lab + "," if lab else "") + (square + "," if square else "")
               + f"scale={tile_w}:-2{stamp},"
               f"tile={cols}x{rows}:padding=2:margin=2:color=0x202020")
-        run(ffmpeg_base() + ["-i", args.input, "-an", "-vf", vf, "-frames:v", "1", "-fps_mode", "vfr", "-update", "1", args.sheet])
+        run(ffmpeg_base() + ["-i", args.input, "-map", f"0:{PROBED_VIDEO}", "-an", "-vf", vf, "-frames:v", "1", "-fps_mode", "vfr", "-update", "1", args.sheet])
         info(f"wrote {args.sheet}")
         result["sheet"] = args.sheet
 

package/scripts/silence.py

@@ -28,11 +28,13 @@ from _common import (filler_spans, FILLER_WORDS, FILLER_AMBIGUOUS, FILLER_DISCOU
                      FILLER_PAD, read_text_or_die)
 from _common import asr as _asr
 from _common.emit import warn
-from _common.runner import replace_checked
+from _common.asr import _dicts
+from _common.runner import parse_json, replace_checked
 from _common import guard_sidecar, refuse_existing_outputs, refuse_output_is_input, _check_output_path
 from _common.emit import refuse
 from _common import detect_silences as detect, STATE, add_common, apply_common, default_output, die, emit, info, is_audio_output, print_json, probe, X264_PRESETS, measured_level_dbfs, fmt_secs
 from _common.decision import frame_rate, stream_starts
+from _common.probe import PROBED_AUDIO
 
 
 
@@ -115,7 +117,7 @@ def sentence_words(args) -> "Tuple[list, str]":
         return usable(args._words, args._words_source)
     if args.words:
         try:
-            raw = json.loads(read_text_or_die(args.words, "--words"))
+            raw = parse_json(read_text_or_die(args.words, "--words"))
         except ValueError as exc:
             die(f"--words {args.words}: not readable JSON ({exc})", kind="input")
         words, _had_segments, _untimed = _words_from_transcript(raw)
@@ -304,7 +306,8 @@ def cut_levels(path: str, tm: Dict[str, Any], duration: float,
     out = []
     with tempfile.TemporaryDirectory(prefix="silence-levels-") as tmp:
         raw = os.path.join(tmp, "pcm.s16le")
-        proc = run_analysis([require_tool("ffmpeg"), "-hide_banner", "-loglevel", "error", "-nostdin", "-i", path, "-vn",
+        proc = run_analysis([require_tool("ffmpeg"), "-hide_banner", "-loglevel", "error", "-nostdin", "-i", path,
+                             "-map", f"0:{PROBED_AUDIO}", "-vn",
                              "-ac", str(channels), "-ar", str(CUT_LEVEL_RATE), "-f", "s16le", "-y", raw],
                             check=False, text=False)
         if proc.returncode != 0 or not os.path.isfile(raw) or not os.path.getsize(raw):
@@ -348,7 +351,7 @@ def resolve_filler(args, meta):
     untimed: list = []  # transcript words without a usable timing (a --words file can carry them)
     if args.words:
         try:
-            raw = json.loads(read_text_or_die(args.words, "--words"))
+            raw = parse_json(read_text_or_die(args.words, "--words"))
         except ValueError as exc:
             die(f"--words {args.words}: not readable JSON ({exc})", kind="input")
         source = f"whisper-json:{args.words}"
@@ -484,11 +487,13 @@ def _words_from_transcript(data):
     listed word it could not cut instead of dropping it unseen."""
     raw, had_segments = [], False
     if isinstance(data, dict):
-        raw = list(data.get("words") or [])
-        segments = data.get("segments") or []
+        # a "words" or "segments" that is not a list, and a segment that is not an object, carry no
+        # words: the file is then refused for having none, not by a traceback
+        raw = _dicts(data.get("words"))
+        segments = _dicts(data.get("segments"))
         had_segments = bool(segments)
         for seg in segments:
-            raw.extend((seg or {}).get("words") or [])
+            raw.extend(_dicts(seg.get("words")))
     elif isinstance(data, list):
         raw = list(data)
     out, untimed = [], []

package/scripts/stabilize.py

@@ -27,6 +27,8 @@ import sys
 import tempfile
 from pathlib import Path
 
+from _common.probe import PROBED_VIDEO
+from _common.runner import default_selection_maps
 from _common import STATE, add_common, apply_common, aac_args, cfr_args, default_output, die, emit, escape_filter_path, ffmpeg_base, info, probe, require_tool, run, video_args, X264_PRESETS, run_analysis, dry_run_input_pending, fmt_secs, record_fallback, EVEN_SCALE
 
 
@@ -79,8 +81,9 @@ def main() -> int:
             # A frame number, not a boolean: frame 1 is the standard reference for "lock to
             # this fixed frame" (mirrors vidstabtransform's own tripod=1 below).
             detect_vf += ":tripod=1"
+        # both passes read the picture probe() describes (its size chose the even scale above)
         detect_cmd = [ffmpeg, "-hide_banner", "-loglevel", "error", "-nostdin", "-y", "-i", args.input,
-                      "-vf", detect_vf, "-f", "null", "-"]
+                      "-map", f"0:{PROBED_VIDEO}", "-vf", detect_vf, "-f", "null", "-"]
         # Pass 1 is a measurement into a temp file (the transforms), so it runs under --dry-run
         # as well; only pass 2, the write, is skipped there.
         if not dry_run_input_pending(args.input):
@@ -94,7 +97,7 @@ def main() -> int:
             # Equivalent to relative=0:smoothing=0 -- overrides --smoothing, since averaging a
             # camera path makes no sense once every frame is locked to one fixed reference.
             transform_vf += ":tripod=1"
-        cmd = ffmpeg_base() + ["-i", args.input, "-vf", transform_vf]
+        cmd = ffmpeg_base() + ["-i", args.input] + default_selection_maps(meta, output) + ["-vf", transform_vf]
         cmd += video_args(meta, args.crf, args.preset)
         cmd += cfr_args(meta)
         if has_audio:

package/scripts/sync.py

@@ -37,6 +37,7 @@ from _common import video_args, add_common, apply_common, emit, aac_args, audio_
 from _common.emit import record_skip, warn
 from _common.decision import SEEK_MARGIN, frame_rate, grid_at_or_after, stream_starts
 from _common.timeline import output_timecode_args
+from _common.runner import default_selection_maps
 
 SR = 8000  # decode sample rate
 
@@ -392,14 +393,15 @@ def main() -> int:
             # 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"]
+                # the second file's first audio track: the one decode_pcm_mono() measured
+                cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + default_selection_maps(second_meta, output) + ["-c", "copy"]
                 if os.path.splitext(output)[1].lower() in (".mp4", ".mov", ".m4v"):
                     cmd += ["-movflags", "+faststart"]
                 cmd += ["-avoid_negative_ts", "make_zero", output]
                 proc = run(cmd, check=False)
                 fail_if_classified(proc)
                 if proc.returncode != 0:
-                    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]
+                    cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + default_selection_maps(second_meta, output) + (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
@@ -415,7 +417,9 @@ def main() -> int:
                     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
+                # -map after the output-side -ss: both are output options, so the order is the
+                # same command, and the seek stays next to the -i it drops the margin from
+                cmd += ["-i", args.second] + out_seek + default_selection_maps(second_meta, output)
                 af_parts = on_clock + drift_af
                 if delay_ms > 0:
                     af_parts.append(f"adelay={delay_ms}:all=1")