ffmpeg-skill 3.1.6 → 3.1.8

package/scripts/export.py

@@ -38,10 +38,12 @@ import tempfile
 from pathlib import Path
 from typing import Dict, List
 
+from _common.runner import child_exit_code, fail_if_classified, kept_clause, mark_delivered
 from _common import STATE, run_analysis, add_common, apply_common, bt709_label_filter, bt709_matrix_args, bt709_tag_args, child_args, emit, cfr_args, default_output, die, encoder_args, ffmpeg_base, info, probe, require_tool, run, run_tool, validate_color, pad_filters, add_pad_fill_args, fmt_secs
 from _common.decision import hw_preset_video, restate_last_swap
 from _common.emit import note, record_fallback, record_skip, warn
 from _common.probe import square_pixels, square_pixels_note
+from _common.runner import subtitle_codec_for
 from check import SPECS as PLATFORMS, measure_loudness
 from _platforms import ALIASES as _ALIASES, PLATFORMS as PLATFORM_TABLE, TP_TOLERANCE_DB, resolve as resolve_platform
 # Frame and duration limit come from the one platform table (scripts/_platforms.py) rather than
@@ -142,19 +144,10 @@ def _loudness_unmeasured(extra: Dict[str, object], notes: List[str], platform: s
 
 # Text subtitle codecs ffmpeg can convert to the container's own text track: mov_text is the one
 # text track MP4/MOV hold, Matroska holds SubRip/ASS/WebVTT as they are but not mov_text.
-_TEXT_SUBTITLES = frozenset({"mov_text", "subrip", "srt", "ass", "ssa", "webvtt", "text"})
-_MP4_FAMILY = frozenset({"mp4", "m4v", "mov"})
-
-
-def _subtitle_codec(codec: str, out_ext: str) -> str:
-    """The -c:s for one source subtitle stream: copy when the output container holds it as it is,
-    else the container's own text format (a bitmap track is tried as a copy; a container that
-    refuses it is the fallback below)."""
-    if out_ext in _MP4_FAMILY and codec in _TEXT_SUBTITLES and codec != "mov_text":
-        return "mov_text"
-    if out_ext == "mkv" and codec == "mov_text":
-        return "srt"
-    return "copy"
+# the -c:s for one source subtitle stream (#380), shared with caption.py --mode mux (#414): copy
+# when the output container holds it as it is, else the container's own text format (a bitmap
+# track is tried as a copy; a container that refuses it is the fallback below)
+_subtitle_codec = subtitle_codec_for
 
 
 def _data_streams(path: str) -> List[Dict[str, object]]:
@@ -191,6 +184,9 @@ def _run_keeping_non_av(cmd: List[str], output: str, sub_codecs: List[str], data
         attempt = run(cmd + extra + [output], check=False)
         if attempt.returncode == 0:
             return dropped
+        # a full disk or a missing encoder fails every rung the same way: that error, not a
+        # fallback that blames the subtitles and encodes again (#415, #389's rule)
+        fail_if_classified(attempt)
         error = " | ".join([ln.strip() for ln in (attempt.stderr or "").splitlines() if ln.strip()][-3:])[-500:]
         going = rungs[n + 1][1]
         record_fallback(f"{os.path.basename(output)} could not hold the source's {' and '.join(t for t in ('subtitle', 'data') if t in going)} "
@@ -355,7 +351,9 @@ def main() -> int:
         notes.append("source is %s (%s). This preset outputs SDR BT.709 tags without converting it; run color.py --to-sdr first for correct colours." % (kind, meta["video"].get("hdr_format")))
         warn(notes[-1], "colour_not_converted", preset=args.preset, hdr_format=meta["video"].get("hdr_format"))
     has_audio = bool(meta.get("audio"))
-    output = args.output or default_output(args.input, args.preset, p["ext"])
+    # copy keeps the source's container, so its default name keeps the source's extension (as
+    # metadata.py's does): default_output()'s .webm -> .mp4 is for the re-encoding presets
+    output = args.output or default_output(args.input, args.preset, p["ext"] or Path(args.input).suffix.lstrip(".") or None)
     out_ext = Path(output).suffix.lstrip(".").lower()
 
     vf: List[str] = []
@@ -474,6 +472,10 @@ def main() -> int:
         dropped = _run_keeping_non_av(cmd, output, sub_codecs, len(data)) if (subs or data) else []
         if not (subs or data):
             run(cmd + [output])
+    if not STATE.dry_run:
+        # the export is on disk: a stop in the reads and the --normalize pass that follow keeps it,
+        # and says so (#415)
+        mark_delivered(output)
     result = probe(output, role="output")
     v = result["video"]
     info(f"wrote {output} ({fmt_secs(result['duration'])}, {v['width']}x{v['height']}, {v['codec']})")
@@ -516,7 +518,12 @@ def main() -> int:
                     err = child.get("error") or {}
                     if os.path.exists(tmp):
                         os.remove(tmp)
-                    die(f"--normalize: loudness.py failed: {err.get('message') or proc.stderr.strip()[-300:]}",
+                    # the child's "nothing was written" is about its own temp file; this run's export is
+                    # on disk, and the child's exit code (124 timeout, 130/143 interrupted) is the
+                    # run's, as render.py and waveform.py pass a stage's on (#415)
+                    why = (err.get("message") or proc.stderr.strip()[-300:]).replace("; nothing was written", "")
+                    die(f"--normalize: loudness.py failed: {why} ({kept_clause()})",
+                        code=child_exit_code(child, proc.returncode) if proc.returncode else 1,
                         kind=err.get("kind") or "ffmpeg", output=output, hint=err.get("hint"))
                 os.replace(tmp, output)
                 m = measure_loudness(output)

package/scripts/metadata.py

@@ -221,7 +221,8 @@ def main() -> int:
         die(f"chapters file not found: {args.chapters}")
 
     meta = probe(args.input)
-    output = args.output or default_output(args.input, "meta")
+    # streams are copied, so the source's own container always holds them (a .webm stays .webm)
+    output = args.output or default_output(args.input, "meta", Path(args.input).suffix.lstrip(".") or "mp4")
     if os.path.abspath(output) == os.path.abspath(args.input):
         die("output must differ from the input (metadata.py never rewrites a file in place)")
     out_ext = Path(output).suffix.lower()
@@ -249,7 +250,13 @@ def main() -> int:
         cmd += ["-map", "0", "-map_metadata", "0", "-map_chapters", "0"]
     for key, value in tags.items():
         cmd += ["-metadata", f"{key}={value}"]
-    cmd += ["-c", "copy", output]
+    cmd += ["-c", "copy"]
+    if out_ext in (".mp4", ".mov", ".m4v", ".m4a"):
+        # A stream copy into the MPEG-4 family writes the index (moov) after the media unless told
+        # otherwise, so without +faststart a faststart input -- render's export -- came out with
+        # its index at the end (#415; every other MP4 write here is faststart since #279)
+        cmd += ["-movflags", "+faststart"]
+    cmd.append(output)
     run(cmd)
     if tmpdir:
         tmpdir.cleanup()

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, 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, found_exe
+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
 import subprocess
 from _contract import CONTRACT_VERSION
@@ -351,6 +351,7 @@ def render_pack(names: List[str], args) -> int:
     rows: List[Dict[str, Any]] = []
     outputs: List[str] = []
     failed: List[str] = []
+    stopped: List[Dict[str, Any]] = []  # destinations a timeout stopped: {kind, exit_code}
     for name in names:
         # the destination decides the container: an audio-only destination in a pack must not be
         # handed a .mp4 name the single-template form would never have written (review 12)
@@ -394,6 +395,9 @@ def render_pack(names: List[str], args) -> int:
         outputs.append(out)
         if not ok:
             failed.append(name)
+            err = doc.get("error") or {}
+            if err.get("kind") in ("timeout", "interrupted"):
+                stopped.append({"kind": err["kind"], "exit_code": child_exit_code(doc, proc.returncode)})
     pack = str(outdir / f"{stem}_pack.md")
     lines = [f"# Social pack — {stem}", "",
              "| platform | file | size | duration | check |", "|---|---|---|---|---|"]
@@ -410,8 +414,11 @@ def render_pack(names: List[str], args) -> int:
         Path(pack).write_text("\n".join(lines) + "\n", encoding="utf-8")
     info(("[dry-run] would write " if STATE.dry_run else "wrote ") + pack)
     if failed:
+        # a destination that was stopped makes the pack a stopped run: its kind and exit code (124,
+        # 130/143), as a stage's are render.py's (docs/contract.md); otherwise a verification failure
         die(f"pack: {len(failed)} of {len(rows)} destinations failed: {', '.join(failed)}",
-            kind="verification", output=pack, dry_run=STATE.dry_run, pack=rows, outputs=outputs)
+            code=stopped[0]["exit_code"] if stopped else 1, kind=stopped[0]["kind"] if stopped else "verification",
+            output=pack, dry_run=STATE.dry_run, pack=rows, outputs=outputs)
     emit(pack, pack=rows, outputs=outputs, stages=["pack"],
          verification=[{"step": "check", "ok": r["ok"], "platform": r["platform"]} for r in rows])
     return 0
@@ -577,6 +584,8 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
             # child's document standing, which a caller reading _LAST_DOC would misattribute.
             _LAST_DOC.clear()
             _LAST_DOC["cached"] = True
+            if not STATE.dry_run:
+                remember_written(dest)  # placed by this run, as a stage's own write would be (#415)
             return dest
         CACHE["misses"].append(stage)
         _refuse_uncached_earlier_stage(stage)
@@ -603,12 +612,27 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
         extra_fields = {"hint": err["hint"]} if err.get("hint") else {}
         error_extra = absorb_stage(Path(script).stem, doc)  # the stage's reason/details and records ride along
         extra_fields.update(_stage_failure_hw(doc))
-        die(f"{script} failed: {err.get('message') or (proc.stderr.strip().splitlines() or ['?'])[-1][:300]}",
+        why = err.get('message') or (proc.stderr.strip().splitlines() or ['?'])[-1][:300]
+        if kept_deliverables() and err.get("kind") in ("timeout", "interrupted"):
+            # 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])
+        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
+            extra_fields.setdefault("output", str(doc["output"]))
+        die(f"{script} failed: {why}",
             code=int(doc.get("exit_code") or 1), kind=err.get("kind") or "input", stage=script, error_extra=error_extra, **extra_fields)
     _LAST_DOC.clear()
     _LAST_DOC.update(doc if isinstance(doc, dict) else {})
     absorb_stage(Path(script).stem, doc)  # a stage's GPU facts (ran on VideoToolbox, fell back and why) and its diagnostics reach this result
     out_path = str(doc.get("output") or "")
+    if not STATE.dry_run:
+        # A file a stage of this run wrote is this run's, not someone else's: the chapters stage
+        # places its tagged copy over the export's delivery, which the output guard would
+        # otherwise refuse as an existing file without --overwrite (#415).
+        remember_written(out_path, dest)
     if key:
         cache_store(stage, key, out_path or (dest or ""), time.time() - started, doc)
     return out_path
@@ -951,8 +975,10 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
     if proc.returncode != 0 or doc.get("status") != "completed":
         err = doc.get("error") or {}
         error_extra = absorb_stage(tool, doc)  # the tool's reason/details and records ride along
+        # the tool's exit code is the plan's (124 timeout, 130/143 interrupted), as sh() passes a stage's on
         die(f"{tool} failed while executing the plan: {err.get('message') or proc.stderr.strip()[-300:]}",
-            kind=err.get("kind", "ffmpeg"), plan=path, tool=tool, error_extra=error_extra, **_stage_failure_hw(doc))
+            code=child_exit_code(doc, proc.returncode), kind=err.get("kind", "ffmpeg"), plan=path, tool=tool,
+            error_extra=error_extra, **_stage_failure_hw(doc))
     absorb_stage(tool, doc)  # the tool's GPU facts (fell back and why, ran on VideoToolbox) and diagnostics reach this result
     output = doc.get("output") or plan.get("output")
     check_result = None
@@ -1611,6 +1637,8 @@ def main() -> int:
             place_output(current, output)
         info(("[dry-run] would copy" if STATE.dry_run else "copied") + f" final stage to {output}")
     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)
 
     # ---- chapters (metadata.py on the delivered file: streams copied, markers written)
     ch = proj.get("chapters")
@@ -1648,6 +1676,13 @@ def main() -> int:
             exit_code = 1
         elif check_result.get("error") or check_result.get("status") == "failed":
             err = check_result.get("error")
+            if isinstance(err, dict) and err.get("kind") in ("timeout", "interrupted"):
+                # stopped, not failed: the run exits with check.py's own code (124, 130/143), as a
+                # stage that stopped does, and says the delivery it had written is kept (#415)
+                why = str(err.get("message") or "").replace("; nothing was written", "")
+                die(f"check.py failed: {why} ({kept_clause()})",
+                    code=int(check_result.get("exit_code") or err.get("exit_code") or 1), kind=err["kind"],
+                    stage="check.py", output=output, stages=stages_done)
             info(f"check: could not run check.py — {err.get('message') if isinstance(err, dict) else err}")
             exit_code = 1
         else:

package/scripts/silence.py

@@ -83,10 +83,29 @@ def speech_aware_silences(path: str, threshold: float, min_silence: float) -> "T
     return boundaries, breaths
 
 
+def inside_margin(silences: List[Tuple[float, float]], duration: float, margin: float) -> List[Tuple[float, float]]:
+    """Each silence with --margin kept on both sides: the stretch actually removed. A silence too
+    short to hold two margins removes nothing (it is dropped, never turned inside out).
+
+    The margin is applied to the silences alone, before they are merged with filler spans (#414):
+    a filler word's span is the word itself plus --filler-pad, and taking a 0.2 s margin off each
+    side of it turned every word narrower than 2 x --margin inside out -- kept, and still counted
+    as removed."""
+    out: List[Tuple[float, float]] = []
+    for s, e in silences:
+        a = s + margin
+        b = duration if e == float("inf") else min(duration, e - margin)
+        if b > a:
+            out.append((a, b))
+    return out
+
+
 def keep_ranges(silences: List[Tuple[float, float]], duration: float, margin: float, min_keep: float) -> List[Tuple[float, float]]:
     keeps: List[Tuple[float, float]] = []
     cursor = 0.0
     for s, e in sorted(silences):
+        if e != float("inf") and e - margin <= s + margin:
+            continue  # narrower than two margins: nothing of it is removed (#414)
         s_adj = max(cursor, s + margin)
         if s_adj - cursor >= min_keep:
             keeps.append((cursor, s_adj))
@@ -503,6 +522,9 @@ def main() -> int:
     media_out = None if (args.list or args.filler_list) else (args.output or default_output(args.input, "tight"))
     guard_sidecar(args.edl, args.input, args.words, args.filler_words, siblings=(media_out,))
 
+    if not math.isfinite(args.margin) or args.margin < 0:
+        # nan made inside_margin() drop every silence and re-encode the whole file unchanged
+        die(f"--margin must be a finite number of seconds, 0 or more (got {args.margin:g})", kind="input")
     if args.filler_pad < 0:
         die("--filler-pad cannot be negative: a negative pad turns each word's span inside out "
             "(end before start) and the span is then silently dropped, so nothing is removed",
@@ -525,8 +547,10 @@ def main() -> int:
     filler_info, filler_ranges = resolve_filler(args, meta) if args.filler else (None, [])
     # One sorted, merged removal list through the graph the tool already has: filler removal IS
     # time-range removal, so it reuses keep_ranges() and the same select chain.
-    removals = merge_spans(list(silences) + list(filler_ranges))
-    keeps = keep_ranges(removals, duration, args.margin, args.min_keep)
+    # --margin is kept around the silences only (inside_margin), not around filler spans, whose
+    # own trim is --filler-pad (#414); the merged list then goes through with no further margin.
+    removals = merge_spans(inside_margin(silences, duration, args.margin) + list(filler_ranges))
+    keeps = keep_ranges(removals, duration, 0.0, args.min_keep)
     # what the render holds (on a picture, each bound on its nearest frame): the report, the EDL
     # and the time map all describe these, so a re-cut or a sum of `keep` is the rendered edit
     video_out = bool(meta.get("video")) and not (media_out and is_audio_output(media_out))
@@ -540,7 +564,7 @@ def main() -> int:
     # the silences alone; everything removed is `removed_seconds_total`.
     silence_only = removed
     if args.filler:
-        silence_keeps = keep_ranges(merge_spans(list(silences)), duration, args.margin, args.min_keep)
+        silence_keeps = keep_ranges(merge_spans(inside_margin(silences, duration, args.margin)), duration, 0.0, args.min_keep)
         silence_only = max(0.0, duration - sum(e - s for s, e in rendered_ranges(silence_keeps, meta, duration, video_out)))
     kinds = silence_kinds(args.input, silences, duration, args.threshold)
     summary = {
@@ -649,8 +673,9 @@ def main() -> int:
         return 0
     if not keeps or not held:
         die("nothing would be kept; raise --threshold (e.g. -45) or check the audio")
-    if not silences or removed < 0.05:
-        info("no removable silence found; output would equal the input")
+    if removed < 0.05:
+        # what the render removes, filler spans included: --filler alone has no silences at all
+        info(f"no removable {'filler' if filler_only else 'silence or filler' if args.filler else 'silence'} found; output would equal the input")
 
     output = args.output or default_output(args.input, "tight")
     # the join of more than 32 ranges concats a list of chunks, so its last command never names the

package/scripts/sync.py

@@ -32,6 +32,7 @@ import os
 import sys
 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
@@ -377,6 +378,7 @@ def main() -> int:
             cmd += ["-af", ",".join(af_parts)]
             cmd += aac_args() + (["-t", f"{ref_dur:.3f}"] if ref_dur else ["-shortest"]) + [output]
             proc = run(cmd, check=False)
+            fail_if_classified(proc)  # a cause the re-encode would hit too is reported, not retried (#415)
             if proc.returncode != 0:
                 cmd = [c for c in cmd if c != "copy"]
                 idx = cmd.index("-c:v"); del cmd[idx]
@@ -389,6 +391,7 @@ def main() -> int:
                     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]
                     run(cmd)

package/scripts/waveform.py

@@ -284,6 +284,14 @@ def main() -> int:
             notes.append(f"the visualisation band and {args.platform}'s bottom safe zone overlap by "
                          f"{overlap}px: the captions or the app's own UI will sit over the waveform "
                          f"(lower --vis-height to {max(0.05, (args.height - safe_px) / args.height):.2f})")
+    if STATE.dry_run and (args.title or args.srt or args.text):
+        # graphics.py / caption.py plan on the render this dry run did not write, whose frame they
+        # cannot measure: their sizes and offsets come out 0 in the plan, and the real run takes
+        # them from the WxH render (#415). Said here, so a plan is not read as the real numbers.
+        later = " and ".join(n for n, on in (("title", args.title), ("captions", args.srt or args.text)) if on)
+        notes.append(f"the {later} stage was planned on the visualisation render this dry run did not write, so the "
+                     f"font sizes and offsets in its planned command are placeholders (0); the real run sizes them "
+                     f"from the {args.width}x{args.height} render")
     if silent_peak is not None:
         warn(f"{args.input} is silent (peak {silent_peak:g} dBFS); the visualisation is a flat line", "silent_input",
              path=args.input, peak_db=silent_peak)