ffmpeg-skill 3.6.5 → 3.6.7

package/scripts/export.py

@@ -44,16 +44,17 @@ import os
 import sys
 import tempfile
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from _common.runner import child_exit_code, fail_if_classified, kept_clause, mark_delivered
 from _common import STATE, run_analysis, add_common, apply_common, bt709_label_filter, bt709_matrix_args, bt709_tag_args, child_args, emit, cfr_args, default_output, die, encoder_args, ffmpeg_base, info, probe, require_tool, run, run_tool, validate_color, pad_filters, add_pad_fill_args, fmt_secs
 from _common.decision import hw_preset_video, restate_last_swap
 from _common.emit import note, record_fallback, record_skip, warn
-from _common.probe import square_pixels, square_pixels_note
+from _common.probe import PROBED_AUDIO, PROBED_VIDEO, probed_maps, square_pixels, square_pixels_note
 from _common.runner import ffmpeg_encoders, guard_sidecar, remember_written, replace_checked, replace_checked_together, reserve_sibling, run_analysis as _run_analysis, subtitle_codec_for
 from _common.emit import file_identity
 from check import SPECS as PLATFORMS, measure_loudness
+from _common.probe import SILENT_PEAK_DBFS, shorter_than_a_loudness_block
 from _platforms import ALIASES as _ALIASES, PLATFORMS as PLATFORM_TABLE, TP_TOLERANCE_DB, resolve as resolve_platform
 # Frame and duration limit come from the one platform table (scripts/_platforms.py) rather than
 # from a literal restated here: before 1.14 they were typed twice and the facebook preset had
@@ -204,8 +205,8 @@ def _key_fill(args, p: Dict, meta: Dict, output: str, cmd: List[str], vf: List[s
     key_chain = ",".join(vf + ["alphaextract", "format=yuv422p10le"])
     tc = ((meta.get("timecode") or {}).get("value"))
     tc_args = ["-timecode", tc] if tc else []
-    cmd = cmd + ["-filter_complex", f"[0:v:0]split[f][k];[f]{fill_chain}[fill];[k]{key_chain}[key]"]
-    cmd += ["-map", "[fill]"] + (["-map", "0:a:0"] if has_audio else []) + p["video"] + tc_args + cfr_args(meta)
+    cmd = cmd + ["-filter_complex", f"[0:{PROBED_VIDEO}]split[f][k];[f]{fill_chain}[fill];[k]{key_chain}[key]"]
+    cmd += ["-map", "[fill]"] + probed_maps(meta, video=False, audio=has_audio) + p["video"] + tc_args + cfr_args(meta)
     # the fill is always written to a hidden sibling and moved into place only after the encode
     # succeeds: run() stages and cleans up only ffmpeg's last output (the key), so a failed encode
     # left a partial new fill (the retry was refused as output_exists) or truncated an existing one
@@ -288,17 +289,22 @@ def _luma_stats(path: str) -> "Dict[str, float] | None":
     return _frame_means([require_tool("ffmpeg"), "-hide_banner", "-loglevel", "error", "-nostdin"], path, "format=gray")
 
 
-def _loudness_unmeasured(extra: Dict[str, object], notes: List[str], platform: str, spec: Dict, normalized: bool = False) -> None:
-    """The written file's loudness could not be read (ffmpeg's loudnorm JSON did not parse): the
+def _loudness_unmeasured(extra: Dict[str, object], notes: List[str], platform: str, spec: Dict, normalized: bool = False,
+                         tp: Optional[float] = None) -> None:
+    """The written file's loudness could not be read (ffmpeg's loudnorm JSON did not parse, or,
+    with `tp`, the audio is shorter than one 400 ms gating block and has only a true peak): the
     platform's loudness was not verified, and the document says so -- a `loudness` block with null
     values and a reason, a failing `loudness` verification step, a warning -- rather than leaving
     the block out, which read as "nothing to check". check.py reports the same case as a WARN row."""
     reason = "not_measured"
-    extra["loudness"] = {"lufs": None, "tp": None, "target_lufs": spec["lufs"], "target_tp": spec["tp"], "ok": None,
-                         "measured": False, "reason": reason, **({"normalized": True} if normalized else {})}
+    extra["loudness"] = {"lufs": None, "tp": tp, "target_lufs": spec["lufs"], "target_tp": spec["tp"], "ok": None,
+                         "measured": False, "reason": reason, **({"too_short": True} if tp is not None else {}),
+                         **({"normalized": True} if normalized else {})}
     extra["verification"] = [{"step": "loudness", "ok": False, "platform": platform, "reason": reason}]
+    why = ("the audio is shorter than one 400 ms loudness block, so it has a true peak but no integrated loudness"
+           if tp is not None else "ffmpeg's loudnorm output did not parse")
     msg = (f"the written file's loudness could not be measured{' after --normalize' if normalized else ''} "
-           f"(ffmpeg's loudnorm output did not parse), so {platform}'s {spec['lufs']:g} LUFS / {spec['tp']:g} dBTP was not "
+           f"({why}), so {platform}'s {spec['lufs']:g} LUFS / {spec['tp']:g} dBTP was not "
            "verified; run check.py on the file")
     notes.append(msg)
     warn(msg, "loudness_not_measured", platform=platform, normalized=normalized)
@@ -410,7 +416,9 @@ def media_damage(path: str) -> Dict[str, int]:
     PTS) and every other error line, counted. What --repair is measured by, before and after."""
     # repeat+: every occurrence on its own line, not "Last message repeated N times", which hid
     # N timestamp warnings and was itself counted as a decode error
-    proc = run_analysis([require_tool("ffmpeg"), "-hide_banner", "-nostdin", "-v", "repeat+warning", "-i", path, "-f", "null", "-"],
+    # the streams a copy export writes (probed_maps), not the ones default selection would decode
+    proc = run_analysis([require_tool("ffmpeg"), "-hide_banner", "-nostdin", "-v", "repeat+warning", "-i", path,
+                         "-map", f"0:{PROBED_VIDEO}?", "-map", f"0:{PROBED_AUDIO}?", "-f", "null", "-"],
                         check=False, record=True)
     lines = [ln for ln in (proc.stderr or "").splitlines() if ln.strip()]
     # "Packet corrupt (stream = 0, dts = ...)" names a dts but is damage, not a timestamp problem
@@ -585,16 +593,19 @@ def main() -> int:
     # Subtitle and data streams (a soft-subtitle track muxed upstream, a camera's timecode) are
     # kept where the container can hold them: ffmpeg's default stream selection takes one video
     # and one audio stream only, and through 2.22.1 every preset dropped the rest without a word.
-    # Mapping them means mapping the picture and the sound too, the same streams probe() describes.
+    # The picture and the sound are mapped on every export, the same streams probe() describes:
+    # until A118 they were mapped only beside a subtitle or data stream, and without one ffmpeg's
+    # default selection took the larger picture and the track with the default disposition or the
+    # most channels, so which audio track an export kept depended on whether it had subtitles.
     subs = meta.get("subtitle_stream_details") or []
     data = _data_streams(args.input) if meta.get("data_streams") else []
     sub_codecs = [_subtitle_codec(s.get("codec") or "", out_ext) for s in subs]
-    if args.preset != "gif" and not p.get("keyfill") and (subs or data):
-        cmd += ["-map", "0:V:0"] + (["-map", "0:a:0"] if has_audio else [])
+    if args.preset != "gif" and not p.get("keyfill"):
+        cmd += probed_maps(meta, audio=has_audio)
 
     if args.preset == "gif":
         chain = ",".join(([gif_label] if gif_label else []) + ["fps=12"] + vf)
-        fc = f"[0:v]{chain},split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle"
+        fc = f"[0:{PROBED_VIDEO}]{chain},split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle"
         cmd += ["-filter_complex", fc, "-loop", "0", output]
         run(cmd)
         info(f"wrote {output}")
@@ -717,7 +728,14 @@ def main() -> int:
         # written file here so the result names the gap and the caller plans one pass, not two.
         spec = PLATFORMS[platform]
         m = measure_loudness(output)
-        if not m:
+        written_audio = probe(output, role="output").get("audio") or {}
+        if (m and not math.isfinite(m["lufs"]) and math.isfinite(m["tp"]) and m["tp"] > SILENT_PEAK_DBFS
+                and shorter_than_a_loudness_block(written_audio.get("duration") or written_audio.get("tagged_duration"))):
+            # A257: too short for a gating block is not silent (it has a measured peak); a longer
+            # track under the gate is not "too short" and takes the path it took before
+            _loudness_unmeasured(extra, notes, platform, spec, tp=m["tp"])
+            m = {}
+        elif not m:
             _loudness_unmeasured(extra, notes, platform, spec)
         if m:
             ok = abs(m["lufs"] - spec["lufs"]) <= spec["lufs_tol"] and m["tp"] <= spec["tp"] + TP_TOLERANCE_DB

package/scripts/graphics.py

@@ -202,6 +202,12 @@ def main(force_route: Optional[str] = None) -> int:
     fps = meta["video"].get("fps")
     s = time_arg(args.start, "--start", fps) if args.start else 0.0
     e = time_arg(args.end, "--end", fps) if args.end else dur
+    # the picture's own length first: sound that runs on keeps the container open past the last frame
+    picture_len = meta["video"].get("duration") or dur
+    if picture_len and s >= picture_len:
+        # A172: a graphic that starts after the picture ends draws nothing (verified: true before)
+        die(f"--start {s:g} is at or after the end of the video ({picture_len:.3f} s): nothing would be drawn",
+            hint="give a --start inside the clip")
     if e <= s:
         die("--end must be after --start")
     en = f"enable='between(t,{s:.3f},{e:.3f})'"

package/scripts/look.py

@@ -24,7 +24,7 @@ from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
 from _common.color import bt709_label_filter, bt2020_sdr_to_bt709_chain, hdr_to_sdr_chain, is_bt2020_sdr  # noqa: E402
-from _common.probe import display_size, square_pixels, square_pixels_note  # noqa: E402
+from _common.probe import PROBED_VIDEO, display_size, square_pixels, square_pixels_note  # noqa: E402
 
 # --guides: broadcast safe areas as outlines, in fractions of the frame (a tile as much as a frame).
 # Action and title safe are SMPTE ST 2046-1's 93 % and 90 % of a 16:9 picture; the 4:3 centre cut
@@ -337,7 +337,7 @@ def main() -> int:
                 conv = "," + conv if conv else ""
                 return (f"scale={half}:{box_h}:force_original_aspect_ratio=decrease{conv}{pre},"
                         f"pad={half}:{box_h}:(ow-iw)/2:(oh-ih)/2:color=0x202020,setsar=1{stamp}")
-            fc = (f"[0:v]{lab}{sq}{fit(tm)}[a];[1:v]{lab2}{csq}{fit(tm2)}[b];"
+            fc = (f"[0:{PROBED_VIDEO}]{lab}{sq}{fit(tm)}[a];[1:{PROBED_VIDEO}]{lab2}{csq}{fit(tm2)}[b];"
                   f"[a][b]hstack=inputs=2[out]")
             cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", *still_input_args(args.input), "-i", args.input, "-ss", f"{sec:.3f}", *still_input_args(args.compare), "-i", args.compare,
                                    "-filter_complex", fc, "-map", "[out]", "-frames:v", "1", "-update", "1", out]
@@ -354,7 +354,7 @@ def main() -> int:
                 # several frames, or -o given as a stem/prefix without an image extension
                 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_prefix}{FONT}"
-            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", *still_input_args(args.input), "-i", args.input, "-vf", f"{lab}{sq}scale={args.width}:-2{tc.replace(',' + timecode_filter(font_prefix), '')}{stamp}", "-frames:v", "1", "-update", "1", out]
+            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", *still_input_args(args.input), "-i", args.input, "-map", f"0:{PROBED_VIDEO}", "-vf", f"{lab}{sq}scale={args.width}:-2{tc.replace(',' + timecode_filter(font_prefix), '')}{stamp}", "-frames:v", "1", "-update", "1", out]
             run(cmd)
             outputs.append(out)
     else:
@@ -384,7 +384,7 @@ def main() -> int:
         tc_sheet = tc
         vf = (f"select='isnan(prev_selected_t)+gte(t-prev_selected_t\\,{step * 0.98:.6f})',{lab}{sq}scale={tile_w}:-2{tc_sheet},"
               f"tile={cols}x{rows}:padding=2:margin=2:color=0x202020")
-        cmd = ffmpeg_base() + ["-copyts", "-start_at_zero", "-ss", f"{seek:.6f}", *still_input_args(args.input), "-i", args.input, "-vf", vf, "-frames:v", "1", "-update", "1", out]
+        cmd = ffmpeg_base() + ["-copyts", "-start_at_zero", "-ss", f"{seek:.6f}", *still_input_args(args.input), "-i", args.input, "-map", f"0:{PROBED_VIDEO}", "-vf", vf, "-frames:v", "1", "-update", "1", out]
         run(cmd)
         outputs.append(out)
         info(f"contact sheet: {n} frames every {step:.2f}s")

package/scripts/loudness.py

@@ -23,6 +23,8 @@ from _platforms import TP_TOLERANCE_DB
 
 AUDIO_LENGTH_TOLERANCE = 0.03  # seconds: one AAC frame at 48 kHz is 0.021 s
 LUFS_TOLERANCE = 1.0  # LU: a normalised file within this of the requested -I is on target
+from _common.probe import PROBED_AUDIO, probed_maps, shorter_than_a_loudness_block
+from _common.emit import refuse
 from _common import STATE, add_common, apply_common, emit, AUDIO_CODECS, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, run_keeping_subtitles, dry_run_input_pending
 
 
@@ -65,7 +67,11 @@ def measure(path: str, I: float, tp: float, lra: float) -> dict:
     if dry_run_input_pending(path):
         return {"input_i": "-20.0", "input_tp": "-3.0", "input_lra": "8.0", "input_thresh": "-30.0", "target_offset": "0.0", "silent": False, "placeholder": True}
     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", "-"]
+    # the first audio track, the one pass 2 normalises and probe() describes: without a -map,
+    # FFmpeg measured the track with the default disposition or the most channels, and the gain
+    # for that track was applied to a:0 (A110)
+    cmd = [ffmpeg, "-hide_banner", "-nostdin", "-i", path, "-map", f"0:{PROBED_AUDIO}", "-vn",
+           "-af", f"loudnorm=I={I}:TP={tp}:LRA={lra}:print_format=json", "-f", "null", "-"]
     # Pass 1 is a measurement: it runs under --dry-run too, so the planned pass-2 command and
     # the reported input_i are real (before 1.4.6 a dry run returned a made-up -20 LUFS).
     proc = run_analysis(cmd, check=False, record=True)
@@ -73,14 +79,37 @@ def measure(path: str, I: float, tp: float, lra: float) -> dict:
     if proc.returncode != 0 or not m:
         die(f"loudness measurement failed:\n{proc.stderr.strip()[-1500:]}", kind="ffmpeg")
     data = json.loads(m.group(0))
+    data["too_short"] = False
     for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset"):
         if data.get(k) in (None, "-inf", "inf", "nan"):
-            data["silent"] = True
+            # A257: a clip shorter than one 400 ms gating block has no integrated loudness but a
+            # true peak; that is not silence, and telling the caller to replace the audio was wrong.
+            # The length decides it, not the peak: a long track under the absolute gate has a
+            # finite peak and no integrated loudness as well, and stays "silent" as before.
+            data["too_short"] = (data.get("input_tp") not in (None, "-inf", "inf", "nan")
+                                 and shorter_than_a_loudness_block(audio_length(probe(path))))
+            data["silent"] = not data["too_short"]
             return data
     data["silent"] = False
     return data
 
 
+def loudnorm_mode(stats: dict, lufs: float, tp: float, lra: float) -> str:
+    """The mode loudnorm runs pass 2 in, by its own rule (af_loudnorm.c init): linear only when the
+    measured values are all usable and the linear gain keeps the true peak under the ceiling and
+    the range within --lra; otherwise it falls back to dynamic, which compresses the range and can
+    land away from the target on its own (A111). The values are the strings pass 1 printed, which
+    are the ones pass 2 is given, so the comparison is ffmpeg's own. Checked against loudnorm's
+    print_format=json normalization_type by test_loudnorm_mode_matches_what_ffmpeg_reports."""
+    try:
+        mi, mtp, mlra, mth = (float(stats[k]) for k in ("input_i", "input_tp", "input_lra", "input_thresh"))
+    except (KeyError, TypeError, ValueError):
+        return "dynamic"
+    if mtp == 99 or mth == -70 or mlra == 0 or mi == 0:
+        return "dynamic"
+    return "linear" if mtp + (lufs - mi) <= tp and mlra <= lra else "dynamic"
+
+
 def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output: str) -> dict:
     """One normalised file at `lufs` / `tp_max`, measured after: the keys emit() takes for it."""
     af = (
@@ -112,9 +141,9 @@ def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output
             af += f",atrim=duration={float(in_audio):.6f}"
         cmd = ffmpeg_base() + ["-i", args.input, "-af", af, "-ar", str(sr)]
         if ext in AUDIO_CODECS or not meta.get("video"):
-            cmd += ["-vn"] + audio_codec_for(output, bitrate)
+            cmd += ["-map", f"0:{PROBED_AUDIO}", "-vn"] + audio_codec_for(output, bitrate)
         else:
-            cmd += ["-map", "0:v:0", "-map", "0:a:0", "-c:v", "copy", "-c:a", "aac", "-b:a", bitrate]
+            cmd += probed_maps(meta) + ["-c:v", "copy", "-c:a", "aac", "-b:a", bitrate]
             if ext in (".mp4", ".mov", ".m4v"):
                 cmd += ["-movflags", "+faststart"]
             dropped_streams = run_keeping_subtitles(cmd, output)
@@ -125,7 +154,8 @@ def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output
     encode(tp_max, bitrate)
     if STATE.dry_run:
         # pass 1 measured the input for real; there is no output to measure
-        return {"output": output, "measured": {k: stats[k] for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset", "silent")}}
+        return {"output": output, "measured": {k: stats[k] for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset", "silent")},
+                "loudnorm_mode": loudnorm_mode(stats, lufs, tp_max, args.lra)}
     after = measure(output, lufs, tp_max, args.lra)
     # loudnorm holds the ceiling on the float samples it outputs; the lossy encoder then adds
     # its own overshoot. ffmpeg's native AAC at 192k turned one transient of a 12-minute film
@@ -157,22 +187,43 @@ def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output
     if ext not in AUDIO_CODECS or "aac" in AUDIO_CODECS[ext]:
         result["audio_bitrate_used"] = bitrate
     result["encodes"] = rounds + 1
-    if not after.get("silent") and abs(float(after["input_i"]) - lufs) > LUFS_TOLERANCE:
-        result["note"] = (f"integrated loudness is {float(after['input_i']) - lufs:+.1f} LU from the target because the "
-                          f"true-peak ceiling had to absorb the encoder's overshoot; a lossless delivery (wav/flac) or a pinned "
-                          f"higher --audio-bitrate keeps both")
+    # the mode of the last encode: its ceiling is the one the file was made with
+    result["loudnorm_mode"] = loudnorm_mode(stats, lufs, ceiling, args.lra)
+    if not after.get("silent") and not after.get("too_short") and abs(float(after["input_i"]) - lufs) > LUFS_TOLERANCE:
+        if result["loudnorm_mode"] == "dynamic":
+            # A111: the miss is loudnorm's dynamic mode, not an encoder overshoot (it happens on a
+            # lossless output too): a linear gain to the target would have put the true peak over
+            # the ceiling, or the range is wider than --lra
+            result["note"] = (f"integrated loudness is {float(after['input_i']) - lufs:+.1f} LU from the target because "
+                              f"loudnorm could not apply one linear gain (the input's true peak {float(stats['input_tp']):.1f} dBTP "
+                              f"plus the gain would pass the {ceiling:.2f} dBTP ceiling, or its range "
+                              f"{float(stats['input_lra']):.1f} LU is outside 0 < LRA <= --lra {args.lra:g}) and fell back to "
+                              f"dynamic mode, which compresses the range; a lower -I, a higher --tp or a wider --lra keeps it linear")
+        else:
+            result["note"] = (f"integrated loudness is {float(after['input_i']) - lufs:+.1f} LU from the target because the "
+                              f"true-peak ceiling had to absorb the encoder's overshoot; a lossless delivery (wav/flac) or a pinned "
+                              f"higher --audio-bitrate keeps both")
     if not after.get("silent") and float(after["input_tp"]) > tp_max + TP_TOLERANCE_DB:
         die(f"true peak is still {float(after['input_tp']):.2f} dBTP after {rounds + 1} encodes (requested <= {tp_max:g}); "
             f"the encoder overshoots more than the loudnorm ceiling can absorb at this bitrate",
             kind="verification", output=output, result=result,
             hint="raise --audio-bitrate (e.g. 256k) or deliver a lossless format (wav/flac) and let the platform encode")
-    verification = [{"step": "loudness",
-                     "ok": bool(after.get("silent")) or (abs(float(after["input_i"]) - lufs) <= LUFS_TOLERANCE and float(after["input_tp"]) <= tp_max + TP_TOLERANCE_DB),
-                     "lufs": float(after["input_i"]), "tp": float(after["input_tp"]), "target_lufs": lufs, "target_tp": tp_max,
-                     "property": "loudness", "expected": {"lufs": lufs, "tp_max": tp_max},
-                     "measured": {"lufs": float(after["input_i"]), "tp": float(after["input_tp"])},
-                     "delta": {"lufs": round(float(after["input_i"]) - lufs, 2), "tp": round(float(after["input_tp"]) - tp_max, 2)},
-                     "tolerance": {"lufs": LUFS_TOLERANCE, "tp": TP_TOLERANCE_DB}, "provenance": "user_specified"}]
+    if after.get("silent") or after.get("too_short"):
+        # an output with no integrated loudness was not measured against the target: through
+        # 3.6 a silent one passed this step (ok: true) with -inf in its numbers
+        verification = [{"step": "loudness", "ok": False, "target_lufs": lufs, "target_tp": tp_max,
+                         "property": "loudness", "expected": {"lufs": lufs, "tp_max": tp_max},
+                         "reason": "not_measured: the output has no integrated loudness ("
+                                   + ("silent" if after.get("silent") else "shorter than one 400 ms block") + ")",
+                         "provenance": "user_specified"}]
+    else:
+        verification = [{"step": "loudness",
+                         "ok": abs(float(after["input_i"]) - lufs) <= LUFS_TOLERANCE and float(after["input_tp"]) <= tp_max + TP_TOLERANCE_DB,
+                         "lufs": float(after["input_i"]), "tp": float(after["input_tp"]), "target_lufs": lufs, "target_tp": tp_max,
+                         "property": "loudness", "expected": {"lufs": lufs, "tp_max": tp_max},
+                         "measured": {"lufs": float(after["input_i"]), "tp": float(after["input_tp"])},
+                         "delta": {"lufs": round(float(after["input_i"]) - lufs, 2), "tp": round(float(after["input_tp"]) - tp_max, 2)},
+                         "tolerance": {"lufs": LUFS_TOLERANCE, "tp": TP_TOLERANCE_DB}, "provenance": "user_specified"}]
     written = probe(output, role="output")
     out_audio = audio_length(written)
     if in_audio and out_audio:
@@ -199,6 +250,10 @@ def _versions(args, meta: dict, plan: list) -> int:
     for label, lufs, tp in plan:
         out = default_output(args.input, f"loudnorm_{label}")
         stats = measure(args.input, lufs, tp, args.lra)
+        if stats.get("too_short"):
+            refuse("input", "audio_too_short",
+               f"input audio peaks at {stats.get('input_tp')} dBTP but is shorter than one 400 ms loudness block, so it has "
+               "no integrated loudness to normalise from (this is not silence)", input_tp=stats.get("input_tp"))
         if stats.get("silent"):
             die("input audio is silent; loudness normalisation is meaningless (use audio.py --replace to add a track)")
         doc = _normalize(args, meta, stats, lufs, tp, out)
@@ -245,6 +300,18 @@ def main() -> int:
         return _versions(args, meta, plan)
 
     stats = measure(args.input, args.lufs, args.tp, args.lra)
+    if stats.get("too_short"):
+        info(f"audio is shorter than one 400 ms loudness block: no integrated loudness (true peak {stats.get('input_tp')} dBTP)")
+        if args.measure_only:
+            measured = {"silent": False, "too_short": True, "input_i": None, "input_tp": stats.get("input_tp")}
+            if STATE.json:
+                emit(None, measured=measured)
+            else:
+                print(json.dumps(measured, indent=2))
+            return 0
+        refuse("input", "audio_too_short",
+               f"input audio peaks at {stats.get('input_tp')} dBTP but is shorter than one 400 ms loudness block, so it has "
+               "no integrated loudness to normalise from (this is not silence)", input_tp=stats.get("input_tp"))
     if stats.get("silent"):
         info("audio is silent (integrated loudness -inf); nothing to normalise")
         if args.measure_only:

package/scripts/multicam.py

@@ -33,7 +33,7 @@ import sys
 from typing import Dict, List, Tuple
 
 from _common import guard_sidecar, label_chain, matrix_chain, range_chain, video_args, aac_args, add_common, apply_common, default_output, die, emit, ffmpeg_base, info, time_arg, probe, run, x264_args, X264_PRESETS, fmt_secs, decode_pcm_mono, rms_envelope, STATE
-from _common.emit import note, record_fallback, warn
+from _common.emit import note, record_fallback, record_skip, warn
 from _common.decision import av_trim, rebase_project_paths
 from _common.probe import display_size, square_pixels, square_pixels_note
 from sync import measure_offset
@@ -179,9 +179,13 @@ def main() -> int:
     offsets = [0.0]
     ratios = [1.0]
     conf = [1.0]
+    # A131: per camera, why --fix-drift measured no drift (too_short / low_confidence, as sync.py
+    # says it); None when it was measured, and for the reference, which is the clock (0 by definition)
+    drift_skipped: List[object] = [None]
     for p in args.inputs[1:]:
         off, score = measure_offset(args.inputs[0], p, 0.0, args.analyze_seconds, 20.0, args.max_offset, 1.0)
         ratio = 1.0
+        skipped_reason = None
         if args.fix_drift:
             ref_dur = metas[0]["duration"] or 0.0
             sec_dur = probe(p)["duration"] or 0.0
@@ -189,7 +193,11 @@ def main() -> int:
             window = 60.0
             head_len = min(args.analyze_seconds, overlap_end)
             tail_start = overlap_end - window
-            if tail_start > head_len / 2 + 5:
+            if tail_start <= head_len / 2 + 5:
+                skipped_reason = "too_short"
+                record_skip(f"{p} too short to measure drift reliably; skipping drift correction", "drift_correction_skipped",
+                            path=p, reason=skipped_reason, overlap_seconds=round(overlap_end, 3), drift_window=window)
+            else:
                 ref_start, sec_start = tail_start, tail_start - off
                 if sec_start < 0:
                     ref_start -= sec_start
@@ -204,10 +212,18 @@ def main() -> int:
                 if elapsed > 0 and sc > 0.1:
                     ratio = 1.0 - residual / elapsed
                     off = off + (ratio - 1.0) * (head_len / 2)
+                else:
+                    skipped_reason = "low_confidence"
+                    record_skip(f"could not measure drift with confidence for {p}; skipping drift correction",
+                                "drift_correction_skipped", path=p, reason=skipped_reason,
+                                confidence=round(max(0.0, sc), 3), measured_over_seconds=round(elapsed, 2))
+        drift_skipped.append(skipped_reason)
         offsets.append(off)
         ratios.append(ratio)
         conf.append(score)
-        info(f"{p}: offset {off:+.3f}s (confidence {score:.2f})" + (f", drift {(ratio - 1) * 1e6:+.0f} ppm" if args.fix_drift else ""))
+        info(f"{p}: offset {off:+.3f}s (confidence {score:.2f})"
+             + (f", drift {(ratio - 1) * 1e6:+.0f} ppm" if args.fix_drift and not skipped_reason else
+                f", drift not measured ({skipped_reason})" if args.fix_drift else ""))
         if score < 0.1:
             warn(f"{p} has low correlation confidence ({score:.2f}); check that it shares an audio event with the reference before "
                  "trusting this offset", "sync_low_confidence", path=p, confidence=round(score, 3))
@@ -215,7 +231,8 @@ def main() -> int:
     report = {"inputs": args.inputs, "offsets_seconds": [round(o, 4) for o in offsets],
               "confidence": [round(c, 3) for c in conf]}
     if args.fix_drift:
-        report["drift_ppm"] = [round((r - 1) * 1e6, 1) for r in ratios]
+        report["drift_ppm"] = [None if why else round((r - 1) * 1e6, 1) for r, why in zip(ratios, drift_skipped)]
+        report["drift_skipped_reason"] = drift_skipped
     if args.offsets_only:
         emit(None, **report)
         if not args.json:

package/scripts/overlay.py

@@ -388,6 +388,12 @@ def main() -> int:
     end = time_arg(args.end, "--end", fps) if args.end else None
     if start is not None and end is not None and end <= start:
         die("--end must be after --start")
+    main_len = (meta.get("video") or {}).get("duration") or meta.get("duration")
+    if start is not None and main_len and start >= main_len:
+        # A172: an overlay that starts after the picture ends draws nothing, and the run said
+        # verified: true; --place already refuses the same case
+        die(f"--start {start:g} is at or after the end of the video ({main_len:.3f} s): nothing would be drawn",
+            hint="give a --start inside the clip")
     if not 0 <= args.opacity <= 1:
         die("--opacity must be within 0..1")
     if args.chromakey and not args.video:

package/scripts/pad.py

@@ -16,6 +16,7 @@ Examples:
 import argparse
 import sys
 
+from _common.emit import record_fallback
 from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, drawn_chain, emit, EVEN_SCALE, ffmpeg_base, info, probe, run_keeping_subtitles, validate_color, video_args, X264_PRESETS, time_arg, fmt_secs, run
 
 
@@ -58,6 +59,11 @@ def main() -> int:
         # streams runs on 5.1-8.1 alike. run() only adds an even scale to a -vf, so add it here.
         v = meta["video"]
         even = EVEN_SCALE + "," if (v.get("width") or 0) % 2 or (v.get("height") or 0) % 2 else ""
+        if even:
+            # A239: the runner's retry records this when it adds the scale; here it is added up
+            # front (one -filter_complex), so the record is made here, as broll and stabilize do
+            record_fallback(f"{args.input} is {v.get('width')}x{v.get('height')}: scaled to even dimensions first",
+                            "odd_dimensions_scaled_even", output=output, scale=EVEN_SCALE)
         af = f"adelay={int(args.start * 1000)}:all=1,apad=pad_dur={args.end:.3f}"
         cmd += ["-filter_complex", f"[0:v:0]{even}{vf}[v];[0:a:0]{af}[a]", "-map", "[v]", "-map", "[a]"]
     else:

package/scripts/render.py

@@ -391,7 +391,8 @@ def render_pack(names: List[str], args) -> int:
         size = os.path.getsize(out) if os.path.exists(out) else 0
         rows.append({"platform": name, "file": os.path.basename(out), "path": out,
                      "size_bytes": size, "duration": probe_doc.get("duration"),
-                     "check": ("pass" if chk.get("ok") else ("%d FAIL" % chk["failed"]) if chk.get("failed") else ("pass" if ok else "failed")),
+                     # a destination whose check did not run is "not checked", not "pass" (the class of A113)
+                     "check": ("pass" if chk.get("ok") else ("%d FAIL" % chk["failed"]) if chk.get("failed") else ("not checked" if ok else "failed")),
                      "ok": bool(ok)})
         outputs.append(out)
         if not ok:
@@ -421,7 +422,8 @@ def render_pack(names: List[str], args) -> int:
             code=stopped[0]["exit_code"] if stopped else 1, kind=stopped[0]["kind"] if stopped else "verification",
             output=pack, dry_run=STATE.dry_run, pack=rows, outputs=outputs)
     emit(pack, pack=rows, outputs=outputs, stages=["pack"],
-         verification=[{"step": "check", "ok": r["ok"], "platform": r["platform"]} for r in rows])
+         # a destination whose check did not run has no check step: "not checked" is not ok: true
+         verification=[{"step": "check", "ok": True, "platform": r["platform"]} for r in rows if r["check"] == "pass"])
     return 0
 
 
@@ -1186,6 +1188,31 @@ def _has_sound(current: str, proj: Dict[str, Any], rel: Any) -> bool:
     return False
 
 
+def planned_clip_length(clip: Dict[str, Any], src: str, index: int) -> float:
+    """A dry run's length of clip `index` before its speed stage: the source's measured length,
+    or its in..out range of it (the cut a real run measures does not exist yet). Only when neither
+    can be read is the speed planned on a stand-in 10 s, and that is recorded (A97): a plan that
+    gave no sign its fit.py --duration came from an invented number read as a measured one."""
+    from _common.decision import parse_time
+    length = fps = None
+    if os.path.isfile(src):
+        meta = probe(src)
+        length = meta.get("duration") or None
+        # hh:mm:ss:ff needs the source's rate, which the real cut reads from the same place
+        fps = (meta.get("video") or {}).get("fps") or None
+    try:
+        start = parse_time(str(clip["in"]), fps) if clip.get("in") is not None else 0.0
+        end = parse_time(str(clip["out"]), fps) if clip.get("out") is not None else length
+    except ValueError:
+        start, end = 0.0, None
+    if end is not None and end - start > 0:
+        return end - start
+    record_skip(f"[dry-run] clip {index}: its length could not be read before the cut exists, so the speed stage is "
+                "planned on a stand-in 10 s; a real run measures the cut", "speed_length_placeholder",
+                stage="clips", clip=index, path=src, placeholder_seconds=10.0)
+    return 10.0
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("project", nargs="?", help="project.json, or a plan.json written by <tool> --plan")
@@ -1474,7 +1501,7 @@ def main() -> int:
             if not (spd > 0) or spd != spd or spd == float("inf"):
                 die(f"clip {i}: speed must be a positive number, got {c['speed']!r}")
             if abs(spd - 1.0) > 1e-6:  # speed 1.0 used to cost a full re-encode for nothing
-                dur = (probe(part).get("duration") or 0.0) if not STATE.dry_run else 10.0
+                dur = (probe(part).get("duration") or 0.0) if not STATE.dry_run else planned_clip_length(c, src, i)
                 fitted = str(work / f"clip{i:02d}_speed{mid}")
                 sh("fit.py", part, "--duration", f"{dur / spd:.3f}", "-o", fitted, stage="clips")
                 part = fitted

package/scripts/scenes.py

@@ -30,7 +30,7 @@ from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
 from _common.color import bt709_label_filter  # noqa: E402
-from _common.probe import square_pixels  # noqa: E402
+from _common.probe import PROBED_VIDEO, square_pixels  # noqa: E402
 from _common import dry_run_input_pending  # noqa: E402
 
 SHOT_FPS = 4.0          # frames/second sampled for --shots' flow estimate
@@ -348,7 +348,7 @@ def main() -> int:
         vf = (f"select='{expr}'," + (lab + "," if lab else "") + (square + "," if square else "")
               + f"scale={tile_w}:-2{stamp},"
               f"tile={cols}x{rows}:padding=2:margin=2:color=0x202020")
-        run(ffmpeg_base() + ["-i", args.input, "-an", "-vf", vf, "-frames:v", "1", "-fps_mode", "vfr", "-update", "1", args.sheet])
+        run(ffmpeg_base() + ["-i", args.input, "-map", f"0:{PROBED_VIDEO}", "-an", "-vf", vf, "-frames:v", "1", "-fps_mode", "vfr", "-update", "1", args.sheet])
         info(f"wrote {args.sheet}")
         result["sheet"] = args.sheet
 

package/scripts/silence.py

@@ -34,6 +34,7 @@ from _common import guard_sidecar, refuse_existing_outputs, refuse_output_is_inp
 from _common.emit import refuse
 from _common import detect_silences as detect, STATE, add_common, apply_common, default_output, die, emit, info, is_audio_output, print_json, probe, X264_PRESETS, measured_level_dbfs, fmt_secs
 from _common.decision import frame_rate, stream_starts
+from _common.probe import PROBED_AUDIO
 
 
 
@@ -305,7 +306,8 @@ def cut_levels(path: str, tm: Dict[str, Any], duration: float,
     out = []
     with tempfile.TemporaryDirectory(prefix="silence-levels-") as tmp:
         raw = os.path.join(tmp, "pcm.s16le")
-        proc = run_analysis([require_tool("ffmpeg"), "-hide_banner", "-loglevel", "error", "-nostdin", "-i", path, "-vn",
+        proc = run_analysis([require_tool("ffmpeg"), "-hide_banner", "-loglevel", "error", "-nostdin", "-i", path,
+                             "-map", f"0:{PROBED_AUDIO}", "-vn",
                              "-ac", str(channels), "-ar", str(CUT_LEVEL_RATE), "-f", "s16le", "-y", raw],
                             check=False, text=False)
         if proc.returncode != 0 or not os.path.isfile(raw) or not os.path.getsize(raw):

package/scripts/stabilize.py

@@ -27,6 +27,8 @@ import sys
 import tempfile
 from pathlib import Path
 
+from _common.probe import PROBED_VIDEO
+from _common.runner import default_selection_maps
 from _common import STATE, add_common, apply_common, aac_args, cfr_args, default_output, die, emit, escape_filter_path, ffmpeg_base, info, probe, require_tool, run, video_args, X264_PRESETS, run_analysis, dry_run_input_pending, fmt_secs, record_fallback, EVEN_SCALE
 
 
@@ -79,8 +81,9 @@ def main() -> int:
             # A frame number, not a boolean: frame 1 is the standard reference for "lock to
             # this fixed frame" (mirrors vidstabtransform's own tripod=1 below).
             detect_vf += ":tripod=1"
+        # both passes read the picture probe() describes (its size chose the even scale above)
         detect_cmd = [ffmpeg, "-hide_banner", "-loglevel", "error", "-nostdin", "-y", "-i", args.input,
-                      "-vf", detect_vf, "-f", "null", "-"]
+                      "-map", f"0:{PROBED_VIDEO}", "-vf", detect_vf, "-f", "null", "-"]
         # Pass 1 is a measurement into a temp file (the transforms), so it runs under --dry-run
         # as well; only pass 2, the write, is skipped there.
         if not dry_run_input_pending(args.input):
@@ -94,7 +97,7 @@ def main() -> int:
             # Equivalent to relative=0:smoothing=0 -- overrides --smoothing, since averaging a
             # camera path makes no sense once every frame is locked to one fixed reference.
             transform_vf += ":tripod=1"
-        cmd = ffmpeg_base() + ["-i", args.input, "-vf", transform_vf]
+        cmd = ffmpeg_base() + ["-i", args.input] + default_selection_maps(meta, output) + ["-vf", transform_vf]
         cmd += video_args(meta, args.crf, args.preset)
         cmd += cfr_args(meta)
         if has_audio:

package/scripts/sync.py

@@ -37,6 +37,7 @@ from _common import video_args, add_common, apply_common, emit, aac_args, audio_
 from _common.emit import record_skip, warn
 from _common.decision import SEEK_MARGIN, frame_rate, grid_at_or_after, stream_starts
 from _common.timeline import output_timecode_args
+from _common.runner import default_selection_maps
 
 SR = 8000  # decode sample rate
 
@@ -392,14 +393,15 @@ def main() -> int:
             # Even a keyframe on the trim point moved the picture by its B-frame delay (+69 ms).
             # The re-encode below starts on the frame itself; a sound-only file is still copied.
             if head_trim > 0 and not drift_af and not has_video:
-                cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second, "-c", "copy"]
+                # the second file's first audio track: the one decode_pcm_mono() measured
+                cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + default_selection_maps(second_meta, output) + ["-c", "copy"]
                 if os.path.splitext(output)[1].lower() in (".mp4", ".mov", ".m4v"):
                     cmd += ["-movflags", "+faststart"]
                 cmd += ["-avoid_negative_ts", "make_zero", output]
                 proc = run(cmd, check=False)
                 fail_if_classified(proc)
                 if proc.returncode != 0:
-                    cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + (video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf) if has_video else []) + audio_codec_for(output) + [output]
+                    cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + default_selection_maps(second_meta, output) + (video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf) if has_video else []) + audio_codec_for(output) + [output]
                     run(cmd)
             else:
                 # Seek SEEK_MARGIN early and drop the margin on the output side, as cut.py's
@@ -415,7 +417,9 @@ def main() -> int:
                     cmd += ["-ss", f"{head_trim - m:.6f}"]
                     if m > 0:
                         out_seek = ["-ss", f"{m / (drift_ratio if drift_af else 1.0):.6f}"]
-                cmd += ["-i", args.second] + out_seek
+                # -map after the output-side -ss: both are output options, so the order is the
+                # same command, and the seek stays next to the -i it drops the margin from
+                cmd += ["-i", args.second] + out_seek + default_selection_maps(second_meta, output)
                 af_parts = on_clock + drift_af
                 if delay_ms > 0:
                     af_parts.append(f"adelay={delay_ms}:all=1")