ffmpeg-skill 0.10.0 → 0.12.5

package/scripts/fit.py

@@ -5,7 +5,13 @@ Duration: --duration N with --method speed (retime video+audio, pitch-preserving
 via atempo chaining) or --method trim (keep the first N seconds, or a centred
 window with --from-center). Aspect: --aspect 16:9|9:16|1:1|4:5|W:H with
 --fit pad (letterbox/pillarbox with --pad-color, default black) or --fit crop.
---width sets the output width; height follows the aspect.
+--width and/or --height set the output size: give one and the other follows
+the aspect (source aspect if --aspect is not also given); give both for an
+exact frame. --rotate 90|180|270 (clockwise) and --flip h|v apply a new
+rotation/mirror to the picture -- distinct from the rotation metadata a
+source already carries (read automatically to compute the displayed size,
+never altered by these flags unless asked). Both can be combined; rotate is
+applied before flip.
 
 Crop keeps the centre of the frame by default, which is a guess: going from
 16:9 to 9:16 throws away most of the width, and whatever isn't in the middle
@@ -20,6 +26,10 @@ Examples:
   python3 fit.py input.mp4 --aspect 9:16 --fit pad --width 1080
   python3 fit.py input.mp4 --aspect 1:1 --fit crop --duration 15
   python3 fit.py input.mp4 --aspect 9:16 --fit crop --crop-x 1   # keep the right edge (e.g. product held stage-right)
+  python3 fit.py input.mp4 --height 1080                         # width follows the source aspect
+  python3 fit.py input.mp4 --width 1920 --height 1080            # exact frame, no aspect needed
+  python3 fit.py input.mp4 --rotate 90                           # rotate 90 degrees clockwise
+  python3 fit.py input.mp4 --flip h                              # mirror horizontally
 """
 import argparse
 import math
@@ -27,7 +37,7 @@ import sys
 from fractions import Fraction
 from typing import List
 
-from _common import video_args, STATE, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, ffmpeg_base, info, parse_time, probe, run, x264_args
+from _common import video_args, STATE, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, ffmpeg_base, info, parse_time, probe, run, run_keeping_subtitles, x264_args
 
 ASPECT_PRESETS = {"16:9": Fraction(16, 9), "9:16": Fraction(9, 16), "1:1": Fraction(1, 1), "4:5": Fraction(4, 5), "4:3": Fraction(4, 3), "21:9": Fraction(21, 9)}
 
@@ -66,6 +76,10 @@ 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>_fit.<ext>)")
+    ap.add_argument("--audio-stream", type=int, default=0,
+                     help="which audio stream of the input to keep, 0-based in file order (probe.py lists them under "
+                          "audio_streams) -- matters on a multi-track input (dubbed languages, M&E stems); default 0, "
+                          "the first track, same as leaving it unset always did")
     d = ap.add_argument_group("duration")
     d.add_argument("--duration", help="target duration (seconds or mm:ss)")
     d.add_argument("--method", choices=["speed", "trim"], default="speed", help="how to reach the duration (default speed)")
@@ -76,10 +90,14 @@ def main() -> int:
     a = ap.add_argument_group("aspect")
     a.add_argument("--aspect", help="target aspect ratio, e.g. 16:9, 9:16, 1:1, 4:5")
     a.add_argument("--fit", choices=["pad", "crop"], default="pad", help="pad (letterbox) or crop to reach the aspect (default pad)")
-    a.add_argument("--width", type=int, help="output width in px (default: keep source width or the width implied by the aspect)")
+    a.add_argument("--width", type=int, help="output width in px (default: keep source width or the width implied by the aspect); with --height also given, both are used directly")
+    a.add_argument("--height", type=int, help="output height in px (default: keep source height or the height implied by the aspect); with --width also given, both are used directly")
     a.add_argument("--pad-color", default="black", help="pad colour, e.g. black, white, 0x101010 (default black)")
     a.add_argument("--crop-x", type=float, default=0.5, help="with --fit crop, horizontal anchor 0=left, 0.5=centre (default), 1=right")
     a.add_argument("--crop-y", type=float, default=0.5, help="with --fit crop, vertical anchor 0=top, 0.5=centre (default), 1=bottom")
+    r = ap.add_argument_group("rotate / flip")
+    r.add_argument("--rotate", type=int, choices=[90, 180, 270], help="rotate the picture clockwise by this many degrees")
+    r.add_argument("--flip", choices=["h", "v"], help="mirror the picture horizontally (h) or vertically (v)")
     e = ap.add_argument_group("encoding")
     e.add_argument("--crf", type=int, default=18)
     e.add_argument("--preset", default="medium")
@@ -88,8 +106,10 @@ def main() -> int:
     args = ap.parse_args()
     apply_common(args)
 
-    if not args.duration and not args.aspect and not args.width and not args.fps:
-        die("nothing to do: give --duration, --aspect, --width and/or --fps")
+    if args.fps is not None and args.fps <= 0:
+        die(f"--fps must be positive, got {args.fps:g}")
+    if not args.duration and not args.aspect and not args.width and not args.height and not args.fps and not args.rotate and not args.flip:
+        die("nothing to do: give --duration, --aspect, --width/--height, --rotate/--flip and/or --fps")
     if not 0.0 <= args.crop_x <= 1.0:
         die(f"--crop-x must be 0..1, got {args.crop_x}")
     if not 0.0 <= args.crop_y <= 1.0:
@@ -98,10 +118,17 @@ def main() -> int:
     meta = probe(args.input)
     if not meta.get("video"):
         die("input has no video stream")
+    audio_streams = meta.get("audio_streams") or []
+    if audio_streams and not (0 <= args.audio_stream < len(audio_streams)):
+        die(f"--audio-stream {args.audio_stream}: input has {len(audio_streams)} audio stream(s), 0..{len(audio_streams) - 1}")
+    if args.audio_stream and not audio_streams:
+        die("--audio-stream needs an input with audio streams")
     src_dur = meta["duration"] or 0.0
     sw, sh = meta["video"]["width"], meta["video"]["height"]
     if meta["video"].get("rotation") in (90, -90, 270, -270):
         sw, sh = sh, sw
+    if args.rotate in (90, 270):
+        sw, sh = sh, sw
     has_audio = bool(meta.get("audio"))
 
     vf: List[str] = []
@@ -110,6 +137,18 @@ def main() -> int:
     post: List[str] = []
     factor = 1.0
 
+    # ---- rotate / flip
+    if args.rotate == 90:
+        vf.append("transpose=1")
+    elif args.rotate == 270:
+        vf.append("transpose=2")
+    elif args.rotate == 180:
+        vf.append("transpose=2,transpose=2")
+    if args.flip == "h":
+        vf.append("hflip")
+    elif args.flip == "v":
+        vf.append("vflip")
+
     # ---- duration
     if args.duration:
         target = parse_time(args.duration)
@@ -142,14 +181,22 @@ def main() -> int:
                 info(f"source ({src_dur:.2f}s) is already shorter than {target:.2f}s; trim does nothing")
 
     # ---- aspect / size
-    if args.aspect or args.width:
-        src_ratio = Fraction(sw, sh)
+    if args.aspect or args.width or args.height:
+        src_ratio = Fraction(sw, sh) if sh else None
         ratio = parse_aspect(args.aspect) if args.aspect else src_ratio
-        if args.width:
+        if args.width and args.height:
+            out_w, out_h = even(args.width), even(args.height)
+        elif args.width:
             out_w = even(args.width)
-        else:
+            out_h = even(out_w / ratio) if ratio else args.width
+        elif args.height:
+            out_h = even(args.height)
+            out_w = even(out_h * ratio) if ratio else args.height
+        elif ratio and src_ratio:
             out_w = even(sw if ratio <= src_ratio else sh * ratio)
-        out_h = even(out_w / ratio)
+            out_h = even(out_w / ratio)
+        else:
+            out_w, out_h = even(sw), even(sh)
         if args.fit == "crop":
             vf.append(f"scale={out_w}:{out_h}:force_original_aspect_ratio=increase")
             vf.append(f"crop={out_w}:{out_h}:(in_w-out_w)*{args.crop_x:g}:(in_h-out_h)*{args.crop_y:g}")
@@ -169,21 +216,33 @@ def main() -> int:
         cmd += ["-vf", ",".join(vf)]
     if af:
         cmd += ["-af", ",".join(af)]
+    cmd += ["-map", "0:v:0"]
+    if has_audio:
+        cmd += ["-map", f"0:a:{args.audio_stream}"]
     cmd += video_args(meta, args.crf, args.preset)
     cmd += cfr_args(meta, args.fps) if not args.fps else []
     if has_audio:
         cmd += aac_args()
     else:
         cmd += ["-an"]
-    cmd += post + [output]
-    run(cmd)
+    cmd += post
+    if abs(factor - 1.0) > 1e-4:
+        # A subtitle/data stream stream-copied by run_keeping_subtitles keeps the source's
+        # original timestamps; --method speed retimes video (setpts) and audio (atempo) but has
+        # no equivalent way to retime a copied subtitle track, so it would desync from the
+        # now-faster/slower picture. Drop them here rather than ship a captions track that lies
+        # about when a line is spoken.
+        run(cmd + [output])
+        dropped_streams = bool(meta.get("subtitle_streams") or meta.get("data_streams"))
+    else:
+        dropped_streams = run_keeping_subtitles(cmd, output)
 
-    result = probe(output)
+    result = probe(output, role="output")
     msg = f"wrote {output} ({result['duration']:.3f}s, {result['video']['width']}x{result['video']['height']})"
     if abs(factor - 1.0) > 1e-4:
         msg += f", speed {factor:.3f}x"
     info(msg)
-    emit(output)
+    emit(output, dropped_non_av_streams=dropped_streams)
     return 0
 
 

package/scripts/graphics.py

@@ -21,7 +21,7 @@ import argparse
 import sys
 from typing import List, Optional
 
-from _common import aac_args, add_common, apply_common, cfr_args, color_hex, default_output, die, emit, escape_drawtext, escape_filter_path, ffmpeg_base, info, load_brand, parse_time, probe, run, video_args
+from _common import aac_args, add_common, apply_common, cfr_args, color_hex, default_font_file, default_output, die, emit, escape_drawtext, escape_filter_path, ffmpeg_base, info, load_brand, parse_time, probe, run, run_keeping_subtitles, video_args
 
 TEMPLATES = ["lower-third", "title", "chapter", "progress", "countdown", "bug"]
 
@@ -33,6 +33,9 @@ def ff_color(hex_rgb: str, alpha: float = 1.0) -> str:
 def font_opts(brand: dict, font: Optional[str], font_file: Optional[str]) -> str:
     if font_file or brand.get("font_file"):
         return f"fontfile={escape_filter_path(font_file or brand['font_file'])}"
+    resolved = default_font_file(font or brand.get("font", "DejaVu Sans"))
+    if resolved:
+        return f"fontfile={escape_filter_path(resolved)}"
     return f"font='{font or brand.get('font', 'DejaVu Sans')}'"
 
 
@@ -40,6 +43,10 @@ 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>_gfx.<ext>)")
+    ap.add_argument("--audio-stream", type=int, default=0,
+                     help="which audio stream of the input to keep, 0-based in file order (probe.py lists them under "
+                          "audio_streams) -- matters on a multi-track input (dubbed languages, M&E stems); default 0, "
+                          "the first track, same as leaving it unset always did")
     ap.add_argument("--template", choices=TEMPLATES, required=True)
     ap.add_argument("--brand", help="brand.json for colours, font, safe margin")
     ap.add_argument("--name", help="lower-third: name line")
@@ -70,6 +77,11 @@ def main() -> int:
     meta = probe(args.input)
     if not meta.get("video"):
         die("input has no video stream")
+    audio_streams = meta.get("audio_streams") or []
+    if audio_streams and not (0 <= args.audio_stream < len(audio_streams)):
+        die(f"--audio-stream {args.audio_stream}: input has {len(audio_streams)} audio stream(s), 0..{len(audio_streams) - 1}")
+    if args.audio_stream and not audio_streams:
+        die("--audio-stream needs an input with audio streams")
     W, H = meta["video"]["width"], meta["video"]["height"]
     if meta["video"].get("rotation") in (90, -90, 270, -270):
         W, H = H, W
@@ -149,16 +161,15 @@ def main() -> int:
     output = args.output or default_output(args.input, "gfx")
     cmd = ffmpeg_base() + ["-i", args.input]
     if fc:
-        cmd += ["-filter_complex", ";".join(fc), "-map", "[vout]", "-map", "0:a:0?"]
+        cmd += ["-filter_complex", ";".join(fc), "-map", "[vout]", "-map", f"0:a:{args.audio_stream}?"]
     else:
-        cmd += ["-vf", ",".join(filters), "-map", "0:v:0", "-map", "0:a:0?"]
+        cmd += ["-vf", ",".join(filters), "-map", "0:v:0", "-map", f"0:a:{args.audio_stream}?"]
     cmd += video_args(meta, args.crf, args.preset) + cfr_args(meta)
     cmd += aac_args() if meta.get("audio") else ["-an"]
-    cmd.append(output)
-    run(cmd)
-    r = probe(output)
+    dropped_streams = run_keeping_subtitles(cmd, output)
+    r = probe(output, role="output")
     info(f"wrote {output} ({r['duration']:.3f}s, {args.template})")
-    emit(output, template=args.template)
+    emit(output, template=args.template, dropped_non_av_streams=dropped_streams)
     return 0
 
 

package/scripts/insert.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Turn a still image into a silent, timed video clip.
+
+Produces a fixed-duration, constant-frame-rate video from one image -- for
+example a title card, an end slate, or a placeholder to slot into join.py
+alongside real footage. The output has no audio track: pair it with audio.py
+or export.py's own audio handling if the surrounding edit needs sound under
+the still.
+
+--width/--height set the output frame size the same way fit.py does: give
+one and the other follows the image's own aspect; give both for an exact
+frame (the image is scaled to fill it, centre-cropping any excess -- never
+distorted). Omit both to keep the image's native size (evened for 4:2:0).
+
+--zoom in|out applies a Ken Burns effect: a slow, linear zoom across the
+clip's duration (--zoom-amount sets the end/start zoom factor, default 1.3 =
+30% zoomed in by the end). --pan left|right|up|down drifts the visible
+window across the image while zoomed (ignored, with a warning, if --zoom is
+not also given -- panning needs the extra image area a zoom exposes).
+
+Examples:
+  python3 insert.py title.png --duration 3
+  python3 insert.py slate.jpg --duration 5 --width 1920 --height 1080 --fps 30 -o slate.mp4
+  python3 insert.py photo.jpg --duration 6 --zoom in --pan right --width 1920 --height 1080
+"""
+import argparse
+import math
+import sys
+
+from _common import add_common, apply_common, default_output, die, emit, ffmpeg_base, info, parse_time, probe, run, video_args
+
+
+def even(n: float) -> int:
+    v = int(round(n))
+    return v if v % 2 == 0 else v + 1
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("input", help="still image (PNG/JPG/...)")
+    ap.add_argument("-o", "--output", help="output file (default: <name>_insert.mp4)")
+    ap.add_argument("--duration", required=True, help="clip duration (seconds or mm:ss)")
+    ap.add_argument("--width", type=int, help="output width in px; with --height also given, both are used directly")
+    ap.add_argument("--height", type=int, help="output height in px; with --width also given, both are used directly")
+    ap.add_argument("--fps", type=float, default=30.0, help="output frame rate (default 30)")
+    ap.add_argument("--zoom", choices=["in", "out"], help="Ken Burns: slow linear zoom in or out across the clip")
+    ap.add_argument("--zoom-amount", type=float, default=1.3, help="end (zoom in) or start (zoom out) zoom factor, > 1.0 (default 1.3)")
+    ap.add_argument("--pan", choices=["left", "right", "up", "down"], help="drift the visible window this direction while zoomed (needs --zoom)")
+    ap.add_argument("--crf", type=int, default=18, help="x264 CRF (default 18)")
+    ap.add_argument("--preset", default="medium", help="x264 preset")
+    add_common(ap)
+    args = ap.parse_args()
+    apply_common(args)
+
+    target = parse_time(args.duration)
+    if target <= 0:
+        die("--duration must be > 0")
+    if args.fps <= 0:
+        die("--fps must be > 0")
+    if args.zoom_amount <= 1.0:
+        die(f"--zoom-amount must be > 1.0, got {args.zoom_amount}")
+    if args.pan and not args.zoom:
+        die("--pan needs --zoom in|out")
+
+    meta = probe(args.input)
+    if not meta.get("video"):
+        die("input has no image/video stream")
+    sw, sh = meta["video"]["width"], meta["video"]["height"]
+    ratio = sw / sh
+
+    if args.width and args.height:
+        out_w, out_h = even(args.width), even(args.height)
+    elif args.width:
+        out_w = even(args.width)
+        out_h = even(out_w / ratio)
+    elif args.height:
+        out_h = even(args.height)
+        out_w = even(out_h * ratio)
+    else:
+        out_w, out_h = even(sw), even(sh)
+
+    if args.zoom:
+        frames = max(1, round(target * args.fps))
+        amount = args.zoom_amount
+        if args.zoom == "in":
+            zexpr = f"if(eq(on,0),1,min(zoom+{(amount - 1) / frames:.8f},{amount:g}))"
+        else:
+            zexpr = f"if(eq(on,0),{amount:g},max(zoom-{(amount - 1) / frames:.8f},1))"
+        pan_x = {
+            "left": f"(iw-iw/zoom)*(1-on/{frames})",
+            "right": f"(iw-iw/zoom)*on/{frames}",
+        }.get(args.pan, "iw/2-(iw/zoom/2)")
+        pan_y = {
+            "up": f"(ih-ih/zoom)*(1-on/{frames})",
+            "down": f"(ih-ih/zoom)*on/{frames}",
+        }.get(args.pan, "ih/2-(ih/zoom/2)")
+        # zoompan samples from the still at its native resolution; scale it up first so the
+        # zoomed-in crop still has real pixels to draw from instead of upscaling blur.
+        upscale = max(2, math.ceil(amount * 2))
+        vf = [
+            f"scale={out_w * upscale}:{out_h * upscale}:force_original_aspect_ratio=increase",
+            f"crop={out_w * upscale}:{out_h * upscale}",
+            f"zoompan=z='{zexpr}':x='{pan_x}':y='{pan_y}':d={frames}:s={out_w}x{out_h}:fps={args.fps:g}",
+            "setsar=1",
+        ]
+    else:
+        vf = [
+            f"scale={out_w}:{out_h}:force_original_aspect_ratio=increase",
+            f"crop={out_w}:{out_h}",
+            "setsar=1",
+            f"fps={args.fps:g}",
+        ]
+
+    output = args.output or default_output(args.input, "insert", "mp4")
+    cmd = ffmpeg_base() + ["-loop", "1", "-i", args.input, "-t", f"{target:.3f}", "-vf", ",".join(vf)]
+    cmd += video_args(None, args.crf, args.preset)
+    cmd += ["-an", output]
+    run(cmd)
+
+    result = probe(output, role="output")
+    v = result["video"]
+    info(f"wrote {output} ({result['duration']:.3f}s, {v['width']}x{v['height']}, {v['fps']:g}fps)")
+    emit(output)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/join.py

@@ -121,9 +121,11 @@ def main() -> int:
     if args.width and args.height:
         w, h = args.width, args.height
     elif args.width:
-        w, h = args.width, int(round(args.width * fh / fw))
+        w = args.width
+        h = int(round(args.width * fh / fw)) if fw else args.width
     elif args.height:
-        w, h = int(round(args.height * fw / fh)), args.height
+        h = args.height
+        w = int(round(args.height * fw / fh)) if fh else args.height
     else:
         w, h = fw, fh
     fps = args.fps or first.get("fps") or 30.0
@@ -141,15 +143,22 @@ def main() -> int:
     n = len(args.inputs)
     for i, (p, m) in enumerate(zip(args.inputs, metas)):
         cmd += ["-i", p]
-    # silent audio for clips without an audio track
+    # silent audio for clips without an audio track. `idx` is this ffmpeg input's position, i.e. n +
+    # how many synthetic inputs were already added -- not len(extra_inputs), which counts the six
+    # argv tokens ("-f", "lavfi", "-t", duration, "-i", "anullsrc=...") each synthetic input adds, not
+    # the input itself. With one no-audio clip both counts coincide (n + 0); from the second no-audio
+    # clip onward they diverge, and the previous `n + len(extra_inputs)` named a nonexistent, far-out-of-
+    # range ffmpeg input index -- found via a real multi-camera join where every clip lacked audio.
     audio_src: List[str] = []
+    added = 0
     for i, m in enumerate(metas):
         if m.get("audio"):
             audio_src.append(f"{i}:a:0")
         else:
-            idx = n + len(extra_inputs)
+            idx = n + added
             extra_inputs += ["-f", "lavfi", "-t", f"{durs[i]:.3f}", "-i", "anullsrc=r=48000:cl=stereo"]
             audio_src.append(f"{idx}:a:0")
+            added += 1
     cmd += extra_inputs
 
     if args.fit == "crop":
@@ -180,7 +189,7 @@ def main() -> int:
     cmd += video_args(metas[0], args.crf, args.preset) + aac_args() + [output]
     run(cmd)
     expected = sum(durs) - d * (n - 1)
-    r = probe(output)
+    r = probe(output, role="output")
     info(f"wrote {output} ({r['duration']:.3f}s, expected ~{expected:.3f}s, {w}x{h} @ {fps:g}fps, {n} clips, {args.transition})")
     emit(output, mode="video", clips=n, transition=args.transition, expected_duration=round(expected, 3))
     return 0

package/scripts/look.py

@@ -15,7 +15,7 @@ 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
+from _common import add_common, apply_common, default_font_file, die, emit, escape_drawtext, escape_filter_path, 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"
 
@@ -26,8 +26,8 @@ def fmt_hms(sec: float) -> str:
     return f"{int(h):02d}:{int(m):02d}:{s_:06.3f}"
 
 
-def timecode_filter() -> str:
-    return f"drawtext=text='%{{pts\\:hms}}':{FONT}"
+def timecode_filter(font_prefix: str) -> str:
+    return f"drawtext=text='%{{pts\\:hms}}':{font_prefix}{FONT}"
 
 
 def main() -> int:
@@ -49,7 +49,12 @@ def main() -> int:
     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()
+    # a resolvable font file, given as fontfile=, is the only form confirmed not to crash drawtext's
+    # own fontconfig resolution on some real Windows ffmpeg builds (#100); font= is the fallback when
+    # nothing can be resolved, unchanged from before this existed.
+    default_font = default_font_file("DejaVu Sans")
+    font_prefix = f"fontfile={escape_filter_path(default_font)}:" if default_font else ""
+    tc = "" if args.no_timecode else "," + timecode_filter(font_prefix)
     # HDR sources: tone-map for the PNG so the agent judges representative colours, not raw HLG/PQ
     if meta["video"].get("hdr"):
         v = meta["video"]
@@ -67,8 +72,8 @@ def main() -> int:
             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
-            stamp = "" if args.no_timecode else f",drawtext=text='{escape_drawtext(fmt_hms(sec))}':{FONT}"
-            tcs = tc.replace("," + timecode_filter(), "") + stamp
+            stamp = "" if args.no_timecode else f",drawtext=text='{escape_drawtext(fmt_hms(sec))}':{font_prefix}{FONT}"
+            tcs = tc.replace("," + timecode_filter(font_prefix), "") + stamp
             fc = (f"[0:v]scale={half}:-2{tcs}[a];[1:v]scale={half}:-2{tcs}[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,
@@ -81,8 +86,8 @@ def main() -> int:
             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")
-            stamp = "" if args.no_timecode else f",drawtext=text='{escape_drawtext(fmt_hms(sec))}':{FONT}"
-            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", "-i", args.input, "-vf", f"scale={args.width}:-2{tc.replace(',' + timecode_filter(), '')}{stamp}", "-frames:v", "1", out]
+            stamp = "" if args.no_timecode else f",drawtext=text='{escape_drawtext(fmt_hms(sec))}':{font_prefix}{FONT}"
+            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", "-i", args.input, "-vf", f"scale={args.width}:-2{tc.replace(',' + timecode_filter(font_prefix), '')}{stamp}", "-frames:v", "1", out]
             run(cmd)
             outputs.append(out)
     else:

package/scripts/loudness.py

@@ -24,13 +24,13 @@ from _common import STATE, add_common, apply_common, emit, AUDIO_CODECS, audio_c
 
 def measure(path: str, I: float, tp: float, lra: float) -> dict:
     if STATE["dry_run"]:
-        return {"input_i": "-20.0", "input_tp": "-3.0", "input_lra": "8.0", "input_thresh": "-30.0", "target_offset": "0.0"}
+        return {"input_i": "-20.0", "input_tp": "-3.0", "input_lra": "8.0", "input_thresh": "-30.0", "target_offset": "0.0", "silent": False}
     ffmpeg = require_tool("ffmpeg")
     cmd = [ffmpeg, "-hide_banner", "-nostdin", "-i", path, "-vn", "-af", f"loudnorm=I={I}:TP={tp}:LRA={lra}:print_format=json", "-f", "null", "-"]
     proc = run(cmd, check=False)
     m = re.search(r"\{[^{}]*\"input_i\"[^{}]*\}", proc.stderr, re.S)
     if proc.returncode != 0 or not m:
-        die(f"loudness measurement failed:\n{proc.stderr.strip()[-1500:]}")
+        die(f"loudness measurement failed:\n{proc.stderr.strip()[-1500:]}", kind="ffmpeg")
     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"):
@@ -89,7 +89,7 @@ def main() -> int:
     after = measure(output, args.lufs, args.tp, args.lra)
     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)
+    emit(output, result={k: after[k] for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset", "silent")})
     return 0
 
 

package/scripts/multicam.py

@@ -197,7 +197,7 @@ def main() -> int:
     cmd += ["-filter_complex", ";".join(parts), "-map", "[vout]", "-map", "[aout]"]
     cmd += video_args(metas[0], args.crf, args.preset) + aac_args() + ["-shortest", output]
     run(cmd)
-    r = probe(output)
+    r = probe(output, role="output")
     info(f"wrote {output} ({r['duration']:.3f}s, {len(filled)} cuts, audio from input {a})")
     emit(output, cuts=[[round(s, 3), round(e, 3), c] for s, e, c in filled], **report)
     return 0