ffmpeg-skill 0.1.0 → 0.3.0

package/scripts/look.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Give the agent eyes: pull frames or a contact sheet out of a video as PNG so
+the result can be inspected (caption placement, logo position, crop, colour).
+
+Examples:
+  python3 look.py final.mp4                          # 12-tile contact sheet with timecodes -> final_sheet.png
+  python3 look.py final.mp4 --tiles 4x5 --width 1600
+  python3 look.py final.mp4 --at 2.5 --at 7          # single frames -> final_2.500s.png, final_7.000s.png
+  python3 look.py before.mp4 --compare after.mp4 --at 4   # side-by-side frame
+Then view the PNG (Read tool / image viewer) and verify before reporting.
+"""
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import List
+
+from _common import add_common, apply_common, die, emit, escape_drawtext, ffmpeg_base, info, parse_time, probe, run
+
+FONT = "fontcolor=white:fontsize=h/18:box=1:boxcolor=black@0.55:boxborderw=6:x=8:y=8"
+
+
+def timecode_filter() -> str:
+    return f"drawtext=text='%{{pts\\:hms}}':{FONT}"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("input")
+    ap.add_argument("-o", "--output", help="output PNG (contact sheet / compare) or basename for --at frames")
+    ap.add_argument("--at", action="append", help="time of a frame to extract (repeatable)")
+    ap.add_argument("--tiles", default="4x3", help="contact sheet grid COLSxROWS (default 4x3)")
+    ap.add_argument("--width", type=int, default=1280, help="total width of the sheet / compare image (default 1280)")
+    ap.add_argument("--compare", help="second video: place its frame next to the first (needs --at)")
+    ap.add_argument("--no-timecode", action="store_true")
+    add_common(ap)
+    args = ap.parse_args()
+    apply_common(args)
+
+    meta = probe(args.input)
+    if not meta.get("video"):
+        die("input has no video stream")
+    dur = meta.get("duration") or 0.0
+    stem = Path(args.input).stem
+    outdir = str(Path(args.output).parent) if args.output else str(Path(args.input).parent)
+    tc = "" if args.no_timecode else "," + timecode_filter()
+    outputs: List[str] = []
+
+    if args.compare:
+        if not args.at:
+            die("--compare needs --at TIME")
+        probe(args.compare)
+        for t in args.at:
+            sec = parse_time(t)
+            out = args.output or os.path.join(outdir, f"{stem}_vs_{Path(args.compare).stem}_{sec:.3f}s.png")
+            half = args.width // 2
+            fc = (f"[0:v]scale={half}:-2{tc}[a];[1:v]scale={half}:-2{tc}[b];"
+                  f"[a][b]scale2ref=w=iw:h=ih[a2][b2];[a2][b2]hstack=inputs=2[out]")
+            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", "-i", args.input, "-ss", f"{sec:.3f}", "-i", args.compare,
+                                   "-filter_complex", fc, "-map", "[out]", "-frames:v", "1", out]
+            run(cmd)
+            outputs.append(out)
+    elif args.at:
+        for t in args.at:
+            sec = parse_time(t)
+            if dur and sec > dur:
+                die(f"--at {t} is beyond the duration ({dur:.2f}s)")
+            out = os.path.join(outdir, f"{args.output and Path(args.output).stem or stem}_{sec:.3f}s.png")
+            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", "-i", args.input, "-vf", f"scale={args.width}:-2{tc}", "-frames:v", "1", out]
+            run(cmd)
+            outputs.append(out)
+    else:
+        try:
+            cols, rows = (int(x) for x in args.tiles.lower().split("x"))
+        except ValueError:
+            die("--tiles must look like 4x3")
+        n = cols * rows
+        if not dur:
+            die("cannot build a contact sheet without a known duration")
+        step = dur / n
+        tile_w = max(2, (args.width // cols) // 2 * 2)
+        out = args.output or os.path.join(outdir, f"{stem}_sheet.png")
+        # sample at the middle of each slice so the first/last tiles are not black lead-in/out frames
+        vf = (f"select='isnan(prev_selected_t)+gte(t-prev_selected_t\\,{step * 0.98:.6f})',scale={tile_w}:-2{tc},"
+              f"tile={cols}x{rows}:padding=2:margin=2:color=0x202020")
+        cmd = ffmpeg_base() + ["-ss", f"{step / 2:.6f}", "-i", args.input, "-vf", vf, "-frames:v", "1", out]
+        run(cmd)
+        outputs.append(out)
+        info(f"contact sheet: {n} frames every {step:.2f}s")
+
+    for o in outputs:
+        info(f"wrote {o}")
+    emit(outputs[0] if len(outputs) == 1 else None, outputs=outputs)
+    if len(outputs) > 1 and not args.json:
+        for o in outputs:
+            print(o)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/loudness.py

@@ -18,7 +18,7 @@ import os
 import re
 import sys
 
-from _common import AUDIO_CODECS, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run
+from _common import add_common, apply_common, emit, AUDIO_CODECS, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run
 
 
 
@@ -46,7 +46,9 @@ def main() -> int:
     ap.add_argument("--measure-only", action="store_true", help="print the measured stats as JSON and exit")
     ap.add_argument("--audio-bitrate", default="192k", help="AAC bitrate when the container is video (default 192k)")
     ap.add_argument("--sample-rate", type=int, help="output sample rate (default: 48000; loudnorm upsamples internally to 192k)")
+    add_common(ap)
     args = ap.parse_args()
+    apply_common(args)
 
     meta = probe(args.input)
     if not meta.get("audio"):
@@ -76,7 +78,7 @@ def main() -> int:
 
     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)")
-    print(output)
+    emit(output)
     return 0
 
 

package/scripts/overlay.py

@@ -15,7 +15,7 @@ import argparse
 import sys
 from typing import List, Optional
 
-from _common import aac_args, default_output, die, escape_drawtext, escape_filter_path, ffmpeg_base, info, parse_time, probe, run, x264_args
+from _common import add_common, apply_common, emit, aac_args, cfr_args, default_output, die, escape_drawtext, escape_filter_path, ffmpeg_base, info, parse_time, probe, run, x264_args
 
 POS = {
     "top-left": ("{m}", "{m}"),
@@ -100,7 +100,9 @@ def main() -> int:
     enc = ap.add_argument_group("encoding")
     enc.add_argument("--crf", type=int, default=18)
     enc.add_argument("--preset", default="medium")
+    add_common(ap)
     args = ap.parse_args()
+    apply_common(args)
 
     meta = probe(args.input)
     if not meta.get("video"):
@@ -157,13 +159,13 @@ def main() -> int:
             opts.append(f"enable='{enable}'")
         cmd += ["-vf", "drawtext=" + ":".join(opts)]
 
-    cmd += x264_args(args.crf, args.preset)
+    cmd += x264_args(args.crf, args.preset) + cfr_args(meta)
     cmd += aac_args() if meta.get("audio") else ["-an"]
     cmd.append(output)
     run(cmd)
     result = probe(output)
     info(f"wrote {output} ({result['duration']:.3f}s)")
-    print(output)
+    emit(output)
     return 0
 
 

package/scripts/silence.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""Remove silences / dead air (jump-cut editing) or just list them.
+
+Detects quiet stretches with ffmpeg's silencedetect, keeps a margin on each
+side so words are not clipped, drops gaps shorter than --min-silence, and
+writes a frame-accurate re-encode in one pass (select/aselect filters).
+
+Examples:
+  python3 silence.py talk.mp4                                 # -35 dB, gaps >= 0.6 s, 0.15 s margin
+  python3 silence.py talk.mp4 --threshold -40 --min-silence 1 --margin 0.25
+  python3 silence.py talk.mp4 --list                          # print the silences and the resulting cut list, no output
+  python3 silence.py talk.mp4 --edl keep.txt                  # also save the kept ranges (START-END per line, cut.py --segments format)
+"""
+import argparse
+import re
+import sys
+from typing import List, Tuple
+
+from _common import aac_args, add_common, apply_common, cfr_args, default_output, die, emit, ffmpeg_base, info, print_json, probe, require_tool, run, x264_args
+
+SIL_RE = re.compile(r"silence_(start|end): ([0-9.]+)")
+
+
+def detect(path: str, threshold: float, min_silence: float) -> List[Tuple[float, float]]:
+    ffmpeg = require_tool("ffmpeg")
+    cmd = [ffmpeg, "-hide_banner", "-nostdin", "-i", path, "-vn", "-af",
+           f"silencedetect=noise={threshold}dB:d={min_silence}", "-f", "null", "-"]
+    proc = run(cmd, quiet=True, check=False)
+    if proc.returncode != 0:
+        die(f"silencedetect failed:\n{proc.stderr.strip()[-800:]}")
+    silences: List[Tuple[float, float]] = []
+    start = None
+    for kind, val in SIL_RE.findall(proc.stderr):
+        if kind == "start":
+            start = float(val)
+        elif start is not None:
+            silences.append((start, float(val)))
+            start = None
+    if start is not None:  # silence runs to the end
+        silences.append((start, float("inf")))
+    return silences
+
+
+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 silences:
+        s_adj = max(cursor, s + margin)
+        if s_adj - cursor >= min_keep:
+            keeps.append((cursor, s_adj))
+        cursor = min(duration, e - margin) if e != float("inf") else duration
+    if duration - cursor >= min_keep:
+        keeps.append((cursor, duration))
+    return keeps
+
+
+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>_tight.<ext>)")
+    ap.add_argument("--threshold", type=float, default=-35.0, help="silence level in dBFS (default -35; use -40..-45 for quiet rooms)")
+    ap.add_argument("--min-silence", type=float, default=0.6, help="only remove gaps at least this long in seconds (default 0.6)")
+    ap.add_argument("--margin", type=float, default=0.15, help="seconds of silence to keep on each side of speech (default 0.15)")
+    ap.add_argument("--min-keep", type=float, default=0.2, help="drop kept pieces shorter than this (default 0.2)")
+    ap.add_argument("--list", action="store_true", help="only print silences and the kept ranges")
+    ap.add_argument("--edl", help="write the kept ranges to this file, one START-END per line")
+    ap.add_argument("--crf", type=int, default=18)
+    ap.add_argument("--preset", default="medium")
+    add_common(ap)
+    args = ap.parse_args()
+    apply_common(args)
+
+    meta = probe(args.input)
+    if not meta.get("audio"):
+        die("input has no audio stream to analyse")
+    duration = meta.get("duration") or 0.0
+    silences = detect(args.input, args.threshold, args.min_silence)
+    keeps = keep_ranges(silences, duration, args.margin, args.min_keep)
+    kept = sum(e - s for s, e in keeps)
+    removed = max(0.0, duration - kept)
+    summary = {
+        "silences": [[round(s, 3), None if e == float("inf") else round(e, 3)] for s, e in silences],
+        "keep": [[round(s, 3), round(e, 3)] for s, e in keeps],
+        "input_duration": round(duration, 3),
+        "kept_duration": round(kept, 3),
+        "removed_seconds": round(removed, 3),
+    }
+    info(f"{len(silences)} silences, keeping {len(keeps)} ranges: {kept:.2f}s of {duration:.2f}s (removing {removed:.2f}s)")
+
+    if args.edl:
+        with open(args.edl, "w", encoding="utf-8") as fh:
+            for s, e in keeps:
+                fh.write(f"{s:.3f}-{e:.3f}\n")
+        info(f"wrote {args.edl}")
+
+    if args.list:
+        if args.json:
+            emit(None, **summary)
+        else:
+            print_json(summary)
+        return 0
+    if not keeps:
+        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")
+
+    output = args.output or default_output(args.input, "tight")
+    expr = "+".join(f"between(t,{s:.3f},{e:.3f})" for s, e in keeps)
+    vf = f"select='{expr}',setpts=N/FRAME_RATE/TB"
+    af = f"aselect='{expr}',asetpts=N/SR/TB"
+    cmd = ffmpeg_base() + ["-i", args.input]
+    if meta.get("video"):
+        cmd += ["-vf", vf] + x264_args(args.crf, args.preset) + cfr_args(meta)
+    cmd += ["-af", af] + aac_args() + [output]
+    run(cmd)
+    r = probe(output)
+    info(f"wrote {output} ({r['duration']:.3f}s, expected ~{kept:.3f}s)")
+    emit(output, **summary)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/sync.py

@@ -1,11 +1,10 @@
 #!/usr/bin/env python3
 """Detect the time offset between two recordings by audio cross-correlation
-and (optionally) write a synced output.
+and (optionally) write a synced output, with optional clock-drift correction.
 
 Pure standard library: both tracks are decoded by ffmpeg to mono 8 kHz PCM,
-reduced to a coarse loudness envelope, and cross-correlated with an FFT
-implemented in Python. Precision is roughly +/- one envelope step (default
-5 ms), which is plenty for lining up a lav mic or a second camera.
+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.
@@ -15,6 +14,7 @@ Examples:
   python3 sync.py camera.mp4 lavmic.wav --replace-audio -o synced.mp4
   python3 sync.py camA.mp4 camB.mp4 --trim-second -o camB_synced.mp4
   python3 sync.py cam.mp4 mic.wav --max-offset 60 --json
+  python3 sync.py cam.mp4 recorder.wav --fix-drift --replace-audio   # long takes: fix clock drift too
 """
 import argparse
 import cmath
@@ -26,14 +26,14 @@ import subprocess
 import sys
 from typing import List
 
-from _common import aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, x264_args
+from _common import add_common, apply_common, emit, aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, x264_args
 
 SR = 8000  # decode sample rate
 
 
-def decode_mono(path: str, seconds: float) -> List[float]:
+def decode_mono(path: str, seconds: float, start: float = 0.0) -> List[float]:
     ffmpeg = require_tool("ffmpeg")
-    cmd = [ffmpeg, "-hide_banner", "-loglevel", "error", "-nostdin", "-i", path, "-t", f"{seconds:.3f}",
+    cmd = [ffmpeg, "-hide_banner", "-loglevel", "error", "-nostdin", "-ss", f"{start:.3f}", "-i", path, "-t", f"{seconds:.3f}",
            "-vn", "-ac", "1", "-ar", str(SR), "-f", "s16le", "-"]
     proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     if proc.returncode != 0 or not proc.stdout:
@@ -110,6 +110,45 @@ def cross_correlate(ref: List[float], other: List[float], max_lag: int):
     return best_lag, best_val / energy
 
 
+def refine(ref_s: List[float], oth_s: List[float], coarse_offset: float, fine_step: int, window_s: float) -> float:
+    """Direct correlation at fine resolution around a coarse estimate (+/- window_s)."""
+    ref_e = envelope(ref_s, fine_step)
+    oth_e = envelope(oth_s, fine_step)
+    centre = int(round(coarse_offset * SR / fine_step))
+    span = int(window_s * SR / fine_step)
+    best_lag, best_val = centre, -float("inf")
+    n = min(len(ref_e), len(oth_e))
+    for lag in range(centre - span, centre + span + 1):
+        # ref[i] ~ oth[i - lag]
+        lo, hi = max(0, lag), min(n, n + lag)
+        if hi - lo < 10:
+            continue
+        val = 0.0
+        for i in range(lo, hi):
+            val += ref_e[i] * oth_e[i - lag]
+        val /= (hi - lo)
+        if val > best_val:
+            best_val, best_lag = val, lag
+    return best_lag * fine_step / SR
+
+
+def measure_offset(ref_path: str, oth_path: str, start: float, seconds: float, step_ms: float, max_offset: float, fine_ms: float):
+    """Return (offset_seconds, confidence) for a window starting at `start` in both files."""
+    ref_s = decode_mono(ref_path, seconds, start)
+    oth_s = decode_mono(oth_path, seconds, start)
+    step = max(1, int(SR * step_ms / 1000))
+    ref = envelope(ref_s, step)
+    oth = envelope(oth_s, step)
+    if len(ref) < 10 or len(oth) < 10:
+        die("not enough audio to analyse")
+    max_lag = int(max_offset * SR / step)
+    lag, score = cross_correlate(ref, oth, max_lag)
+    offset = lag * step / SR
+    if fine_ms and fine_ms < step_ms:
+        offset = refine(ref_s, oth_s, offset, max(1, int(SR * fine_ms / 1000)), step_ms / 1000 * 2)
+    return offset, max(0.0, min(1.0, score))
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("reference", help="reference recording (usually the camera video)")
@@ -117,30 +156,63 @@ def main() -> int:
     ap.add_argument("-o", "--output", help="output file when writing a synced result")
     ap.add_argument("--max-offset", type=float, default=30.0, help="largest offset to search in seconds (default 30)")
     ap.add_argument("--analyze-seconds", type=float, default=120.0, help="how much audio to analyse from each file (default 120)")
-    ap.add_argument("--step-ms", type=float, default=5.0, help="envelope resolution in ms (default 5)")
-    ap.add_argument("--json", action="store_true", help="print the result as JSON")
+    ap.add_argument("--step-ms", type=float, default=20.0, help="coarse envelope resolution in ms for the FFT search (default 20)")
+    ap.add_argument("--fine-ms", type=float, default=1.0, help="fine resolution in ms for the refinement pass, 0 to skip (default 1)")
+    ap.add_argument("--fix-drift", action="store_true", help="also measure the offset near the END and correct clock drift by resampling the second file")
+    ap.add_argument("--drift-window", type=float, default=60.0, help="seconds of audio analysed at each end for drift (default 60)")
     mode = ap.add_mutually_exclusive_group()
     mode.add_argument("--replace-audio", action="store_true", help="write reference video with the second file's audio, aligned")
     mode.add_argument("--trim-second", action="store_true", help="write the second file shifted so it lines up with the reference")
     ap.add_argument("--crf", type=int, default=18)
+    add_common(ap)
     args = ap.parse_args()
+    apply_common(args)
 
     for p in (args.reference, args.second):
         if not probe(p).get("audio"):
             die(f"{p} has no audio stream to correlate")
 
-    step = max(1, int(SR * args.step_ms / 1000))
-    ref = envelope(decode_mono(args.reference, args.analyze_seconds), step)
-    oth = envelope(decode_mono(args.second, args.analyze_seconds), step)
-    if len(ref) < 10 or len(oth) < 10:
-        die("not enough audio to analyse")
+    offset, score = measure_offset(args.reference, args.second, 0.0, args.analyze_seconds, args.step_ms, args.max_offset, args.fine_ms)
 
-    max_lag = int(args.max_offset * SR / step)
-    lag, score = cross_correlate(ref, oth, max_lag)
-    # With prod = FFT(ref) * conj(FFT(other)), the peak sits at lag k where ref[i] ~ other[i - k]:
-    # the same event happens k steps later in the reference than in the second file, which
-    # means the second recording STARTED k steps later. Positive offset = second starts later.
-    offset = lag * step / SR
+    drift_ratio = 1.0
+    drift_info = None
+    if args.fix_drift:
+        ref_dur = probe(args.reference)["duration"] or 0.0
+        sec_dur = probe(args.second)["duration"] or 0.0
+        overlap_end = min(ref_dur, sec_dur + offset)  # last reference time both files cover
+        head_len = min(args.analyze_seconds, overlap_end)
+        tail_start = overlap_end - args.drift_window
+        if tail_start <= head_len / 2 + 5:
+            info("warning: files too short to measure drift reliably; skipping drift correction")
+        else:
+            ref_start = tail_start
+            sec_start = tail_start - offset
+            if sec_start < 0:
+                ref_start -= sec_start
+                sec_start = 0.0
+            ref_s = decode_mono(args.reference, args.drift_window, ref_start)
+            oth_s = decode_mono(args.second, args.drift_window, sec_start)
+            step = max(1, int(SR * args.step_ms / 1000))
+            lag, end_score = cross_correlate(envelope(ref_s, step), envelope(oth_s, step), int(2.0 * SR / step))
+            residual = lag * step / SR
+            if args.fine_ms:
+                residual = refine(ref_s, oth_s, residual, max(1, int(SR * args.fine_ms / 1000)), args.step_ms / 1000 * 2)
+            # both measurements represent the offset at the centre of their windows
+            head_mid = head_len / 2
+            tail_mid = ref_start + args.drift_window / 2
+            elapsed = tail_mid - head_mid
+            if elapsed > 0 and end_score > 0.1:
+                # offset(T) = offset0 - (ratio - 1) * T, where ratio is how fast the second file's clock
+                # runs relative to the reference (ratio > 1 = the second file is too long / plays slow)
+                drift_ratio = 1.0 - residual / elapsed
+                offset = offset + (drift_ratio - 1.0) * head_mid  # extrapolate back to T = 0
+                drift_info = {"residual_at_end_seconds": round(residual, 4), "measured_over_seconds": round(elapsed, 2),
+                              "drift_ppm": round((drift_ratio - 1) * 1e6, 1),
+                              "meaning": "second file runs %.1f ppm %s (%.3fs over %.0fs); it will be resampled to match" % (
+                                  abs(drift_ratio - 1) * 1e6, "long/slow" if drift_ratio > 1 else "short/fast", abs(residual), elapsed),
+                              "confidence": round(end_score, 3)}
+            else:
+                info("warning: could not measure drift with confidence; skipping drift correction")
 
     result = {
         "reference": args.reference,
@@ -149,6 +221,8 @@ def main() -> int:
         "confidence": round(max(0.0, min(1.0, score)), 3),
         "meaning": ("second starts %.3fs %s than reference" % (abs(offset), "later" if offset > 0 else "earlier")),
     }
+    if drift_info:
+        result["drift"] = drift_info
     if result["confidence"] < 0.1:
         info("warning: low correlation confidence; check that both files contain the same audio event")
 
@@ -160,14 +234,20 @@ def main() -> int:
         head_trim = -offset if offset < 0 else 0.0
         second_meta = probe(args.second)
         has_video = bool(second_meta.get("video"))
+        sec_sr = (second_meta.get("audio") or {}).get("sample_rate") or 48000
+        drift_af: List[str] = []
+        if abs(drift_ratio - 1.0) > 1e-7:
+            # the second file runs long by drift_ratio -> play it faster by that ratio (pitch shift is ~ppm, inaudible)
+            drift_af = [f"asetrate={sec_sr * drift_ratio:.6f}", f"aresample={sec_sr}"]
 
         if args.replace_audio:
             cmd = ffmpeg_base() + ["-i", args.reference]
             if head_trim > 0:
                 cmd += ["-ss", f"{head_trim:.4f}"]
             cmd += ["-i", args.second, "-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy"]
-            if delay_ms > 0:
-                cmd += ["-af", f"adelay={delay_ms}:all=1"]
+            af_parts = drift_af + ([f"adelay={delay_ms}:all=1"] if delay_ms > 0 else [])
+            if af_parts:
+                cmd += ["-af", ",".join(af_parts)]
             cmd += aac_args() + ["-shortest", output]
             proc = run(cmd, check=False)
             if proc.returncode != 0:
@@ -176,26 +256,42 @@ def main() -> int:
                 cmd = cmd[:-1] + x264_args(args.crf) + [output]
                 run(cmd)
         else:
-            if head_trim > 0:
+            if head_trim > 0 and not drift_af:
                 cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second, "-c", "copy", "-avoid_negative_ts", "make_zero", output]
                 proc = run(cmd, check=False)
                 if proc.returncode != 0:
                     cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + (x264_args(args.crf) if has_video else []) + audio_codec_for(output) + [output]
                     run(cmd)
             else:
-                af = f"adelay={delay_ms}:all=1"
-                cmd = ffmpeg_base() + ["-i", args.second]
+                cmd = ffmpeg_base()
+                if head_trim > 0:
+                    cmd += ["-ss", f"{head_trim:.4f}"]
+                cmd += ["-i", args.second]
+                af_parts = list(drift_af)
+                if delay_ms > 0:
+                    af_parts.append(f"adelay={delay_ms}:all=1")
                 if has_video:
-                    cmd += ["-vf", f"tpad=start_duration={offset:.4f}"] + x264_args(args.crf)
-                cmd += ["-af", af] + audio_codec_for(output) + [output]
+                    vf = []
+                    if delay_ms > 0:
+                        vf.append(f"tpad=start_duration={offset:.4f}")
+                    if drift_af:
+                        vf.append(f"setpts=PTS/{drift_ratio:.9f}")
+                    if vf:
+                        cmd += ["-vf", ",".join(vf)]
+                    cmd += x264_args(args.crf)
+                if af_parts:
+                    cmd += ["-af", ",".join(af_parts)]
+                cmd += audio_codec_for(output) + [output]
                 run(cmd)
         result["output"] = output
         info(f"wrote {output}")
 
     if args.json:
-        print(json.dumps(result, indent=2))
+        emit(result.get("output"), **{k: v for k, v in result.items() if k != "output"})
     else:
         print(f"offset: {result['offset_seconds']:+.3f}s ({result['meaning']}), confidence {result['confidence']:.2f}")
+        if drift_info:
+            print(f"drift: {drift_info['drift_ppm']:+.1f} ppm ({drift_info['residual_at_end_seconds']:+.3f}s over {drift_info['measured_over_seconds']:.0f}s), confidence {drift_info['confidence']:.2f}")
         if "output" in result:
             print(result["output"])
     return 0