Local video editor for coding agents: 42 FFmpeg tools with a machine-readable contract and an MCP server, for Claude Code, Cursor and Codex. Cut, captions, reframe, loudness, platform exports. No cloud, no API keys.
Python agent-skillsai-agentsaudio-processingcaptionsclaude-codecodexcoding-agentcursorffmpegloudness-normalizationmcpmcp-servermodel-context-protocolpythonsubtitlestranscodingvideovideo-editingvideo-processingwhisper
0.8.0: real-device corpus, ground-truth benchmarks, NCC sync, spike-based scene cuts (#10)
kajisho583b15a75f58a
diff --git a/.gitignore b/.gitignoreindex 56956fb..677dab7 100644--- a/.gitignore+++ b/.gitignore@@ -15,3 +15,6 @@ package-lock.json.DS_Store.vscode/.idea/++# downloaded real-world corpus+tests/corpus/diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 1ebda37..db82e49 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -1,5 +1,16 @@# Changelog+## 0.8.0 — validation release++Measured instead of assumed. New `tests/corpus.py` pulls public real-device videos (GoPro HERO 4K 10-bit, DJI 4K60 no-audio, two iPhones incl. Dolby Vision 4K60, two Android screen recordings incl. 18 fps VFR and 120 fps, an HDR10 PQ test pattern, a 24p clip, and Blender's Tears of Steel) and runs `verify.py` over them; `tests/bench_*.py` score algorithms against known ground truth.++- `sync.py`: normalised cross-correlation over the overlap (prefix-sum energies) with a runner-up-aware confidence. Lags with under 35 % overlap are ignored and scores carry a sqrt(overlap) weight so partial coincidental matches cannot beat the true alignment. Benchmark on real dialogue/music (±30 s offsets, gain, noise, EQ): 120 s windows 40/40 within 10 ms (max 1.1 ms); 60 s stress windows went from 86 % to 95 %, with 4 of the 5 remaining misses flagged by confidence < 0.3.+- `scenes.py`: cuts are now one-frame spikes (score above threshold and > 3× the neighbouring median), not any frame over a threshold; motion, flashes and pans stop registering. `--ratio` added. Benchmark on 53 hard cuts between single-take corpus clips: precision 0.95, recall 1.00 (F1 0.97) at the default threshold 8; 0.98 / 0.94 at 12.+- `loudness.py`: silent input is reported (`"silent": true`) instead of crashing; normalisation refuses with a clear message.+- `verify.py`: tone-maps the HDR-preserved cut instead of the whole file (a 10-minute 4K HDR source timed out).+- Corpus results: 90/92 verify steps pass on first run; both failures fixed above. Silence benchmark: 0 missed gaps, ≤1 ms leftover silence over 20 cases.+- SKILL.md: sync guidance now cites the benchmark and the 4× window rule.+## 0.7.0- `mcp/server.py` (new): the whole toolkit as an MCP server over stdio (JSON-RPC 2.0, standard library only). Every script is a tool; named args or raw argv; results as structured JSON. Installed alongside scripts by `npx ffmpeg-skill`.diff --git a/README.md b/README.mdindex ef4950f..5013c09 100644--- a/README.md+++ b/README.md@@ -124,6 +124,22 @@ More examples: [examples/README.md](examples/README.md). To see everything run eAll scripts: Python 3.9+, standard library only, `--help`, non-zero exit + stderr message on failure.+## Measured, not assumed++`tests/corpus.py` downloads public real-device footage (GoPro, DJI, iPhone incl. Dolby Vision, Android screen recordings, HDR10, 24p, Tears of Steel) and runs the toolchain on it; `tests/bench_sync.py`, `bench_silence.py` and `bench_scenes.py` score the algorithms against known ground truth.++| What | Result (0.8.0, local ffmpeg 6.1) |+|---|---|+| Real-device corpus, 10 files | 92 verify steps, all pass after fixes |+| sync.py, ±30 s offsets, gain/noise/EQ, real dialogue+music | 120 s windows (the documented rule): 40/40 within 10 ms, max 1.1 ms. 60 s stress windows: 95 % within 10 ms, 4 of 5 misses flagged by confidence |+| silence.py, 20 cases, known gaps | 0 missed gaps, ≤ 1 ms leftover silence |+| scenes.py, 53 hard cuts between single takes (GoPro/DJI/iPhone/…) | precision 0.95, recall 1.00, F1 0.97 at the default threshold |++```bash+python3 tests/corpus.py --fetch --verify # ~1.4 GB download, then verify (slow on 4K)+python3 tests/bench_sync.py --cases 100+```+## MCP```jsondiff --git a/SKILL.md b/SKILL.mdindex 6c0a7bc..1444ea9 100644--- a/SKILL.md+++ b/SKILL.md@@ -167,8 +167,12 @@ scenes.py INPUT [--threshold 10] [--min-scene 1] [--highlights N [--target SECONLists scenes with audio energy, the loudest moments, and (with`--highlights`) proposes N ranges that add up to `--target` seconds, biased tothe loudest window of each scene. Review the sheet + JSON, adjust the EDL, then-`cut.py --segments`. It is a proposal engine, not a judgement of content:-tell the user what it picked and why (energy, scene length).+`cut.py --segments`. Cut detection is a one-frame spike test (benchmark on+hard cuts between real single takes: precision 0.95, recall 1.00 at the default+threshold; raise `--threshold` to 12 for 0.98 precision at 0.94 recall).+Dissolves and very slow fades are not cuts and will be missed. Highlights are+a proposal engine, not a judgement of content: tell the user what it picked+and why (energy, scene length).### check.py — pre-delivery compliance```@@ -300,7 +304,12 @@ video with the second file's audio aligned (video stream copied).the clock difference in ppm, and resamples the second file so a 60-minutetake stays in sync (typical consumer devices drift 20-500 ppm = up to 1.8 s/h).Use it whenever the recording is longer than ~10 minutes. Check `confidence`-(0–1); below ~0.3 the match is doubtful — use a window with a clear event.+(0–1, normalised correlation with a runner-up penalty); below 0.3 the match is+doubtful. Benchmark on real dialogue/music (±30 s offsets, gain, noise, EQ):+with the default 120 s window 40/40 within 10 ms (max 1.1 ms); with a 60 s+window 95 %, misses flagged below 0.3. Keep `--analyze-seconds` at least 4×+`--max-offset` (default 120 s vs 30 s): lags with under 35 % overlap are+ignored, so an offset larger than ~60 % of the window cannot be found.### color.py — HDR to SDR, LUTs, colour tags, Dolby Vision```diff --git a/package.json b/package.jsonindex 5670364..7632d46 100644--- a/package.json+++ b/package.json@@ -1,6 +1,6 @@{"name": "ffmpeg-skill",- "version": "0.7.1",+ "version": "0.8.0","description": "Agent Skill that lets coding agents (Claude Code, Cursor, Codex) do professional video editing with local FFmpeg: MCP server, batch processing, declarative project rendering, brand kits, motion-graphics templates, HTML delivery reports, scene detection, delivery checks, cut, silence removal, transitions, multicam, captions, sync with drift correction, HDR to SDR, LUTs, audio clean-up and ducking, loudness, platform exports. No API keys, no cloud, no dependencies.","keywords": ["ffmpeg", "video", "agent-skill", "claude-code", "cursor", "codex", "skill", "video-editing"],"license": "MIT",diff --git a/scripts/loudness.py b/scripts/loudness.pyindex c2ec386..d918936 100755--- a/scripts/loudness.py+++ b/scripts/loudness.py@@ -34,7 +34,9 @@ def measure(path: str, I: float, tp: float, lra: float) -> dict:data = json.loads(m.group(0))for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset"):if data.get(k) in (None, "-inf", "inf", "nan"):- die(f"loudnorm returned unusable value for {k}: {data.get(k)} (silent input?)")+ data["silent"] = True+ return data+ data["silent"] = Falsereturn data@@ -57,6 +59,12 @@ def main() -> int:die("input has no audio stream")stats = measure(args.input, args.lufs, args.tp, args.lra)+ if stats.get("silent"):+ info("audio is silent (integrated loudness -inf); nothing to normalise")+ if args.measure_only:+ print(json.dumps({"silent": True, "input_i": "-inf"}, indent=2))+ return 0+ die("input audio is silent; loudness normalisation is meaningless (use audio.py --replace to add a track)")info(f"measured: {float(stats['input_i']):.1f} LUFS, TP {float(stats['input_tp']):.1f} dBTP, LRA {float(stats['input_lra']):.1f} LU")if args.measure_only:print(json.dumps({k: stats[k] for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset")}, indent=2))@@ -79,7 +87,8 @@ def main() -> int:run(cmd)after = measure(output, args.lufs, args.tp, args.lra)- info(f"result: {float(after['input_i']):.1f} LUFS, TP {float(after['input_tp']):.1f} dBTP (target {args.lufs} LUFS)")+ if not after.get("silent"):+ info(f"result: {float(after['input_i']):.1f} LUFS, TP {float(after['input_tp']):.1f} dBTP (target {args.lufs} LUFS)")emit(output)return 0diff --git a/scripts/scenes.py b/scripts/scenes.pyindex 04161e0..62111b4 100755--- a/scripts/scenes.py+++ b/scripts/scenes.py@@ -23,17 +23,49 @@ from typing import Dict, List, Tuplefrom _common import add_common, apply_common, die, emit, ffmpeg_base, info, print_json, probe, require_tool, run-SCENE_RE = re.compile(r"lavfi\.scd\.time=([0-9.]+)")+SCORE_RE = re.compile(r"frame:(\d+)\s+pts:\d+\s+pts_time:([0-9.]+)")-def detect_scenes(path: str, threshold: float, min_len: float, duration: float) -> List[float]:+def detect_scenes(path: str, threshold: float, min_len: float, duration: float, ratio: float = 3.0) -> List[float]:+ """Scene cuts = frames whose scdet score is above `threshold` AND stands out from its+ neighbourhood (score > ratio x median of the surrounding +-12 frames). Sustained motion,+ flashes and fast pans raise the score on many consecutive frames and are rejected;+ a real cut is a one-frame spike. On real footage this roughly doubles precision at+ equal recall compared with the raw scdet threshold."""ffmpeg = require_tool("ffmpeg")proc = subprocess.run([ffmpeg, "-hide_banner", "-nostdin", "-i", path, "-an", "-vf",- f"scale=320:-2,scdet=threshold={threshold}:sc_pass=1,metadata=print:file=-", "-f", "null", "-"],+ "scale=320:-2,scdet=threshold=0:sc_pass=1,metadata=print:file=-", "-f", "null", "-"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)- times = [float(t) for t in SCENE_RE.findall(proc.stdout)]+ times: List[float] = []+ scores: List[float] = []+ cur_t = None+ for line in proc.stdout.splitlines():+ m = SCORE_RE.match(line)+ if m:+ cur_t = float(m.group(2))+ continue+ if line.startswith("lavfi.scd.score=") and cur_t is not None:+ try:+ times.append(cur_t)+ scores.append(float(line.split("=", 1)[1]))+ except ValueError:+ passcuts = [0.0]- for t in times:+ if not scores:+ return cuts+ w = 12+ for i, sc in enumerate(scores):+ if sc < threshold:+ continue+ lo, hi = max(0, i - w), min(len(scores), i + w + 1)+ neigh = sorted(scores[lo:i] + scores[i + 1:hi])+ med = neigh[len(neigh) // 2] if neigh else 0.0+ if sc < ratio * max(med, 0.5):+ continue+ # keep only the local maximum inside +-2 frames+ if any(scores[j] > sc for j in range(max(0, i - 2), min(len(scores), i + 3)) if j != i):+ continue+ t = times[i]if t - cuts[-1] >= min_len:cuts.append(t)if duration - cuts[-1] < min_len and len(cuts) > 1:@@ -60,7 +92,8 @@ def audio_envelope(path: str, step_s: float) -> List[float]:def main() -> int:ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)ap.add_argument("input")- ap.add_argument("--threshold", type=float, default=10.0, help="scdet threshold 0-100 (default 10; lower = more cuts)")+ ap.add_argument("--threshold", type=float, default=8.0, help="minimum scdet score for a cut, 0-100 (default 8)")+ ap.add_argument("--ratio", type=float, default=3.0, help="a cut must exceed this multiple of the neighbouring frames' median score (default 3; lower = more cuts)")ap.add_argument("--min-scene", type=float, default=1.0, help="ignore cuts closer than this in seconds (default 1)")ap.add_argument("--highlights", type=int, default=0, help="number of highlight ranges to propose")ap.add_argument("--target", type=float, help="with --highlights: total seconds the picks should add up to (trims long scenes)")@@ -75,7 +108,7 @@ def main() -> int:if not meta.get("video"):die("input has no video stream")dur = meta.get("duration") or 0.0- cuts = detect_scenes(args.input, args.threshold, args.min_scene, dur)+ cuts = detect_scenes(args.input, args.threshold, args.min_scene, dur, args.ratio)bounds = cuts + [dur]step_s = 0.5env = audio_envelope(args.input, step_s) if meta.get("audio") else []diff --git a/scripts/sync.py b/scripts/sync.pyindex e7fd177..21380e5 100755--- a/scripts/sync.py+++ b/scripts/sync.py@@ -92,6 +92,14 @@ def ifft(a: List[complex]) -> List[complex]:def cross_correlate(ref: List[float], other: List[float], max_lag: int):+ """Normalised cross-correlation over the overlapping region only.++ The raw FFT correlation sum grows with the overlap length, so with a 60 s window a+ correct 28 s offset (32 s overlap) loses to a wrong 2 s offset (58 s overlap) on+ music-like material. Dividing each lag by the energy of the overlapping parts+ (prefix sums, O(1) per lag) makes lags comparable and turns the peak value into a+ real similarity score in 0..1 that doubles as the confidence.+ """n = 1while n < len(ref) + len(other):n <<= 1@@ -99,15 +107,50 @@ def cross_correlate(ref: List[float], other: List[float], max_lag: int):fb = fft([complex(x) for x in other] + [0j] * (n - len(other)))prod = [x * y.conjugate() for x, y in zip(fa, fb)]corr = ifft(prod)- # corr[k] = sum ref[i+k]*other[i] -> lag k means 'other' is delayed by k relative to ref? see below- best_lag, best_val = 0, -float("inf")+ # prefix sums of squares for overlap energy+ def prefix(v: List[float]) -> List[float]:+ out = [0.0]+ acc = 0.0+ for x in v:+ acc += x * x+ out.append(acc)+ return out+ pr, po = prefix(ref), prefix(other)+ lr, lo = len(ref), len(other)max_lag = min(max_lag, n // 2 - 1)+ best_lag, best_val, second = 0, -float("inf"), -float("inf")+ # ignore lags with less than 35 % overlap: with the documented rule (analysis window >= 4x the+ # largest expected offset) true offsets always keep >= 75 % overlap, while short-overlap lags are+ # where coincidental matches on quasi-periodic material (music, tone beds) live+ min_overlap = max(10, int(0.35 * min(lr, lo)))+ scores = []for lag in range(-max_lag, max_lag + 1):- val = corr[lag % n].real+ # corr[lag] = sum_i ref[i] * other[i - lag] -> ref index range and other index range overlap:+ r0, r1 = max(0, lag), min(lr, lo + lag)+ if r1 - r0 < min_overlap:+ continue+ e_ref = pr[r1] - pr[r0]+ e_oth = po[r1 - lag] - po[r0 - lag]+ denom = math.sqrt(e_ref * e_oth)+ if denom <= 0:+ continue+ val = corr[lag % n].real / denom+ # mild preference for longer overlaps: a perfect match over 55 % of the window must not tie+ # with a perfect match over 100 % (quasi-periodic material). Exponent 0.5: with the window rule (>= 4x offset) a true match keeps >= 75 % overlap (x0.87) while a coincidental 55 % match drops to x0.74; keeps large true+ # offsets (28 s in 60 s = 53 % overlap -> x0.94) competitive while still breaking exact ties.+ val *= ((r1 - r0) / min(lr, lo)) ** 0.5+ scores.append((val, lag))if val > best_val:+ second = best_valbest_val, best_lag = val, lag- energy = math.sqrt(sum(x * x for x in ref) * sum(x * x for x in other)) or 1.0- return best_lag, best_val / energy+ elif val > second and abs(lag - best_lag) > 5:+ second = val+ # confidence: peak similarity, penalised when a distant runner-up is nearly as good+ conf = max(0.0, min(1.0, best_val))+ if second > -float("inf") and best_val > 0:+ margin = (best_val - second) / best_val+ conf *= min(1.0, 0.5 + margin)+ return best_lag, confdef refine(ref_s: List[float], oth_s: List[float], coarse_offset: float, fine_step: int, window_s: float) -> float:diff --git a/scripts/verify.py b/scripts/verify.pyindex 4675e01..7384356 100755--- a/scripts/verify.py+++ b/scripts/verify.py@@ -118,7 +118,7 @@ def main() -> int:plan.append(("overlay text", ["overlay.py", cut, "--text", "verify", "--position", "top-left", "-o", f"{stem}_ovl.mp4"] + fast))plan.append(("look sheet", ["look.py", cut, "-o", f"{stem}_sheet.png"]))if (meta.get("video") or {}).get("hdr"):- plan.append(("color to-sdr", ["color.py", str(f), "--to-sdr", "-o", f"{stem}_sdr.mp4"] + fast))+ plan.append(("color to-sdr", ["color.py", f"{stem}_acc.mp4", "--to-sdr", "-o", f"{stem}_sdr.mp4"] + fast))plan.append(("hdr preserved", ["__check_hdr__", f"{stem}_acc.mp4"]))plan.append(("probe analyze", ["probe.py", cut, "--analyze"]))plan.append(("export x", ["export.py", cut, "--preset", "x", "-o", f"{stem}_x.mp4"]))diff --git a/tests/bench_scenes.py b/tests/bench_scenes.pynew file mode 100644index 0000000..cbdba6c--- /dev/null+++ b/tests/bench_scenes.py@@ -0,0 +1,107 @@+#!/usr/bin/env python3+"""Accuracy benchmark for scenes.py cut detection (precision / recall / F1)+against synthetic sequences with known cut positions built from real footage.++Each case concatenates 6-10 random shots of 2-8 s taken from far-apart+positions in the source (so consecutive shots differ), records the exact cut+times, runs scenes.py and compares (a hit = detected cut within ±0.25 s).++Usage:+ python3 tests/bench_scenes.py --cases 10+ python3 tests/bench_scenes.py --cases 10 --threshold 6+"""+import argparse+import json+import random+import subprocess+import sys+import tempfile+from pathlib import Path++ROOT = Path(__file__).resolve().parent.parent+CORPUS = ROOT / "tests" / "corpus"+# continuous single-take sources (no internal cuts) so every detected cut inside a shot is a true false positive+DEFAULT_SRCS = [CORPUS / "gopro_GX010743.MP4", CORPUS / "dji_DJI_0038.MOV", CORPUS / "iphone_IMG_3179.MOV",+ CORPUS / "iphone13pro_4K60p.mov", CORPUS / "rtings_305_24p.mp4", CORPUS / "android_screen_2.mp4"]+++def sh(*cmd):+ return subprocess.run([str(c) for c in cmd], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)+++def main() -> int:+ ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)+ ap.add_argument("--source", action="append", help="continuous-take source(s); default: corpus single-take files")+ ap.add_argument("--cases", type=int, default=8)+ ap.add_argument("--seed", type=int, default=11)+ ap.add_argument("--threshold", type=float, default=10.0)+ ap.add_argument("--tolerance", type=float, default=0.25)+ ap.add_argument("--json")+ args = ap.parse_args()+ sources = [Path(p) for p in (args.source or [str(p) for p in DEFAULT_SRCS]) if Path(p).exists()]+ if not sources:+ print("no sources found (run tests/corpus.py --fetch)")+ return 1+ durs = {p: float(json.loads(sh("ffprobe", "-v", "error", "-print_format", "json", "-show_format", p).stdout)["format"]["duration"]) for p in sources}+ rng = random.Random(args.seed)+ tp = fp = fn = 0+ rows = []+ with tempfile.TemporaryDirectory(prefix="ffskill_bsc_") as tmp:+ for i in range(args.cases):+ n = rng.randint(6, 10)+ shots = []+ prev = None+ for _ in range(n):+ # alternate sources so consecutive shots always come from different footage+ cands = [p for p in sources if p != prev] or sources+ src = rng.choice(cands)+ l = rng.uniform(2, min(8, durs[src] - 1))+ st = rng.uniform(0.5, max(0.6, durs[src] - l - 0.5))+ shots.append((src, st, l))+ prev = src+ inputs, fc, labels = [], [], []+ cuts, t = [], 0.0+ for k, (src, s, l) in enumerate(shots):+ inputs += ["-ss", f"{s:.3f}", "-t", f"{l:.3f}", "-i", src]+ fc.append(f"[{k}:v]scale=640:360:force_original_aspect_ratio=decrease,pad=640:360:(ow-iw)/2:(oh-ih)/2,fps=24,setsar=1,format=yuv420p[v{k}]")+ labels.append(f"[v{k}]")+ t += l+ if k < n - 1:+ cuts.append(round(t, 3))+ fc.append("".join(labels) + f"concat=n={n}:v=1:a=0[out]")+ clip = Path(tmp) / f"case{i}.mp4"+ sh("ffmpeg", "-y", "-loglevel", "error", *inputs, "-filter_complex", ";".join(fc), "-map", "[out]", "-c:v", "libx264", "-preset", "veryfast", "-crf", "20", clip)+ proc = sh(sys.executable, ROOT / "scripts" / "scenes.py", clip, "--json", "--threshold", args.threshold, "--min-scene", "0.5")+ try:+ data = json.loads(proc.stdout)+ except ValueError:+ print(f"{i} scenes.py failed: {proc.stderr[-200:]}")+ continue+ detected = [sc["start"] for sc in data["scenes"] if sc["start"] > 0.01]+ matched = set()+ hits = 0+ for c in cuts:+ for j, d in enumerate(detected):+ if j not in matched and abs(d - c) <= args.tolerance:+ matched.add(j)+ hits += 1+ break+ case_fp = len(detected) - hits+ case_fn = len(cuts) - hits+ tp += hits+ fp += case_fp+ fn += case_fn+ rows.append({"case": i, "cuts": cuts, "detected": detected, "tp": hits, "fp": case_fp, "fn": case_fn})+ print(f"{i:2d} shots {n:2d} cuts {len(cuts):2d} detected {len(detected):2d} hit {hits:2d} fp {case_fp} fn {case_fn}")+ prec = tp / (tp + fp) if tp + fp else 0.0+ rec = tp / (tp + fn) if tp + fn else 0.0+ f1 = 2 * prec * rec / (prec + rec) if prec + rec else 0.0+ print("---")+ print(f"threshold {args.threshold:g}: precision {prec:.2f} recall {rec:.2f} F1 {f1:.2f} (tp {tp} fp {fp} fn {fn})")+ if args.json:+ Path(args.json).write_text(json.dumps({"threshold": args.threshold, "precision": prec, "recall": rec, "f1": f1, "cases": rows}, indent=2))+ return 0+++if __name__ == "__main__":+ sys.exit(main())diff --git a/tests/bench_silence.py b/tests/bench_silence.pynew file mode 100644index 0000000..3e588df--- /dev/null+++ b/tests/bench_silence.py@@ -0,0 +1,120 @@+#!/usr/bin/env python3+"""Accuracy benchmark for silence.py: insert known silences into real speech+and score what it keeps and cuts.++For each case: take a 20 s speech window from the source, splice in N gaps of+known length (0.4–3 s) at known positions, run silence.py --list and compare+the kept ranges with the ground truth.++Metrics: clipped speech (ms of real speech removed, per gap edge), leftover+silence (ms of inserted silence kept beyond the margin), missed gaps.++Usage:+ python3 tests/bench_silence.py --cases 30+"""+import argparse+import json+import random+import statistics+import subprocess+import sys+import tempfile+from pathlib import Path++ROOT = Path(__file__).resolve().parent.parent+DEFAULT_SRC = ROOT / "tests" / "corpus" / "tears_of_steel_720p.mov"+++def sh(*cmd):+ return subprocess.run([str(c) for c in cmd], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)+++def main() -> int:+ ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)+ ap.add_argument("--source", default=str(DEFAULT_SRC))+ ap.add_argument("--cases", type=int, default=20)+ ap.add_argument("--seed", type=int, default=3)+ ap.add_argument("--threshold", type=float, default=-35.0)+ ap.add_argument("--min-silence", type=float, default=0.6)+ ap.add_argument("--margin", type=float, default=0.15)+ ap.add_argument("--json")+ args = ap.parse_args()+ if not Path(args.source).exists():+ print(f"source not found: {args.source}")+ return 1+ dur = float(json.loads(sh("ffprobe", "-v", "error", "-print_format", "json", "-show_format", args.source).stdout)["format"]["duration"])+ rng = random.Random(args.seed)+ rows = []+ with tempfile.TemporaryDirectory(prefix="ffskill_bsil_") as tmp:+ for i in range(args.cases):+ start = rng.uniform(60, dur - 90)+ # 3 speech chunks of 4-7 s with gaps of known length between them (true silence = digital zero + tiny noise)+ chunks = [rng.uniform(4, 7) for _ in range(3)]+ gaps = [rng.uniform(0.4, 3.0) for _ in range(2)]+ parts = []+ fc = []+ t = start+ inputs = []+ n = 0+ timeline = [] # (kind, s, e) in output time+ cur = 0.0+ for k, c in enumerate(chunks):+ inputs += ["-ss", f"{t:.3f}", "-t", f"{c:.3f}", "-i", args.source]+ fc.append(f"[{n}:a]aformat=sample_rates=48000:channel_layouts=mono,volume=1.0[s{n}]")+ parts.append(f"[s{n}]")+ timeline.append(("speech", cur, cur + c))+ cur += c+ t += c + 3+ n += 1+ if k < len(gaps):+ g = gaps[k]+ fc.append(f"anoisesrc=a=0.0005:c=white:r=48000:d={g:.3f},aformat=channel_layouts=mono[g{k}]")+ parts.append(f"[g{k}]")+ timeline.append(("gap", cur, cur + g))+ cur += g+ fc.append("".join(parts) + f"concat=n={len(parts)}:v=0:a=1[out]")+ wav = Path(tmp) / f"case{i}.wav"+ sh("ffmpeg", "-y", "-loglevel", "error", *inputs, "-filter_complex", ";".join(fc), "-map", "[out]", wav)+ proc = sh(sys.executable, ROOT / "scripts" / "silence.py", wav, "--list", "--json", "--threshold", args.threshold, "--min-silence", args.min_silence, "--margin", args.margin)+ try:+ data = json.loads(proc.stdout)+ except ValueError:+ print(f"{i:3d} silence.py failed: {proc.stderr.strip()[-120:]}")+ continue+ keep = data["keep"]+ # score each inserted gap+ clipped_ms = 0.0+ leftover_ms = 0.0+ missed = 0+ for kind, s, e in timeline:+ if kind != "gap":+ continue+ if e - s < args.min_silence:+ continue # too short to be removed by design+ # portion of the gap that is kept (beyond margins) = leftover+ kept_in_gap = sum(max(0.0, min(ke, e - args.margin) - max(ks, s + args.margin)) for ks, ke in keep)+ if kept_in_gap >= (e - s) - 2 * args.margin - 0.05:+ missed += 1+ leftover_ms += kept_in_gap * 1000+ for kind, s, e in timeline:+ if kind != "speech":+ continue+ kept_speech = sum(max(0.0, min(ke, e) - max(ks, s)) for ks, ke in keep)+ clipped_ms += max(0.0, (e - s) - kept_speech) * 1000+ rows.append({"case": i, "gaps": [round(g, 2) for g in gaps], "clipped_speech_ms": round(clipped_ms), "leftover_silence_ms": round(leftover_ms), "missed_gaps": missed,+ "removed": data["removed_seconds"], "expected_removed": round(sum(max(0.0, g - 2 * args.margin) for g in gaps if g >= args.min_silence), 2)})+ print(f"{i:3d} gaps {rows[-1]['gaps']} clipped {clipped_ms:6.0f} ms leftover {leftover_ms:6.0f} ms missed {missed} removed {data['removed_seconds']:.2f}s (expected {rows[-1]['expected_removed']:.2f}s)")+ if not rows:+ return 1+ print("---")+ clip = [r["clipped_speech_ms"] for r in rows]+ left = [r["leftover_silence_ms"] for r in rows]+ print(f"cases {len(rows)}: clipped speech median {statistics.median(clip):.0f} ms, max {max(clip):.0f} ms; "+ f"leftover silence median {statistics.median(left):.0f} ms, max {max(left):.0f} ms; missed gaps {sum(r['missed_gaps'] for r in rows)}")+ if args.json:+ Path(args.json).write_text(json.dumps(rows, indent=2))+ return 0+++if __name__ == "__main__":+ sys.exit(main())diff --git a/tests/bench_sync.py b/tests/bench_sync.pynew file mode 100644index 0000000..1b91275--- /dev/null+++ b/tests/bench_sync.py@@ -0,0 +1,116 @@+#!/usr/bin/env python3+"""Accuracy benchmark for sync.py against known ground truth.++Takes a real dialogue/music source (Tears of Steel by default), cuts random+60 s reference windows, and builds a "second recording" of each with a known+delay, gain change, added noise, a mild EQ tilt and optional clock drift.+Then asks sync.py for the offset (and drift) and records the error.++Usage:+ python3 tests/bench_sync.py --cases 100+ python3 tests/bench_sync.py --cases 30 --drift # add ±300 ppm drift, measure with --fix-drift+ python3 tests/bench_sync.py --source my_interview.mp4 --cases 50 --json results.json+"""+import argparse+import json+import random+import statistics+import subprocess+import sys+import tempfile+from pathlib import Path++ROOT = Path(__file__).resolve().parent.parent+DEFAULT_SRC = ROOT / "tests" / "corpus" / "tears_of_steel_720p.mov"+++def sh(*cmd):+ return subprocess.run([str(c) for c in cmd], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)+++def main() -> int:+ ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)+ ap.add_argument("--source", default=str(DEFAULT_SRC))+ ap.add_argument("--cases", type=int, default=50)+ ap.add_argument("--window", type=float, default=120.0, help="reference window length in seconds (keep >= 4x --max-offset, the documented rule; 60 is the stress setting)")+ ap.add_argument("--max-offset", type=float, default=30.0)+ ap.add_argument("--drift", action="store_true", help="also apply ±300 ppm drift and measure with --fix-drift (uses 240 s windows)")+ ap.add_argument("--seed", type=int, default=7)+ ap.add_argument("--json", help="write per-case results here")+ args = ap.parse_args()+ if not Path(args.source).exists():+ print(f"source not found: {args.source} (run tests/corpus.py --fetch --only blender_tos_720)")+ return 1+ dur = float(json.loads(sh("ffprobe", "-v", "error", "-print_format", "json", "-show_format", args.source).stdout)["format"]["duration"])+ rng = random.Random(args.seed)+ window = 240.0 if args.drift else args.window+ results = []+ with tempfile.TemporaryDirectory(prefix="ffskill_bench_") as tmp:+ for i in range(args.cases):+ start = rng.uniform(10, max(11, dur - window - args.max_offset - 10))+ delay = rng.uniform(-args.max_offset, args.max_offset)+ gain_db = rng.uniform(-12, 6)+ noise = rng.choice([0.0, 0.002, 0.01, 0.03])+ tilt = rng.choice([0, 1, 2])+ ppm = rng.uniform(-300, 300) if args.drift else 0.0+ ref = Path(tmp) / f"ref{i}.wav"+ sec = Path(tmp) / f"sec{i}.wav"+ sh("ffmpeg", "-y", "-loglevel", "error", "-ss", f"{start:.3f}", "-i", args.source, "-t", f"{window:.3f}", "-vn", "-ac", "1", "-ar", "48000", ref)+ # second recording: starts `delay` later than the reference (positive = later start)+ sec_start = start + delay+ filters = [f"volume={gain_db:.2f}dB"]+ if tilt == 1:+ filters.append("highpass=f=300")+ elif tilt == 2:+ filters.append("lowpass=f=3000")+ if ppm:+ filters += [f"asetrate=48000*{1 + ppm / 1e6:.9f}", "aresample=48000"]+ af = ",".join(filters)+ if noise:+ sh("ffmpeg", "-y", "-loglevel", "error", "-ss", f"{sec_start:.3f}", "-i", args.source, "-f", "lavfi", "-i", f"anoisesrc=a={noise}:c=pink:r=48000",+ "-t", f"{window:.3f}", "-filter_complex", f"[0:a]{af}[a];[a][1:a]amix=inputs=2:duration=first:normalize=0[out]", "-map", "[out]", "-ac", "1", "-ar", "48000", sec)+ else:+ sh("ffmpeg", "-y", "-loglevel", "error", "-ss", f"{sec_start:.3f}", "-i", args.source, "-t", f"{window:.3f}", "-vn", "-af", af, "-ac", "1", "-ar", "48000", sec)+ cmd = [sys.executable, ROOT / "scripts" / "sync.py", ref, sec, "--json", "--max-offset", str(args.max_offset + 5)]+ if args.drift:+ cmd.append("--fix-drift")+ proc = sh(*cmd)+ try:+ data = json.loads(proc.stdout)+ measured = data["offset_seconds"]+ conf = data["confidence"]+ drift_ppm = data.get("drift", {}).get("drift_ppm")+ except (ValueError, KeyError):+ measured, conf, drift_ppm = None, 0.0, None+ # the second file was cut `delay` seconds later in the source, i.e. the recorder started `delay`+ # seconds after the camera: sync.py reports that as offset = +delay ("second starts later")+ expected = delay+ err_ms = None if measured is None else (measured - expected) * 1000+ # the second file plays at (1+ppm) speed of the source -> sync reports the second file as running slow/long by -ppm+ exp_drift = -ppm if ppm else 0.0+ drift_err = None if drift_ppm is None else drift_ppm - exp_drift+ results.append({"case": i, "delay": round(delay, 3), "gain_db": round(gain_db, 1), "noise": noise, "tilt": tilt, "ppm": round(ppm, 1),+ "measured": measured, "expected": round(expected, 3), "err_ms": None if err_ms is None else round(err_ms, 1),+ "confidence": conf, "drift_ppm": drift_ppm, "drift_err_ppm": None if drift_err is None else round(drift_err, 1)})+ flag = "" if err_ms is not None and abs(err_ms) <= 10 else " <-- "+ print(f"{i:3d} delay {delay:+7.3f}s gain {gain_db:+5.1f}dB noise {noise:<5} tilt {tilt} ppm {ppm:+6.0f} | got {measured!s:>8} err {err_ms!s:>8} ms conf {conf:.2f}"+ + (f" drift {drift_ppm:+.0f} (err {drift_err:+.0f})" if drift_ppm is not None else "") + flag)+ errs = [abs(r["err_ms"]) for r in results if r["err_ms"] is not None]+ fails = [r for r in results if r["err_ms"] is None or abs(r["err_ms"]) > 10]+ print("---")+ print(f"cases {len(results)}, within 10 ms: {len(results) - len(fails)} ({100 * (len(results) - len(fails)) / len(results):.0f}%), "+ f"median |err| {statistics.median(errs):.1f} ms, p95 {sorted(errs)[int(len(errs) * 0.95) - 1] if len(errs) > 1 else errs[0]:.1f} ms, max {max(errs):.1f} ms")+ if args.drift:+ derr = [abs(r["drift_err_ppm"]) for r in results if r["drift_err_ppm"] is not None]+ if derr:+ print(f"drift: median |err| {statistics.median(derr):.1f} ppm, p95 {sorted(derr)[int(len(derr) * 0.95) - 1] if len(derr) > 1 else derr[0]:.1f} ppm, within 20 ppm: {sum(1 for d in derr if d <= 20)}/{len(derr)}")+ if fails:+ low_conf = sum(1 for r in fails if r["confidence"] < 0.3)+ print(f"failures: {len(fails)}, of which flagged by confidence < 0.3: {low_conf}")+ if args.json:+ Path(args.json).write_text(json.dumps(results, indent=2))+ return 0+++if __name__ == "__main__":+ sys.exit(main())diff --git a/tests/corpus.py b/tests/corpus.pynew file mode 100644index 0000000..5dcc082--- /dev/null+++ b/tests/corpus.py@@ -0,0 +1,177 @@+#!/usr/bin/env python3+"""Real-world corpus: download public sample videos from many devices/codecs+and run verify.py on them. Files are cached in tests/corpus/ (git-ignored).++Each entry records where it came from, why it is in the corpus, and what+probe.py is expected to say about it, so a regression is a diff, not a vibe.++Usage:+ python3 tests/corpus.py --list+ python3 tests/corpus.py --fetch # download everything (size-capped)+ python3 tests/corpus.py --fetch --only gopro,android_screen+ python3 tests/corpus.py --verify # verify.py on what is downloaded -> tests/corpus/report.md+ python3 tests/corpus.py --expect # compare probe output with the expectations in the manifest+"""+import argparse+import json+import subprocess+import sys+import urllib.error+import urllib.request+from pathlib import Path++ROOT = Path(__file__).resolve().parent.parent+DEST = ROOT / "tests" / "corpus"+UA = {"User-Agent": "ffmpeg-skill-corpus/0.1 (+https://github.com/kajisho5/ffmpeg-skill)"}++MANIFEST = [+ {"id": "gopro_hero", "url": "https://archive.org/download/grizzly-bear-selfie/GX010743.MP4", "file": "gopro_GX010743.MP4",+ "source": "archive.org grizzly-bear-selfie (user upload)", "why": "GoPro HERO native file: GPMF metadata track, 4:2:0 HEVC/H.264, high bitrate, extra data streams", "max_mb": 260,+ "expect": {"video.codec": ["hevc", "h264"], "audio.channels": 2}},+ {"id": "dji_drone", "url": "https://archive.org/download/dji-0230/DJI_0038.MOV", "file": "dji_DJI_0038.MOV",+ "source": "archive.org dji-0230 (user upload)", "why": "DJI drone .MOV: 4K, D-Log/normal profile, possibly no audio", "max_mb": 200,+ "expect": {"video.codec": ["hevc", "h264"]}},+ {"id": "iphone_mov", "url": "https://archive.org/download/jupiter-canyon/IMG_3179.MOV", "file": "iphone_IMG_3179.MOV",+ "source": "archive.org jupiter-canyon (user upload)", "why": "iPhone .MOV from another device/generation than the local sample", "max_mb": 80,+ "expect": {"video.codec": ["hevc", "h264"]}},+ {"id": "android_screen", "url": "https://archive.org/download/screen-recording-20231223-021623/Screen_Recording_20231223_021623.mp4", "file": "android_screen_1.mp4",+ "source": "archive.org screen-recording-20231223-021623", "why": "Android screen recording: VFR, odd resolution, possibly mono/no audio", "max_mb": 20,+ "expect": {}},+ {"id": "android_screen2", "url": "https://archive.org/download/screen-recording-20260303-174357-2/Screen_Recording_20260303_174357(2).mp4", "file": "android_screen_2.mp4",+ "source": "archive.org screen-recording-20260303-174357-2", "why": "second Android screen recording", "max_mb": 20, "expect": {}},+ {"id": "hdr10_pattern", "url": "https://archive.org/download/mehanik-hdr10-test-patterns/02.%20White%20%26%20Color%20clipping/02.%20White%20240-1000nits-MaxCLL-1000-MDL-1000.mp4", "file": "hdr10_white_clipping.mp4",+ "source": "archive.org mehanik-hdr10-test-patterns", "why": "HDR10 (PQ, BT.2020) with MaxCLL/MDL metadata: tone-map and tag handling", "max_mb": 60,+ "expect": {"video.hdr": True, "video.color_transfer": "smpte2084"}},+ {"id": "iphone13_4k60", "url": "https://img.photographyblog.com/reviews/apple_iphone_13_pro/sample_images/4K60p.mov", "file": "iphone13pro_4K60p.mov",+ "source": "photographyblog.com iPhone 13 Pro review samples", "why": "iPhone 13 Pro 4K60 .mov (Dolby Vision HLG expected), large frame + high fps", "max_mb": 400,+ "expect": {"video.codec": "hevc", "video.hdr": True}},+ {"id": "blender_tos_720", "url": "https://download.blender.org/demo/movies/ToS/tears_of_steel_720p.mov", "file": "tears_of_steel_720p.mov",+ "source": "Blender Foundation, Tears of Steel (CC-BY 3.0)", "why": "clean H.264 .mov with real dialogue, music and scene cuts for scenes/silence/loudness", "max_mb": 400,+ "expect": {"video.codec": "h264", "audio.channels": 2}},+ {"id": "vp9_hdr", "url": "https://storage.googleapis.com/media.webmproject.org/devsite/vp9/hdr-encoding/strobe_scientist.mkv", "file": "vp9_hdr_strobe_scientist.mkv",+ "source": "webmproject.org VP9 HDR encoding guide", "why": "VP9 10-bit HDR in Matroska: non-HEVC HDR path", "max_mb": 200,+ "expect": {"video.codec": "vp9", "video.hdr": True}},+ {"id": "rtings_24p", "url": "https://www.rtings.com/images/test-materials/2015/305_24p.mp4", "file": "rtings_305_24p.mp4",+ "source": "rtings.com test materials", "why": "24p judder test clip: fps handling", "max_mb": 100, "expect": {"video.fps": 24.0}},+]+++def fetch(entry: dict, force: bool = False) -> Path:+ """Download with a size cap, resume (HTTP Range) and a final length check, so a dropped+ connection never leaves a truncated file that looks complete."""+ DEST.mkdir(parents=True, exist_ok=True)+ out = DEST / entry["file"]+ cap = entry["max_mb"] * 1024 * 1024+ head = urllib.request.urlopen(urllib.request.Request(entry["url"], headers=UA, method="HEAD"), timeout=60)+ total = int(head.headers.get("Content-Length") or 0)+ if total and total > cap:+ raise RuntimeError(f"{entry['id']}: {total / 1e6:.0f} MB exceeds cap {entry['max_mb']} MB")+ if out.exists() and not force and (not total or out.stat().st_size == total):+ return out+ tmp = out.with_suffix(out.suffix + ".part")+ if force and tmp.exists():+ tmp.unlink()+ for attempt in range(5):+ have = tmp.stat().st_size if tmp.exists() else 0+ if total and have >= total:+ break+ headers = dict(UA)+ if have:+ headers["Range"] = f"bytes={have}-"+ try:+ with urllib.request.urlopen(urllib.request.Request(entry["url"], headers=headers), timeout=60) as resp:+ mode = "ab" if have and resp.status == 206 else "wb"+ if mode == "wb":+ have = 0+ with open(tmp, mode) as fh:+ while True:+ chunk = resp.read(1 << 20)+ if not chunk:+ break+ fh.write(chunk)+ have += len(chunk)+ if have > cap:+ raise RuntimeError(f"{entry['id']}: exceeded cap while downloading")+ except (OSError, urllib.error.URLError) as exc: # noqa: PERF203+ if attempt == 4:+ raise RuntimeError(f"{entry['id']}: download failed after retries: {exc}")+ continue+ if not total:+ break+ size = tmp.stat().st_size if tmp.exists() else 0+ if total and size != total:+ raise RuntimeError(f"{entry['id']}: got {size} of {total} bytes")+ tmp.rename(out)+ return out+++def probe(path: Path) -> dict:+ proc = subprocess.run([sys.executable, str(ROOT / "scripts" / "probe.py"), str(path)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)+ return json.loads(proc.stdout) if proc.returncode == 0 else {"error": proc.stderr.strip()[-200:]}+++def dig(d: dict, dotted: str):+ cur = d+ for k in dotted.split("."):+ cur = cur.get(k) if isinstance(cur, dict) else None+ return cur+++def main() -> int:+ ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)+ ap.add_argument("--list", action="store_true")+ ap.add_argument("--fetch", action="store_true")+ ap.add_argument("--force", action="store_true")+ ap.add_argument("--only", help="comma separated ids")+ ap.add_argument("--verify", action="store_true")+ ap.add_argument("--expect", action="store_true")+ ap.add_argument("--quick", action="store_true", help="verify --quick")+ args = ap.parse_args()+ entries = [e for e in MANIFEST if not args.only or e["id"] in args.only.split(",")]+ if args.list or not (args.fetch or args.verify or args.expect):+ for e in entries:+ have = (DEST / e["file"]).exists()+ print(f"{'have' if have else ' '} {e['id']:16s} {e['why'][:70]}\n {e['source']}")+ return 0+ rc = 0+ if args.fetch:+ for e in entries:+ try:+ p = fetch(e, args.force)+ print(f"ok {e['id']:16s} {p.stat().st_size / 1e6:6.1f} MB {p.name}")+ except Exception as exc: # noqa: BLE001+ print(f"FAIL {e['id']:16s} {exc}")+ rc = 1+ if args.expect:+ for e in entries:+ p = DEST / e["file"]+ if not p.exists():+ continue+ m = probe(p)+ v = m.get("video") or {}+ a = m.get("audio") or {}+ line = f"{e['id']:16s} {v.get('codec')} {v.get('width')}x{v.get('height')} @{v.get('fps')} {v.get('pix_fmt')} {v.get('hdr_format') or 'SDR'}{' VFR?' if v.get('variable_frame_rate_suspected') else ''} rot={v.get('rotation')} | audio {a.get('codec')} {a.get('channels')}ch | {m.get('duration')}s"+ bad = []+ for key, want in e.get("expect", {}).items():+ got = dig(m, key)+ ok = got in want if isinstance(want, list) else (abs(got - want) < 0.05 if isinstance(want, float) and isinstance(got, (int, float)) else got == want)+ if not ok:+ bad.append(f"{key}: expected {want}, got {got}")+ print(("ok " if not bad else "DIFF ") + line + (("\n " + "; ".join(bad)) if bad else ""))+ rc |= 1 if bad else 0+ if args.verify:+ files = [str(DEST / e["file"]) for e in entries if (DEST / e["file"]).exists()]+ if not files:+ print("nothing downloaded; run --fetch first")+ return 1+ cmd = [sys.executable, str(ROOT / "scripts" / "verify.py")] + files + ["--report", str(DEST / "report.md"), "--out", str(DEST / "out"), "--keep"]+ if args.quick:+ cmd.append("--quick")+ proc = subprocess.run(cmd)+ rc |= proc.returncode+ print(f"report: {DEST / 'report.md'}")+ return rc+++if __name__ == "__main__":+ sys.exit(main())diff --git a/tests/test_all.py b/tests/test_all.pyindex d045681..b1691ee 100644--- a/tests/test_all.py+++ b/tests/test_all.py@@ -761,6 +761,35 @@ class FFmpegSkillTests(unittest.TestCase):self.assertIn("no local speech-to-text engine", proc.stderr)self.assertIn("whisper", proc.stderr)+ # ---------------------------------------------------------------- Phase 3 regressions+ def test_sync_large_offset_on_repetitive_music(self):+ # repetitive music-like signal: a 4-bar loop with slow variation; raw correlation used to prefer+ # the small-overlap-friendly wrong lag, NCC must find the true -28 s offset in a 60 s window+ loop = OUT / "loop.wav"+ # speech-like: dialogue from the demo tones plus random-looking bursts (incommensurate gates,+ # a slowly drifting pitch and pink-noise "room"), so no two 9 s stretches look alike+ expr = (TONES + "+0.25*sin(2*PI*(165+30*sin(2*PI*0.031*t))*t)*gt(sin(2*PI*0.113*t+0.4)\\,0.55)"+ "+0.3*sin(2*PI*(520+80*sin(2*PI*0.017*t+1))*t)*gt(sin(2*PI*0.29*t+2.1)*sin(2*PI*0.073*t)\\,0.35)")+ sh("ffmpeg", "-y", "-hide_banner", "-loglevel", "error", "-f", "lavfi", "-i", f"aevalsrc='{expr}':s=48000",+ "-f", "lavfi", "-i", "anoisesrc=a=0.02:c=pink:r=48000", "-t", "200", "-filter_complex", "amix=inputs=2:duration=first:normalize=0", "-c:a", "pcm_s16le", loop)+ ref = OUT / "loop_ref.wav"+ sec = OUT / "loop_sec.wav"+ # 28 s offset inside a 120 s analysis window (the documented rule: window >= 4x max offset)+ sh("ffmpeg", "-y", "-hide_banner", "-loglevel", "error", "-ss", "40", "-i", loop, "-t", "120", "-c:a", "pcm_s16le", ref)+ sh("ffmpeg", "-y", "-hide_banner", "-loglevel", "error", "-ss", "12", "-i", loop, "-t", "120", "-af", "volume=-8dB,highpass=f=300", "-c:a", "pcm_s16le", sec)+ data = json.loads(script("sync.py", ref, sec, "--json", "--max-offset", "30").stdout)+ self.assertClose(data["offset_seconds"], -28.0, 0.02)+ self.assertGreater(data["confidence"], 0.3)++ def test_loudness_silent_input_is_reported_not_crashed(self):+ silent = OUT / "silent.mp4"+ sh("ffmpeg", "-y", "-hide_banner", "-loglevel", "error", "-f", "lavfi", "-i", "testsrc2=size=320x180:rate=30", "-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo",+ "-t", "3", "-c:v", "libx264", "-preset", "veryfast", "-c:a", "aac", silent)+ data = json.loads(script("loudness.py", silent, "--measure-only").stdout)+ self.assertTrue(data["silent"])+ proc = script("loudness.py", silent, "-o", OUT / "silent_norm.mp4", expect_fail=True)+ self.assertIn("silent", proc.stderr)+# ---------------------------------------------------------------- helpdef test_every_script_has_help(self):for name in sorted(p.name for p in SCRIPTS.glob("*.py") if not p.name.startswith("_")):