ffmpeg-skill 3.8.12 → 3.8.14

package/scripts/sync.py

@@ -7,7 +7,9 @@ reduced to a loudness envelope, cross-correlated with an FFT implemented in
 Python (coarse, 20 ms), then refined by direct correlation at 1 ms.
 
 Offset semantics: a positive offset means the SECOND input starts LATER
-than the reference, i.e. `second` must be shifted earlier by that amount.
+than the reference (it began recording after it), so its sound is delayed by
+that amount (its head padded) to line up; a negative offset means it started
+earlier, and its first -offset seconds are dropped.
 
 This aligns two AUDIO tracks to each other; it does not check or guarantee
 lip sync (mouth movement matching the audio). It assumes each recording's
@@ -25,15 +27,13 @@ Examples:
   python3 sync.py cam.mp4 recorder.wav --fix-drift --replace-audio   # long takes: fix clock drift too
 """
 import argparse
-import cmath
-import json
 import math
 import os
 import sys
 from typing import Dict, List
 
 from _common.runner import fail_if_classified
-from _common import STATE, 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 import STATE, video_args, add_common, apply_common, emit, aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, run, decode_pcm_mono, rms_envelope
 from _common.emit import record_skip, warn
 from _common.decision import SEEK_MARGIN, frame_rate, grid_at_or_after, length_output_t, silence_filter, stream_starts
 from _common.timeline import output_timecode_args
@@ -161,9 +161,14 @@ def cross_correlate(ref: List[float], other: List[float], max_lag: int):
 
         scores.append((val, lag))
         if val > best_val:
-            second = best_val
             best_val, best_lag = val, lag
-        elif val > second and abs(lag - best_lag) > 5:
+    # The runner-up is the best other PEAK more than 5 lags from the winner (A126). The running
+    # "previous best" this used to take was usually the winner's own neighbour, one lag away and
+    # on the same slope, so an exact match read 0.59 and could not be told from a tie (0.50).
+    by_lag = dict((lag, val) for val, lag in scores)
+    for val, lag in scores:
+        if abs(lag - best_lag) > 5 and val > second and \
+                val >= by_lag.get(lag - 1, -float("inf")) and val >= by_lag.get(lag + 1, -float("inf")):
             second = val
     # confidence: peak similarity, penalised when a distant runner-up is nearly as good
     conf = max(0.0, min(1.0, best_val))

package/scripts/verify.py

@@ -18,7 +18,6 @@ import argparse
 import contextlib
 import io
 import json
-import os
 import subprocess
 import sys
 import tempfile
@@ -26,10 +25,12 @@ import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
-from _common import STATE, add_common, apply_common, die, emit, guard_sidecar, info, probe
+from _common import STATE, add_common, apply_common, die, emit, guard_sidecar, info, probe, refuse_output_is_input, MEDIA_EXT as _MEDIA_EXT
 
 HERE = Path(__file__).resolve().parent
-MEDIA_EXT = {".mp4", ".mov", ".m4v", ".mkv", ".webm", ".avi", ".mts", ".m2ts", ".mxf", ".wav", ".m4a", ".mp3", ".flac", ".aac"}
+# _common's one list less the stills, as batch.py walks a folder: verify kept a list of its own,
+# and a folder walk skipped .ts, .3gp, .wmv, .gif, .ogg, .opus, .aif/.aiff, .caf and .wma (#467 A218)
+MEDIA_EXT = {e for e in _MEDIA_EXT if e not in (".png", ".jpg", ".jpeg", ".webp")}
 
 
 def unique_stems(files: List[Path]) -> Dict[Path, str]:
@@ -39,18 +40,31 @@ def unique_stems(files: List[Path]) -> Dict[Path, str]:
     resolve to the identical output prefix. Each file's own steps still ran correctly in isolation,
     but with --keep the second file's outputs silently overwrote the first file's on disk, and the
     report showed PASS for both without ever flagging the collision (same bug class already fixed
-    in batch.py). Disambiguate every colliding stem with a stable per-collision index instead."""
+    in batch.py). Disambiguate every colliding stem with a stable per-collision index instead.
+
+    A stem is compared case-folded (clip.mp4 and Clip.MOV share one name on a case-insensitive
+    disk), and an indexed name skips any stem already taken, a file's own included: through 3.8.8
+    two clip.mp4 and a clip_1.mp4 gave "clip_1" twice (audit A121)."""
     counts: Dict[str, int] = {}
     for f in files:
-        counts[f.stem] = counts.get(f.stem, 0) + 1
+        counts[f.stem.casefold()] = counts.get(f.stem.casefold(), 0) + 1
+    taken = {f.stem.casefold() for f in files if counts[f.stem.casefold()] == 1}
     seen: Dict[str, int] = {}
     stems: Dict[Path, str] = {}
     for f in files:
-        if counts[f.stem] > 1:
-            seen[f.stem] = seen.get(f.stem, 0) + 1
-            stems[f] = f"{f.stem}_{seen[f.stem]}"
-        else:
+        key = f.stem.casefold()
+        if counts[key] == 1:
             stems[f] = f.stem
+            continue
+        n = seen.get(key, 0)
+        while True:
+            n += 1
+            name = f"{f.stem}_{n}"
+            if name.casefold() not in taken:
+                break
+        seen[key] = n
+        taken.add(name.casefold())
+        stems[f] = name
     return stems
 
 
@@ -96,6 +110,20 @@ def _probe_capturing(path: str) -> "Tuple[Optional[Dict[str, Any]], Dict[str, An
         STATE.json = was_json
 
 
+# The shared flags given to verify.py that every step receives as well (set in main())
+FORWARD: Dict[str, bool] = {"overwrite": False, "fast": False}
+
+
+def _forwarded(argv: List[str]) -> List[str]:
+    """--overwrite and --fast as the caller gave them to verify.py: through 3.8.8 neither reached
+    a step, so a rerun into the same --out failed every step on its own earlier output (audit
+    A119). The steps' --timeout is verify's own per-step limit (step()'s `timeout`)."""
+    out = ["--overwrite"] if FORWARD["overwrite"] else []
+    if FORWARD["fast"] and "--fast" not in argv:
+        out.append("--fast")
+    return out
+
+
 def step(name: str, argv: List[str], timeout: float) -> Dict:
     """Run one step and keep what its tool said: `ok` (it completed), and on a failure the tool's
     own `kind`, `reason` and `message` (its --json failure document), `error` being that message
@@ -113,7 +141,7 @@ def step(name: str, argv: List[str], timeout: float) -> Dict:
             r.update(kind="verification", reason="hdr_lost", message=r["error"])
         return r
     try:
-        proc = subprocess.run([sys.executable, str(HERE / argv[0])] + argv[1:] + ["--json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        proc = subprocess.run([sys.executable, str(HERE / argv[0])] + argv[1:] + _forwarded(argv) + ["--json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                               text=True, encoding="utf-8", errors="replace", timeout=timeout or None)
     except subprocess.TimeoutExpired:
         msg = f"timeout after {timeout:.0f}s"
@@ -146,7 +174,7 @@ def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("paths", nargs="+", help="media files and/or folders")
     ap.add_argument("--out", help="directory for outputs (default: temp dir, deleted unless --keep)")
-    ap.add_argument("--keep", action="store_true", help="keep the outputs")
+    ap.add_argument("--keep", action="store_true", help="keep the outputs (without --out: in a new folder, named as out_dir and on stderr)")
     ap.add_argument("--quick", action="store_true", help="probe, copy cut, fit, caption, export only")
     ap.add_argument("--seconds", type=float, default=6.0, help="length of the test cut taken from each file (default 6)")
     ap.add_argument("--timeout", type=float, default=600.0, help="per-step timeout in seconds (default 600; 0 = no limit, as everywhere else)")
@@ -168,6 +196,7 @@ def main() -> int:
         # fault ("9 of 11 verification steps failed") rather than the flag's
         die(f"--seconds must be more than 0 (the length of the test cut), got {args.seconds:g}")
     files = collect(args.paths)
+    FORWARD.update(overwrite=STATE.overwrite, fast=STATE.fast)
     tmp = None
     if args.out:
         # made first, so a --report inside a new --out folder passes the guard below (#413 review)
@@ -177,20 +206,27 @@ def main() -> int:
         # a file this run writes itself (#408): not one of the media it verifies (a folder's
         # files included), nor an existing file without --overwrite
         guard_sidecar(args.report, *args.paths, *map(str, files))
-    if not args.out:
+    if not args.out and args.keep:
+        # --keep without --out: a folder of its own that outlives the run, named in the document
+        # (`out_dir`) and on stderr; through 3.8.8 it was the temporary directory, deleted at exit
+        # whatever --keep said, and never named (audit A120)
+        outdir = Path(tempfile.mkdtemp(prefix="ffskill_verify_"))
+    elif not args.out:
         tmp = tempfile.TemporaryDirectory(prefix="ffskill_verify_")
         outdir = Path(tmp.name)
+    kept_dir = None if tmp else str(outdir)
 
     stem_for = unique_stems(files)
-    results = []
+    # every file's plan is made before any step runs, so the names all of them will write are
+    # checked against every input first (below)
+    jobs: List[Tuple[Path, Dict, List[Tuple[str, List[str]]], Optional[Path]]] = []
     for f in files:
-        info(f"=== {f}")
         entry: Dict = {"file": str(f), "steps": [], "skipped": []}
         meta, failure = _probe_capturing(str(f))
         if meta is None:
             entry["steps"].append(dict({"step": "probe", "ok": False, "seconds": 0, "error": _cell(failure.get("message", ""))}, **failure))
             entry["skipped"].append({"step": "*", "reason": "input_unreadable", "message": "no other step runs on a file probe cannot read"})
-            results.append(entry)
+            jobs.append((f, entry, [], None))
             continue
         entry["probe"] = {k: meta.get(k) for k in ("duration", "format")}
         entry["probe"]["video"] = {k: (meta.get("video") or {}).get(k) for k in ("codec", "width", "height", "fps", "pix_fmt", "hdr_format", "rotation", "variable_frame_rate_suspected")}
@@ -202,7 +238,8 @@ def main() -> int:
         cut = f"{stem}_cut.mp4"
         seg_end = min(dur, args.seconds) if dur else args.seconds
         fast = ["--fast"]
-        plan = []
+        plan: List[Tuple[str, List[str]]] = []
+        cues: Optional[Path] = None
         skipped: List[Dict[str, str]] = entry["skipped"]
 
         def skip(step_name: str, reason: str, message: str) -> None:
@@ -212,7 +249,6 @@ def main() -> int:
             plan.append(("cut accurate", ["cut.py", str(f), "--start", "0", "--end", f"{seg_end:.2f}", "--accurate", "-o", f"{stem}_acc.mp4"] + fast))
             plan.append(("fit 9:16", ["fit.py", cut, "--aspect", "9:16", "--width", "720", "-o", f"{stem}_fit.mp4"] + fast))
             cues = outdir / f"{stem_for[f]}_cues.txt"
-            cues.write_text("0:00-0:02 Verification caption\n0:02-0:04 Second | line\n", encoding="utf-8")
             plan.append(("caption", ["caption.py", cut, "--text", str(cues), "--animate", "pop", "--karaoke", "-o", f"{stem}_cap.mp4"] + fast))
             if not args.quick:
                 plan.append(("overlay text", ["overlay.py", cut, "--text", "verify", "--position", "top-left", "-o", f"{stem}_ovl.mp4"] + fast))
@@ -245,6 +281,30 @@ def main() -> int:
         else:
             for n in ("loudness measure", "silence list", "audio downmix"):
                 skip(n, "quick", "--quick runs probe, copy cut, fit, caption and export only")
+        jobs.append((f, entry, plan, cues))
+
+    # A name verify generates can be another input's (clip.mp4's cut is clip_cut.mp4, which can be
+    # a file of the same folder): each step checks its output against its own input only, so with
+    # --overwrite that input was replaced and its own steps then read the replacement. Every name
+    # the run will write -- step outputs, caption's sidecars, the cue file -- against every input,
+    # through a link or another case of the name included, before the first is written.
+    every_input = [str(f) for f in files]
+    for f, _entry, plan, cues in jobs:
+        written = [("cue file", str(cues))] if cues else []
+        for name, argv in plan:
+            if "-o" in argv:
+                out = argv[argv.index("-o") + 1]
+                written.append((name, out))
+                if argv[0] == "caption.py":
+                    written += [(name, str(Path(out).with_suffix(ext))) for ext in (".srt", ".ass")]
+        for name, out in written:
+            refuse_output_is_input(out, *every_input, why=f"it is where verify writes the {name!r} step's output for {str(f)!r}")
+
+    results = []
+    for f, entry, plan, cues in jobs:
+        info(f"=== {f}")
+        if cues:
+            cues.write_text("0:00-0:02 Verification caption\n0:02-0:04 Second | line\n", encoding="utf-8")
         for name, argv in plan:
             r = step(name, argv, args.timeout)
             entry["steps"].append(r)
@@ -275,14 +335,16 @@ def main() -> int:
         info(f"wrote {args.report}")
     if not args.json:
         print(report)
-    if tmp and not args.keep:
+    if tmp:
         tmp.cleanup()
+    if kept_dir:
+        info(f"step outputs kept in {kept_dir}")
     notes = (["--dry-run is ignored by verify.py: its steps ran and wrote their outputs"] if ignored_dry_run else [])
     if failed:
         die(f"{failed} of {total} verification steps failed", kind="verification", output=None, dry_run=STATE.dry_run,
-            report=args.report, files=results, failed=failed, total=total, **({"notes": notes} if notes else {}))
+            report=args.report, files=results, failed=failed, total=total, out_dir=kept_dir, **({"notes": notes} if notes else {}))
     if args.json:
-        emit(None, report=args.report, files=results, failed=failed, total=total, **({"notes": notes} if notes else {}))
+        emit(None, report=args.report, files=results, failed=failed, total=total, out_dir=kept_dir, **({"notes": notes} if notes else {}))
     return 0
 
 

package/scripts/waveform.py

@@ -43,6 +43,7 @@ from _common import (add_common, apply_common, aac_args, default_output, die, dr
                      fmt_secs, child_args, run_tool, measured_level_dbfs, sibling_temp)
 from _common.emit import absorb_stage_hw, note, warn
 from _common.decision import length_output_t
+from _common.probe import AUDIO_MEDIA_EXT
 
 WAVEFORM_MODES = ["point", "line", "p2p", "cline"]
 
@@ -50,7 +51,7 @@ WAVEFORM_MODES = ["point", "line", "p2p", "cline"]
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("input")
-    ap.add_argument("-o", "--output", help="output file (default: <name>_waveform.<ext>)")
+    ap.add_argument("-o", "--output", help="output file, a video (default: <name>_waveform.<ext>, .mp4 for an audio input; an audio extension is refused)")
     ap.add_argument("--style", choices=["waveform", "spectrum"], default="waveform", help="waveform (default) or spectrum visualization")
     ap.add_argument("--width", type=int, default=1920, help="output width in px, must be even (default 1920)")
     ap.add_argument("--height", type=int, default=1080, help="output height in px, must be even (default 1080)")
@@ -170,7 +171,16 @@ def main() -> int:
                 die(f"{args.input} is silent (audio stream {args.audio_stream} peaks at {silent_peak:g} dBFS, at or below "
                     f"--silence-threshold {args.silence_threshold:g}): the visualisation would be a flat line",
                     kind="input", hint="check the audio, or pass --on-silent warn to render it anyway")
-    output = args.output or default_output(args.input, "waveform")
+    # A137: the output always holds a picture, so an audio input's extension is not the default:
+    # talk.wav made talk_waveform.wav, which the WAV muxer refused (kind ffmpeg), and talk.m4a an
+    # H.264 video named .m4a
+    in_ext = os.path.splitext(args.input)[1].lower()
+    output = args.output or default_output(args.input, "waveform", "mp4" if in_ext in AUDIO_MEDIA_EXT else None)
+    # every audio-only extension this skill reads, not only those it writes (is_audio_output():
+    # .aif, .aiff, .caf and .wma are not there, and passed this to fail in ffmpeg, or in a dry run not at all)
+    if os.path.splitext(output)[1].lower() in AUDIO_MEDIA_EXT:
+        die(f"{output}: waveform.py writes a video, and {os.path.splitext(output)[1].lower()} holds sound only; "
+            "name a video file (.mp4, .mov, .mkv)", kind="input")
 
     # The visualisation's own band. Without --image/--position it fills the frame, which is what
     # every 1.15 command line did, so the graph below is byte-identical when no new flag is given.