ffmpeg-skill 3.6.6 → 3.7.0

package/scripts/caption.py

@@ -1229,7 +1229,9 @@ def main() -> int:
     args._fit_floor = args.min_size if args.min_size is not None else ass_units(MIN_CAPTION_FRACTION)
     fit_unmeasurable = not (play_w and play_h)
     fit_stats: dict = {"fit_size": args.fit_size, "size_requested": args.size,
-                       "size_used": None if fit_unmeasurable else args.size,
+                       # A76: null until a fit (or a stated size) decides it; a --transcribe
+                       # dry run has no cues, so nothing is fitted and nothing is claimed
+                       "size_used": args.size if (args.fit_size == "off" or (args.fit_size == "auto" and args._size_explicit)) else None,
                        "size_floor": args._fit_floor,
                        "size_pct_height": round(args.size * 100.0 / ASS_SCRIPT_HEIGHT, 2),
                        "shrunk": 0, "fit_scope": args.fit_size_scope, "fit_exhausted": False}
@@ -1569,14 +1571,23 @@ def main() -> int:
             cmd += [f"-c:s:{i}", existing_out[i]]
         tracks: List[Dict[str, Any]] = []
         converted: List[str] = []
+        # A60: a kept track is reported with the disposition the input gives it (the muxer copies
+        # it), not False whatever the file says; when --default-track makes a new track the
+        # default, the kept ones are cleared so the file does not carry two defaults
+        new_default = bool(args.default_track and any(
+            lang and lang.lower() == args.default_track.lower() for _p, lang in added))
         for i in range(existing_subs):
             detail = existing_details[i] if i < len(existing_details) else {}
             written = detail.get("codec") if existing_out[i] == "copy" else existing_out[i]
             if existing_out[i] != "copy":
                 converted.append(f"{detail.get('codec')} -> {existing_out[i]}")
+            kept_default = bool(detail.get("default")) and not new_default
+            if new_default and detail.get("default"):
+                # "-default" takes that one flag off; "0" would clear forced and the rest with it
+                cmd += [f"-disposition:s:{i}", "-default"]
             tracks.append({"index": i, "file": None, "language": detail.get("language"),
                            "title": detail.get("title"), "codec": written,
-                           "default": False, "cues": None, "kept_from_input": True})
+                           "default": kept_default, "cues": None, "kept_from_input": True})
         for n, (path, lang) in enumerate(added):
             idx = existing_subs + n
             cmd += [f"-c:s:{idx}", codec]
@@ -1608,7 +1619,9 @@ def main() -> int:
             tracks.append({"index": idx, "file": path, "language": stored, "title": title,
                            "codec": codec, "default": is_default, "cues": cues_n,
                            "kept_from_input": False})
-        if args.default_track and not any(t["default"] for t in tracks):
+        # asked of the tracks this run adds: a default the input already carried does not make
+        # --default-track fr true when no --srt was tagged fr
+        if args.default_track and not new_default:
             die(f"--default-track {args.default_track}: no --srt was tagged with that language",
                 kind="input")
         # MPEG-4 has no way to say "no default subtitle track": the muxer sets the track-header
@@ -1726,6 +1739,19 @@ def main() -> int:
         generated_ass = True
     else:
         generated_ass = False
+    if not generated_ass and caption_stats.get("fit_scope") == "cue":
+        # A67: one size per cue is a {\fsN} override in the generated ASS; the plain SRT burn
+        # draws every cue at one FontSize, so the scope that was applied is the file's, and
+        # saying "cue" described sizes nobody drew. A caller's own --ass sets its sizes itself
+        # (styles, per-cue overrides): this tool decided none of them, so it claims no scope.
+        if args.ass:
+            caption_stats["fit_scope"] = None
+            side_notes.append("--fit-size-scope cue was not applied: the --ass file sets its own sizes, "
+                              "which this tool does not read or change")
+        else:
+            caption_stats["fit_scope"] = "file"
+            side_notes.append("--fit-size-scope cue applies on the generated-ASS route (--animate, --karaoke, emoji "
+                              "overlays); this burn draws every cue at one size (size_used), so the fit is file-scoped")
 
     if args.ass:
         if not generated_ass and not os.path.exists(args.ass) and not planned_ass:

package/scripts/check.py

@@ -48,6 +48,7 @@ from _common.probe import (CHANGE_FLOOR, CHANGE_GRID, change_mask_tiles, change_
                            detect_flashes, first_frame_stats, presentation_times, measured_level_dbfs)
 from _common.emit import file_identity
 from _common.probe import PROBED_AUDIO
+from _common.probe import display_size as shown_size, shorter_than_a_loudness_block
 from _common import STATE, add_common, apply_common, die, emit, info, probe, require_tool, run, run_analysis, dry_run_input_pending
 
 # The one delivery table (scripts/_platforms.py): check.py's rows, export.py's presets and the
@@ -459,8 +460,17 @@ def main() -> int:
                      "reason": reason if status != "PASS" else "",
                      "kind": "judgement" if name in JUDGEMENT else "format"})
 
-    dur = meta.get("duration") or 0.0
-    if spec["max_duration"]:
+    # A113: a length ffprobe did not report is not a length of 0 s that fits under every limit.
+    # The row says it was not measured (FAIL under a length limit, WARN without one), and the
+    # --content rows that are shares of the running time say so too instead of disappearing.
+    dur_read = meta.get("duration")
+    dur = dur_read or 0.0
+    if dur_read is None:
+        row("duration", "FAIL" if spec["max_duration"] else "WARN", "could not measure",
+            f"<= {spec['max_duration']:g}s" if spec["max_duration"] else "any",
+            "remux the file (export.py --preset copy) so the container states its length, then check again",
+            reason="the file does not state its length, so whether it is within the limit is unknown")
+    elif spec["max_duration"]:
         row("duration", "PASS" if dur <= spec["max_duration"] else "FAIL", f"{dur:.2f}s", f"<= {spec['max_duration']:g}s", "decide with the user: cut.py keeps quality but drops content; fit.py --duration speeds up (audio pitch-preserved, motion faster)")
     else:
         row("duration", "PASS", f"{dur:.2f}s", "any")
@@ -469,7 +479,9 @@ def main() -> int:
         w, h = v["width"], v["height"]
         if v.get("rotation") in (90, -90, 270, -270):
             w, h = h, w
-        asp = aspect_name(w, h)
+        # A114: the aspect a viewer sees is the displayed frame's (rotation and SAR applied), not
+        # the stored grid's: 1440x1080 at SAR 4:3 is a 16:9 picture
+        asp = aspect_name(*shown_size(v)) if all(shown_size(v)) else aspect_name(w, h)
         if spec["aspects"]:
             row("aspect", "PASS" if asp in spec["aspects"] else "FAIL", asp, "/".join(spec["aspects"]), f"fit.py --aspect {spec['aspects'][0]} --fit pad (keeps everything, adds bars) or crop (fills the frame, loses the edges: check the subject with look.py)")
         else:
@@ -478,7 +490,11 @@ def main() -> int:
         if spec["min_height"]:
             row("resolution", "PASS" if short >= spec["min_height"] else "WARN", f"{w}x{h}", f"short side >= {spec['min_height']}", "upscaling will not add detail; re-export from the master")
         fps = v.get("fps") or 0
-        if spec["fps_max"]:
+        if spec["fps_max"] and not fps:
+            # a rate ffprobe did not report is not 0 fps under every limit (the class of A113)
+            row("fps", "WARN", "could not measure", f"<= {spec['fps_max']}", "re-encode at a fixed rate (fit.py --fps N)",
+                reason="the stream states no frame rate, so whether it is within the limit is unknown")
+        elif spec["fps_max"]:
             row("fps", "PASS" if fps <= spec["fps_max"] + 0.01 else "FAIL", f"{fps:g}", f"<= {spec['fps_max']}", "fit.py --fps 30 (drops half the frames of 60 fps motion; fine for talking heads, visible on sports/gaming)")
         row("vfr", "PASS" if not v.get("variable_frame_rate_suspected") else "WARN", "variable" if v.get("variable_frame_rate_suspected") else "constant", "constant", "fit.py --fps N (any re-encode conforms it)")
         if spec["codecs"]:
@@ -517,7 +533,10 @@ def main() -> int:
         row("video", "FAIL", "none", "video stream", "")
 
     size = meta.get("size_bytes") or 0
-    if spec["max_bytes"]:
+    if spec["max_bytes"] and meta.get("size_bytes") is None:
+        row("file size", "FAIL", "could not measure", f"<= {spec['max_bytes'] / 1024 / 1024:.0f} MB", "",
+            reason="the file's size could not be read, so whether it is within the limit is unknown")
+    elif spec["max_bytes"]:
         row("file size", "PASS" if size <= spec["max_bytes"] else "FAIL", f"{size / 1024 / 1024:.1f} MB", f"<= {spec['max_bytes'] / 1024 / 1024:.0f} MB", "export.py --crf 24 or lower resolution")
 
     if a:
@@ -569,12 +588,30 @@ def main() -> int:
         loudness_ran = False
         if a.get("sample_rate") and a["sample_rate"] not in (44100, 48000):
             row("sample rate", "WARN", a["sample_rate"], "44100 or 48000", "loudness.py --sample-rate 48000")
-        if not args.no_loudness and spec["lufs"] is not None:
+        # A117: --tp alone (custom has no loudness target) asks for the true-peak row, which
+        # needs the same measurement pass; without it the run reported 0 failed having measured nothing
+        tp_only = spec["lufs"] is None and args.tp is not None
+        if not args.no_loudness and (spec["lufs"] is not None or tp_only):
             lm = measure_loudness(args.input)
             loudness_ran = bool(lm)
             if lm and lm["tp"] <= SILENT_PEAK_DBFS:
                 silent_audio(lm["tp"])
-            if lm:
+            if lm and tp_only:
+                row("true peak", "PASS" if lm["tp"] <= spec["tp"] + TP_TOLERANCE_DB else "FAIL", f"{lm['tp']:.1f} dBTP", f"<= {spec['tp']:g} dBTP (+{TP_TOLERANCE_DB:g} dB tolerance)", f"loudness.py --tp {spec['tp']:g}")
+            elif not lm and tp_only:
+                row("true peak", "WARN", "could not measure", f"<= {spec['tp']:g} dBTP", "re-run check.py, or verify true peak manually",
+                    reason="ffmpeg's loudness measurement didn't produce a readable result -- this was not actually checked")
+            elif (lm and lm["lufs"] == float("-inf") and lm["tp"] > SILENT_PEAK_DBFS
+                  and shorter_than_a_loudness_block(a.get("duration") or a.get("tagged_duration") or dur_read)):
+                # A257: shorter than one 400 ms gating block: a true peak but no integrated
+                # loudness. Not silence, and not a -inf LUFS that FAILs the target. Decided on
+                # the sound's length: a longer track whose every block is under the gate reads
+                # -inf too, and that one still FAILs the target below
+                row("loudness", "WARN", "could not measure (shorter than one 400 ms loudness block)",
+                    f"{spec['lufs']:g} ± {spec['lufs_tol']:g} LUFS", "",
+                    reason="integrated loudness is gated over 400 ms blocks; a clip this short has none")
+                row("true peak", "PASS" if lm["tp"] <= spec["tp"] + TP_TOLERANCE_DB else "FAIL", f"{lm['tp']:.1f} dBTP", f"<= {spec['tp']:g} dBTP (+{TP_TOLERANCE_DB:g} dB tolerance)", f"loudness.py --tp {spec['tp']:g}")
+            elif lm:
                 diff = abs(lm["lufs"] - spec["lufs"])
                 row("loudness", "PASS" if diff <= spec["lufs_tol"] else "FAIL", f"{lm['lufs']:.1f} LUFS", f"{spec['lufs']:g} ± {spec['lufs_tol']:g} LUFS", f"loudness.py -I {spec['lufs']:g} for speech or music; leave ambience/near-silence (<= -40 LUFS) alone and say so",
                     reason="the platform will auto-normalise it to its own target anyway, which can pump or duck the mix in ways you did not choose")
@@ -600,6 +637,14 @@ def main() -> int:
     if args.content:
         cd = detect_content(args.input, dur, video=bool(v), audio=bool(a))
         span = dur if dur > 0 else 0.0
+        if not span and not dry_run_input_pending(args.input):
+            # A113: black, frozen and silence are shares of the running time; with no length
+            # read there is nothing to divide by, and dropping the rows read as nothing to report
+            for name, stream in (("black", v), ("frozen", v), ("silence", a)):
+                if stream:
+                    row(name, "WARN", "could not measure", "a share of the running time",
+                        "remux the file (export.py --preset copy) so the container states its length, then check again",
+                        reason="the file does not state its length, so this share of it could not be worked out")
         if "black" in cd and span:
             share = _span_total(cd["black"]) / span
             row("black", "FAIL" if share >= BLACK_FAIL else ("WARN" if share > BLACK_WARN else "PASS"),

package/scripts/export.py

@@ -44,7 +44,7 @@ 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
@@ -54,6 +54,7 @@ from _common.probe import PROBED_AUDIO, PROBED_VIDEO, probed_maps, square_pixels
 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
@@ -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)
@@ -722,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/loudness.py

@@ -23,7 +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
+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
 
 
@@ -78,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 = (
@@ -130,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
@@ -162,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:
@@ -204,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)
@@ -250,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/verify.py

@@ -156,6 +156,12 @@ def main() -> int:
     apply_common(args)
     if STATE.plan:
         die("verify.py does not support --plan: its steps run for real (it ignores --dry-run too)")
+    ignored_dry_run = STATE.dry_run
+    if ignored_dry_run:
+        # A240: the flag is accepted and ignored (docs/design-decisions.md "Dry run"); the steps
+        # run and write, so the document says dry_run: false and a note says the flag was ignored
+        STATE.dry_run = False
+        info("--dry-run is ignored by verify.py: its steps run and write their outputs")
 
     files = collect(args.paths)
     tmp = None
@@ -267,11 +273,12 @@ def main() -> int:
         print(report)
     if tmp and not args.keep:
         tmp.cleanup()
+    notes = (["--dry-run is ignored by verify.py: its steps ran and wrote their outputs"] if ignored_dry_run else [])
     if failed:
         die(f"{failed} of {total} verification steps failed", kind="verification", output=None, dry_run=STATE.dry_run,
-            report=args.report, files=results, failed=failed, total=total)
+            report=args.report, files=results, failed=failed, total=total, **({"notes": notes} if notes else {}))
     if args.json:
-        emit(None, report=args.report, files=results, failed=failed, total=total)
+        emit(None, report=args.report, files=results, failed=failed, total=total, **({"notes": notes} if notes else {}))
     return 0