ffmpeg-skill 3.8.11 → 3.8.13

package/scripts/export.py

@@ -52,7 +52,7 @@ from _common.decision import hw_preset_video, restate_last_swap
 from _common.emit import note, record_fallback, record_skip, warn
 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, input_length
+from _common.emit import file_identity, input_length, own_length
 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, UPLOAD_LIMITS_AS_OF, resolve as resolve_platform
@@ -254,7 +254,7 @@ def _key_fill(args, p: Dict, meta: Dict, output: str, cmd: List[str], vf: List[s
     pair = {k: [fv.get(k), kv.get(k)] for k in ("width", "height", "nb_frames", "r_frame_rate")}
     # the video streams' lengths: the fill's container also counts its sound, which may run longer
     # than the picture, and the key has none
-    pair["duration"] = [round(v.get("duration") or v.get("tagged_duration") or 0, 3) for v in (fv, kv)]
+    pair["duration"] = [round(own_length(v) or 0, 3) for v in (fv, kv)]
     same = all(a == b and a not in (None, 0) for a, b in pair.values())
     # the two written files against each other: no expected value, so no provenance (#403: it said
     # "output_measurement", which is not one of the contract's values)
@@ -741,7 +741,7 @@ def main() -> int:
         m = measure_loudness(output)
         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"))):
+                and shorter_than_a_loudness_block(own_length(written_audio))):
             # 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"])

package/scripts/fit.py

@@ -68,6 +68,24 @@ def atempo_chain(factor: float) -> str:
     return ",".join(parts)
 
 
+def picture_output_t(target: float, meta: dict) -> str:
+    """The output `-t` of a trim from the start that has no sound to end: `{target:.3f}` as it
+    always was, unless that text keeps another number of frames than `target` does. The frames
+    kept are those that start before `target`. 37 frames of a 30000/1001 picture are 1.2345667 s:
+    `-t 1.235` is past the 38th frame's start and wrote it, and `-t 1.001` for 1.0014 s stopped
+    before the 31st. The limit is then written half a frame before the first frame left out.
+    Without a frame grid (no rate: a dry run's pending input; a variable rate, which the output's
+    -r regrids) the millisecond text stays."""
+    text = f"{target:.3f}"
+    rate = frame_rate(meta)
+    if not rate or (meta.get("video") or {}).get("variable_frame_rate_suspected"):
+        return text
+    out = grid_at_or_after(target, stream_starts(meta)[0], rate)  # the first frame left out
+    if out - 1 / rate + 1e-6 < float(text) <= out + 1e-9:
+        return text
+    return f"{out - 0.5 / rate:.6f}"
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("input")
@@ -189,9 +207,17 @@ def main() -> int:
                     vf.append("tblend=all_mode=average")
                 if has_audio:
                     af.append(atempo_chain(factor))
-            # atempo's sound ends before the target (13 to 62 ms before it on FFmpeg 6.1.1), so the
-            # millisecond cuts nothing off a retimed track and stays
-            post += ["-t", f"{target:.3f}" if af else length_output_t(target, rate, runs_on=True)]
+            # atempo's sound is not the input's length over the factor (it comes out some
+            # milliseconds short or long), and the millisecond -t stays on a retimed track: padding
+            # it to the target's samples (apad after atempo in -af) never ended on FFmpeg 8.0.1
+            # (seen in CI: killed at the time limit), so the track keeps the length atempo gives.
+            # Where the sound is not retimed (a factor within 1e-4 of 1) the source's runs on and
+            # the -t ends it to the sample. A picture without sound that is not retimed either is
+            # a trim, counted in frames; one that is retimed, or regridded by --fps, keeps the
+            # millisecond
+            retimed = abs(factor - 1.0) > 1e-4
+            post += ["-t", f"{target:.3f}" if af else length_output_t(target, rate, runs_on=True) if rate
+                     else f"{target:.3f}" if retimed or args.fps or has_audio else picture_output_t(target, meta)]
             STATE.duration_hint = target
         else:
             if target < src_dur:
@@ -202,7 +228,12 @@ def main() -> int:
                 # picture would not be the one the start timecode below names
                 m = min(SEEK_MARGIN, round(start, 3))
                 pre_input += ["-ss", f"{start - m:.3f}"]
-                post += (["-ss", f"{m:.3f}"] if m > 0 else []) + ["-t", length_output_t(target, rate, runs_on=True)]
+                # without sound the -t only counts frames (picture_output_t). Not from the centre:
+                # there the output's clock starts at the seek, between two frames, and the encoder
+                # rounds each frame to its own tick
+                keep = (picture_output_t(target, meta) if not rate and not args.fps and not args.from_center
+                        else length_output_t(target, rate, runs_on=True))
+                post += (["-ss", f"{m:.3f}"] if m > 0 else []) + ["-t", keep]
                 # the output starts on the first frame at or after the seek (a seek before a
                 # picture that starts after the file's origin: on its first frame): its start
                 # timecode is that frame's, not the source's first frame's

package/scripts/freeze.py

@@ -19,7 +19,7 @@ Examples:
 import argparse
 import sys
 
-from _common.decision import av_trim, frame_durations, frame_rate, grid_at_or_after, silence_filter, stream_starts
+from _common.decision import av_trim, frame_durations, frame_rate, grid_at_or_after, silence_filter, stream_starts, tpad_length
 from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, MissingFpsError, time_arg, fmt_secs, run
 from _common.emit import input_length
 
@@ -83,7 +83,9 @@ def main() -> int:
         vf = f"tpad=start_mode=clone:start_duration={args.hold:.3f}"
         cmd = ffmpeg_base() + ["-i", args.input, "-vf", vf, "-map", "0:v:0"]
         if has_audio:
-            cmd += ["-map", "0:a:0?", "-af", silence_filter(meta["audio"].get("sample_rate"), lead=args.hold)]
+            # the sound waits as long as the picture is held: whole frames (tpad_length), as the
+            # hold in the middle of a clip pads by the held frames' length
+            cmd += ["-map", "0:a:0?", "-af", silence_filter(meta["audio"].get("sample_rate"), lead=tpad_length(args.hold, meta))]
     else:
         # freeze N frames at `at` by holding on that one source frame for --hold seconds, then
         # resuming the rest of the clip: split the timeline at `at` and hold the remainder's

package/scripts/graphics.py

@@ -51,6 +51,7 @@ from _common.fonts import font_choice, record_font_choice
 from _common.probe import display_size, square_pixels, square_pixels_note
 from _ass_overlay import text_overlay_ass, EMOJI_SENTINEL
 from _common import drawtext_fontfile  # noqa: E402
+from _common.decision import window_expr, windowed_overlay_x  # noqa: E402
 from _common.emit import input_length  # noqa: E402
 
 # where the template's text chain goes in a filter_complex it builds (graphics.main fills it in)
@@ -232,7 +233,9 @@ def main(force_route: Optional[str] = None) -> int:
             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})'"
+    # the window's bounds sit half a frame from the frames they select (window_expr): `{:.3f}`
+    # put the frame at 1.234567 s of a 30000/1001 picture after a --start of "1.235"
+    en = f"enable='{window_expr(s, e, meta)}'"
     base = min(W, H) * args.scale  # scale everything from the short side
     filters: List[str] = []
     rate = f"{meta['video'].get('fps') or 30:g}"
@@ -253,6 +256,12 @@ def main(force_route: Optional[str] = None) -> int:
         filters.append(f"{BOX}{len(boxes)}")
         boxes.append((colour, alpha, drawbox_geo, x, y, w, h, enable, x_expr))
 
+    def layer_at(x, y, enable: str) -> str:
+        """An overlay's `x=...:y=...` for a layer shown inside `enable`'s window: the window is in
+        the layer's position, which is evaluated on the picture's frames, where overlay's own
+        enable is evaluated on the layer's frames too (windowed_overlay_x)."""
+        return f"x={windowed_overlay_x(str(x).strip(chr(39)), enable[len('enable='):].strip(chr(39)))}:y={y}"
+
     def layer_src(colour: str, alpha: float, w: int, h: int, left: int = 0, top: int = 0) -> str:
         """A colour source to overlay (a box, the lower-third bar, the progress fill), converted when it
         has chroma. overlay places a 4:2:0 picture on even rows and columns only: a box that starts on
@@ -450,8 +459,8 @@ def main(force_route: Optional[str] = None) -> int:
         x_expr = f"if(lt(t,{s:.3f}+0.4),-{bar_w}+({bar_w}+{m_left})*((t-{s:.3f})/0.4),if(gt(t,{e:.3f}-0.3),{m_left}-({bar_w}+{m_left})*(1-({e:.3f}-t)/0.3),{m_left}))"
         fc.append(f"{layer_src(bg, 0.85, bar_w, bar_h)}[bar]")
         fc.append(f"{layer_src(primary, 1.0, int(base * 0.012), bar_h)}[acc]")
-        fc.append(f"[0:v][bar]overlay=x='{x_expr}':y={y0}:{en}:eof_action=pass[v1]")
-        fc.append(f"[v1][acc]overlay=x='{x_expr}':y={y0}:{en}:eof_action=pass[v2]")
+        fc.append(f"[0:v][bar]overlay={layer_at(x_expr, y0, en)}:eof_action=pass[v1]")
+        fc.append(f"[v1][acc]overlay={layer_at(x_expr, y0, en)}:eof_action=pass[v2]")
         tx = f"({x_expr})+{tx_pad}"
         x_rest, x_off = m_left + tx_pad, -bar_w + tx_pad
         draws = []
@@ -546,10 +555,10 @@ def main(force_route: Optional[str] = None) -> int:
             # a layer (overlay composites the alpha too; drawbox leaves it as it was, and takes a
             # 10-bit picture to 8 bits)
             fc.append(f"{layer_src(bg, 0.5, W, h, 0, (H - h) % 2)}[pbg]")
-            fc.append(f"[0:v][pbg]overlay=x=0:y={(H - h) // 2 * 2}:{en}:eof_action=pass[v1]")
+            fc.append(f"[0:v][pbg]overlay={layer_at(0, (H - h) // 2 * 2, en)}:eof_action=pass[v1]")
         else:
             fc.append(f"[0:v]drawbox=x=0:y=ih-{h}:w=iw:h={h}:color={ff_color(bg, 0.5)}:t=fill:{en}[v1]")
-        fc.append(f"[v1][pb]overlay=x='-w+w*min(1,max(0,(t-{s:.3f})/{e - s:.3f}))':y={H - h}:{en}:eof_action=pass[vout]")
+        fc.append(f"[v1][pb]overlay={layer_at(f'-w+w*min(1,max(0,(t-{s:.3f})/{e - s:.3f}))', H - h, en)}:eof_action=pass[vout]")
 
     elif args.template == "sticker":
         # A social sticker: a filled chip of text that pops in. drawtext's box gives the chip
@@ -593,7 +602,7 @@ def main(force_route: Optional[str] = None) -> int:
         if args.duration <= 0:
             die(f"--duration must be > 0, got {args.duration:g}")
         he = min(e, s + args.duration)
-        hen = f"enable='between(t,{s:.3f},{he:.3f})'"
+        hen = f"enable='{window_expr(s, he, meta)}'"
         h1 = int(base * 0.085)
         bar_h = max(3, int(base * 0.01))
         hook_title = wrapped(args.title, h1)
@@ -642,7 +651,7 @@ def main(force_route: Optional[str] = None) -> int:
             ke = ks + seg
             pulse = f"1-0.15*min(1,(t-{ks:.3f})/{seg * 0.5:.3f})"
             add_text(str(k),
-                     f"drawtext=text='{k}':{fo}:fontsize={fs}:fontcolor={ff_color(primary)}:borderw={max(2, fs // 40)}:bordercolor={ff_color(bg)}:x=(w-text_w)/2:y=(h-text_h)/2:alpha='{pulse}':enable='between(t,{ks:.3f},{ke:.3f})'",
+                     f"drawtext=text='{k}':{fo}:fontsize={fs}:fontcolor={ff_color(primary)}:borderw={max(2, fs // 40)}:bordercolor={ff_color(bg)}:x=(w-text_w)/2:y=(h-text_h)/2:alpha='{pulse}':enable='{window_expr(ks, ke, meta, half_open=k > 0)}'",
                      size=fs, color=primary, font=ass_font_family(), align=5, x=W / 2, y=H / 2,
                      outline=float(max(2, fs // 40)), outline_color=bg, start=ks, end=ke,
                      scale_t=(0, seg * 500, 115))
@@ -766,7 +775,7 @@ def main(force_route: Optional[str] = None) -> int:
     drawboxes = []
     for colour, alpha, geo, x, y, w, h, enable, x_expr in boxes:
         if as_layers:
-            layers.append((layer_src(colour, alpha, w, h, x % 2, y % 2), f"x={x_expr or x - x % 2}:y={y - y % 2}:{enable}"))
+            layers.append((layer_src(colour, alpha, w, h, x % 2, y % 2), layer_at(x_expr or x - x % 2, y - y % 2, enable)))
         drawboxes.append(f"drawbox={geo}:color={ff_color(colour, alpha)}:t=fill:{enable}")
     filters = [("" if as_layers else drawboxes[int(f[len(BOX):])]) if f.startswith(BOX) else f for f in filters]
     filters = [f for f in filters if f]

package/scripts/loop.py

@@ -36,7 +36,7 @@ from _common import STATE, concat_list_line, add_common, aac_args, apply_common,
 from _common.emit import warn
 from _common.decision import HELD_FRAMES_WARN_BYTES, av_trim, held_frames_bytes, length_output_t, stream_starts
 from _common.probe import decode_gray_frames, decode_pcm_mono
-from _common.emit import input_length
+from _common.emit import input_length, own_length
 
 
 # The loop filter's size is capped at 32767 frames, so one boomerang cycle (2N-2 frames) must fit.
@@ -131,7 +131,7 @@ def _conformed_frames(v, rate: float, src_dur: float) -> int:
     its length are counted in these, or a repeat is a frame or more off the length planned."""
     # the video stream's length, else Matroska's tag, else the container's (main() refuses a source
     # without one): never the stored frame count, which is what fps= does not keep
-    d = v.get("duration") or v.get("tagged_duration") or src_dur
+    d = own_length(v) or src_dur
     return int(round(float(d) * rate))
 
 
@@ -296,6 +296,8 @@ def main() -> int:
             die(f"--duration ({target:g}s) must be longer than one repeat ({unit:.3f}s) -- use cut.py to trim instead")
         stream_loop = math.ceil(target / unit) - 1
 
+    # a variable-rate source is conformed by the output's own -fps_mode cfr -r (cfr_args)
+    forced_rate = cfr_args(meta, fps if fade_frames and v.get("variable_frame_rate_suspected") else None)
     if args.boomerang:
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", _boomerang_graph(meta, src_dur, args.times), "-map", "[v]"]
         if meta.get("audio"):
@@ -318,6 +320,18 @@ def main() -> int:
             fh.write((concat_list_line(repeat) + "\n") * (stream_loop + 1))
         vtrim, atrim = av_trim(concat_first_frame(listfile), None, fill_gaps=True)
         cmd = ffmpeg_base() + ["-f", "concat", "-safe", "0", "-i", listfile]
+        v_end = stream_starts(meta)[0] + (v.get("duration") or 0.0)
+        if has_audio and not forced_rate and not fade_frames and src_dur - v_end > 0.5 / fps:
+            # A repeat is as long as the file, so where the sound outlasts the picture by more
+            # than half a frame the next repeat's first frame comes later than one frame after
+            # the last. What stood in that gap was left to the output's frame-rate handling:
+            # FFmpeg 6.1 repeated the last frame and showed the next repeat's first frame twice,
+            # from a frame before its time (a 1 s 25 fps clip with 1.23425 s of sound: frame 0 of
+            # the second repeat at 1.20 s and 1.24 s, its sound from 1.23425 s); FFmpeg 7.1 and 8
+            # held the last frame (50 packets for 56). The graph ends on the clip's own rate, so
+            # the gap is the last frame repeated and each later repeat's frames sit on the grid
+            # once. A clip without that gap has nothing to fill and keeps the command it had.
+            vtrim += f",fps={rate}"
         if has_audio:
             cmd += ["-filter_complex", f"[0:v:0]{vtrim}[v];[0:a:0]{atrim}[a]",
                     "-map", "[v]", "-map", "[a]"]
@@ -329,7 +343,7 @@ def main() -> int:
     cmd += video_args(meta, args.crf, args.preset)
     # a crossfade's repeat is already constant at `rate` (its graph's fps=): the loop keeps that rate,
     # not a variable-rate source's average, which re-timed every repeat by a frame or two
-    cmd += ["-fps_mode", "passthrough"] if args.boomerang else cfr_args(meta, fps if fade_frames and v.get("variable_frame_rate_suspected") else None)
+    cmd += ["-fps_mode", "passthrough"] if args.boomerang else forced_rate
     if has_audio:
         cmd += aac_args()
     else:

package/scripts/loudness.py

@@ -24,8 +24,9 @@ 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.emit import own_length, refuse
 from _common.runner import ffmpeg_failure_extra
+from _common.decision import LOSSLESS_AUDIO_EXT
 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
 
 
@@ -121,7 +122,12 @@ def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output
     sr = args.sample_rate or meta["audio"].get("sample_rate") or 48000
     ext = os.path.splitext(output)[1].lower()
     bitrate_pinned = args.audio_bitrate is not None
-    bitrate = args.audio_bitrate or "192k"
+    # an AAC audio extension starts at its own rate (256k for .m4a/.aac), which is what it was
+    # written at: a pinned --audio-bitrate and the raised retries below never reached it, so the
+    # retries re-encoded at 256k and audio_bitrate_used said 192k, then 256k and 320k (A143)
+    codec = AUDIO_CODECS.get(ext, [])
+    own_rate = codec[codec.index("-b:a") + 1] if "aac" in codec and "-b:a" in codec else None
+    bitrate = args.audio_bitrate or own_rate or "192k"
 
     dropped_streams = False
     # loudnorm emits its last block whole, and through the AAC encoder that came out as 0.1 s more
@@ -142,7 +148,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 += ["-map", f"0:{PROBED_AUDIO}", "-vn"] + audio_codec_for(output, bitrate)
+            # the rate reaches an audio extension's codec when it was pinned or is AAC's (an
+            # .mp3/.ogg/.opus left alone keeps its own setting, as it always has)
+            cmd += ["-map", f"0:{PROBED_AUDIO}", "-vn"] + audio_codec_for(output, bitrate if ext not in AUDIO_CODECS or bitrate_pinned or own_rate else None)
         else:
             cmd += probed_maps(meta) + ["-c:v", "copy", "-c:a", "aac", "-b:a", bitrate]
             if ext in (".mp4", ".mov", ".m4v"):
@@ -185,7 +193,8 @@ def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output
         info(f"result:   {float(after['input_i']):.1f} LUFS, TP {float(after['input_tp']):.1f} dBTP (target {lufs} LUFS, TP <= {tp_max:g})")
     result = {k: after[k] for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset", "silent")}
     result["tp_ceiling_used"] = round(ceiling, 2)
-    if ext not in AUDIO_CODECS or "aac" in AUDIO_CODECS[ext]:
+    if ext not in AUDIO_CODECS or "aac" in AUDIO_CODECS[ext] or bitrate_pinned:
+        # a pinned rate reaches an .mp3/.ogg/.opus codec too (A143); unpinned, those keep their own
         result["audio_bitrate_used"] = bitrate
     result["encodes"] = rounds + 1
     # the mode of the last encode: its ceiling is the one the file was made with
@@ -277,7 +286,8 @@ def main() -> int:
     ap.add_argument("--tp", type=float, default=-1.0, help="true peak ceiling in dBTP (default -1)")
     ap.add_argument("--lra", type=float, default=11.0, help="loudness range target in LU (default 11)")
     ap.add_argument("--measure-only", action="store_true", help="print the measured stats as JSON and exit")
-    ap.add_argument("--audio-bitrate", default=None, help="AAC bitrate when the container is video (default 192k; raised to 256k/320k only when the encoder overshoots the true-peak ceiling and you did not pin it)")
+    ap.add_argument("--audio-bitrate", default=None, help="audio bitrate: AAC's in a video container (default 192k), and the codec's of a lossy audio output (.m4a/.aac default 256k, .mp3/.ogg/.opus their own setting); "
+                         "refused for .wav/.flac. Raised to 256k/320k for AAC only when the encoder overshoots the true-peak ceiling and you did not pin it")
     ap.add_argument("--versions", metavar="LIST",
                     help="write one normalised file per target from this master, each measured after: a comma list of "
                          + ", ".join(f"{n} ({i:g} LUFS / {t:g} dBTP)" for n, (i, t) in VERSION_TARGETS.items())
@@ -303,6 +313,10 @@ def main() -> int:
     meta = probe(args.input)
     if not meta.get("audio"):
         die("input has no audio stream")
+    out_ext = os.path.splitext(args.output or default_output(args.input, "loudnorm"))[1].lower()
+    if args.audio_bitrate is not None and not args.measure_only and out_ext in LOSSLESS_AUDIO_EXT:
+        # A143: the rate was dropped without a word; a lossless codec has none to set
+        die(f"--audio-bitrate has no effect on a lossless {out_ext} output; drop it, or write a lossy one (.m4a, .mp3, ...)")
     if plan is not None and not args.measure_only:
         # each version measures the master against its own target (loudnorm's offset depends on
         # it): a pass against -I/--tp first would be one more full decode whose result is unused
@@ -349,8 +363,7 @@ def audio_length(meta: dict) -> "Optional[float]":
     """The sound's own length: the stream's duration, else Matroska's DURATION tag. Never the
     container's, which is the picture's when the picture runs longer (and would fail a correct
     output against an expected length the sound never had)."""
-    audio = meta.get("audio") or {}
-    return audio.get("duration") or audio.get("tagged_duration")
+    return own_length(meta.get("audio"))
 
 
 def _kbps(value: str) -> int:

package/scripts/multicam.py

@@ -30,7 +30,7 @@ import json
 import math
 import os
 import sys
-from typing import Dict, List, Tuple
+from typing import Dict, List, Optional, 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, record_skip, warn
@@ -60,8 +60,19 @@ def parse_switch(spec: str, n: int) -> List[Tuple[float, float, int]]:
             die(f"camera {c} does not exist (inputs are 0..{n - 1})")
         if e <= s:
             die(f"switch entry '{raw}': end must be after start")
+        if round(e, 3) <= round(s, 3):
+            # the cut list (--edl, `cuts`) is written to the millisecond: this range was its
+            # "0.000-0.000", a line cut.py --segments refuses (the scenes.py --edl sibling)
+            die(f"switch entry '{raw}': shorter than a millisecond, the precision the cut list is written in",
+                kind="input")
         out.append((s, e, c))
     out.sort()
+    # A132: ranges on one timeline cannot overlap. The fill below kept both, so the picture of the
+    # overlap played twice while the sound played once, and every later cut ran behind it
+    for (s0, e0, _c0), (s1, e1, _c1) in zip(out, out[1:]):
+        if s1 < e0:
+            die(f"--switch ranges overlap: {fmt_secs(s0)}-{fmt_secs(e0)} and {fmt_secs(s1)}-{fmt_secs(e1)} "
+                "(on the reference timeline each moment has one camera)", kind="input")
     return out
 
 
@@ -158,7 +169,7 @@ def main() -> int:
         media_out = args.output or default_output(args.inputs[0], "multicam", "mp4")
         guard_sidecar(args.edl, *args.inputs, siblings=(args.write_project, media_out))
         guard_sidecar(args.write_project, *args.inputs, siblings=(media_out,))
-        if args.edl or args.write_project:  # they are written before the cut: refuse its output first
+        if args.edl or args.write_project:  # refused up front with them, before any decode
             guard_sidecar(media_out, *args.inputs)
     if args.analyze_seconds > 900:
         die(f"--analyze-seconds {args.analyze_seconds:g}: the window is decoded into memory; 900 s is the ceiling")
@@ -272,17 +283,26 @@ def main() -> int:
         cursor = max(cursor, e)
     if cursor < ref_dur:
         filled.append((cursor, ref_dur, 0))
+    # a gap or a clipped range under a millisecond is nothing at the precision the cut list is
+    # written in (--switch "0.0004-3:1" left a leading "0.000-0.000", the line cut.py --segments
+    # refuses, and a 0.4 ms trim in the render): its neighbour takes it, so the timeline stays whole
+    whole: List[Tuple[float, float, int]] = []
+    carry: Optional[float] = None
+    for s, e, c in filled:
+        if carry is not None:
+            s, carry = carry, None
+        if round(e, 3) <= round(s, 3):
+            if whole:
+                whole[-1] = (whole[-1][0], e, whole[-1][2])
+            else:
+                carry = s
+            continue
+        whole.append((s, e, c))
+    filled = whole
     for s, e, c in filled:
         if not metas[c].get("video"):
             die(f"camera {c} ({args.inputs[c]}) has no video; it can only be used with --audio")
 
-    if args.edl:
-        if not STATE.dry_run:
-            with open(args.edl, "w", encoding="utf-8") as fh:
-                for s, e, _c in filled:
-                    fh.write(f"{s:.3f}-{e:.3f}\n")
-        info(f"wrote {args.edl}")
-
     v0 = metas[0]["video"]
     # camera 0's displayed frame: rotation applied, non-square pixels squared (#411)
     w, h = args.width or display_size(v0)[0], args.height or display_size(v0)[1]
@@ -322,9 +342,18 @@ def main() -> int:
             c, src_s, src_e = 0, s, e
         rendered.append((s, e, c))
         sq = (square_pixels(metas[c]["video"]) + ",") if square_pixels(metas[c]["video"]) else ""
-        parts.append(f"[{c}:v]trim=start={src_s:.4f}:end={src_e:.4f},setpts=PTS-STARTPTS,{convert[c]}{sq}{geo}[v{i}]")
+        # A130: a drift-corrected camera's range is (e - s) * ratio of its own time; played at that
+        # rate it lasts e - s on the reference, as its sound does (asetrate) -- at its own rate the
+        # picture ran (ratio - 1) * (e - s) long and every later cut fell behind the sound
+        retime = f"(PTS-STARTPTS)/{ratios[c]:.9f}" if abs(ratios[c] - 1.0) > 1e-7 else "PTS-STARTPTS"
+        parts.append(f"[{c}:v]trim=start={src_s:.4f}:end={src_e:.4f},setpts={retime},{convert[c]}{sq}{geo}[v{i}]")
         labels.append(f"[v{i}]")
-        project_clips.append({"src": args.inputs[c], "in": round(src_s, 3), "out": round(src_e, 3)})
+        clip = {"src": args.inputs[c], "in": round(src_s, 3), "out": round(src_e, 3)}
+        if abs(ratios[c] - 1.0) > 1e-7:
+            # render.py plays a clip at clips[].speed (its length / speed), as the retime above
+            # does: without it a drift-corrected camera's clip ran (ratio - 1) * (e - s) long
+            clip["speed"] = round(ratios[c], 9)
+        project_clips.append(clip)
     parts.append("".join(labels) + f"concat=n={len(filled)}:v=1:a=0[vout]")
     a = args.audio
     a_start = -offsets[a] if offsets[a] < 0 else 0.0
@@ -358,17 +387,29 @@ def main() -> int:
         # render.py project instead of the direct render this tool already does -- additive, not
         # a replacement: the combined output below is still written as usual.
         project = {"output": default_output(args.inputs[0], "multicam_project", "mp4"),
-                   "clips": project_clips}
+                   "clips": project_clips,
+                   # a switch is a cut: render.py's default is a 0.5 s crossfade at every join,
+                   # which shortens the timeline by 0.5 s a switch and moves every later one
+                   "transition": {"type": "none"}}
         # the inputs are named as given, relative to the working directory, and render.py reads a
         # project's relative paths against the project file's directory: written elsewhere
         # (--write-project out/cut.json), they named files that are not there
         project = rebase_project_paths(project, os.getcwd())
+
+    run(cmd)
+    # the EDL and the project record the cut: written once it exists, not before an encode that then
+    # failed (#462 A41, the silence.py --edl sibling)
+    if args.edl:
+        if not STATE.dry_run:
+            with open(args.edl, "w", encoding="utf-8") as fh:
+                for s, e, _c in filled:
+                    fh.write(f"{s:.3f}-{e:.3f}\n")
+        info(f"wrote {args.edl}")
+    if args.write_project:
         if not STATE.dry_run:
             with open(args.write_project, "w", encoding="utf-8") as fh:
                 fh.write(json.dumps(project, indent=2) + "\n")
         info(f"wrote {args.write_project}")
-
-    run(cmd)
     r = probe(output, role="output")
     info(f"wrote {output} ({fmt_secs(r['duration'])}, {len(filled)} cuts, audio from input {a})")
     extra = {"switch_mode": "energy", "min_shot": args.min_shot} if energy_mode else {}

package/scripts/overlay.py

@@ -38,7 +38,7 @@ from _common import still_input_args  # noqa: E402
 from _common import STATE, script_font_for_text, drawtext_clean, drawtext_line_metrics, drawtext_text_opts, drawtext_draws_newline_glyph, is_multiline, needs_shaping, LANGUAGE_NAMES, has_emoji, detect_script, emoji_clusters, load_brand, drawn_chain, label_chain, layer_base_chain, matrix_chain, overlay_format, range_chain, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, escape_drawtext, ffmpeg_base, info, parse_time, probe, run, run_keeping_subtitles, validate_color, x264_args, X264_PRESETS, time_arg, fmt_secs
 from _common.emit import note, warn
 from _common.color import is_rgb
-from _common.decision import length_output_t
+from _common.decision import length_output_t, window_expr, windowed_overlay_x
 from _common.alpha import (add_alpha_args, audio_line, check_alpha_args, decoder_args_for, default_ext, finish_chain,
                            has_alpha_plane, report as alpha_report, source_alpha, source_format, tag_args, video_line)
 from _common.probe import display_size, refuse_not_a_still, square_pixels, square_pixels_note
@@ -128,13 +128,12 @@ def _wrap_to_frame(args, frame_w: int, margins: Optional[dict], frame_h: int = 0
     return wrapped
 
 
-def enable_expr(start: Optional[float], end: Optional[float]) -> str:
+def enable_expr(start: Optional[float], end: Optional[float], meta: Optional[dict] = None) -> str:
+    """True on the main picture's frames from --start to --end, both inclusive (window_expr):
+    the bounds sit half a frame from the frames they select, not on a frame's own time."""
     if start is None and end is None:
         return ""
-    s = f"{start:.3f}" if start is not None else "0"
-    if end is None:
-        return f"gte(t,{s})"
-    return f"between(t,{s},{end:.3f})"
+    return window_expr(start, end, meta)
 
 
 def alpha_expr(opacity: float, start: Optional[float], end: Optional[float], fade: float) -> str:
@@ -440,7 +439,7 @@ def main() -> int:
             "from --start to --end without a fade", hint="drop --fade for the video layer")
 
     output = args.output or default_output(args.input, "overlay", default_ext(alpha_codec) if alpha_codec else None)
-    enable = enable_expr(start, end)
+    enable = enable_expr(start, end, meta)
     cmd = ffmpeg_base() + ["-i", args.input]
 
     if args.image:
@@ -464,9 +463,9 @@ def main() -> int:
         x, y = position_exprs(args.position, args.margin, text_mode=False, margins=safe_margins)
         # a 10-bit main on a 10-bit line is composited at 10 bits in YUV: format=auto with an RGBA
         # still took the whole picture through 8-bit RGB (overlay_format)
-        ov = f"overlay={x}:{y}" + (overlay_format(meta) or ":format=auto")
-        if enable:
-            ov += f":enable='{enable}'"
+        # a --start/--end window is in the layer's position, which is evaluated on the main
+        # picture's frames; overlay's enable is evaluated on the layer's frames too
+        ov = f"overlay={windowed_overlay_x(x, enable) if enable else x}:{y}" + (overlay_format(meta) or ":format=auto")
         # -loop 1 turns the still into a timed stream so fade/enable expressions see real timestamps
         cmd = ffmpeg_base() + ["-i", args.input, "-loop", "1", *still_input_args(args.image), "-i", args.image]
         # the RGBA still is converted to the BT.709 the output is tagged with (overlay's own
@@ -545,9 +544,9 @@ def main() -> int:
             # which came back BT.601 under the BT.709 tag (#333's defect, on this path)
             chain.append(f"lut=y=val:u=val:v=val:a=val*{args.opacity:g}")
         x, y = position_exprs(args.position, args.margin, text_mode=False, margins=safe_margins)
-        ov = f"overlay={x}:{y}" + (overlay_format(meta) or ":format=auto")
-        if enable:
-            ov += f":enable='{enable}'"
+        # a --start/--end window is in the layer's position, which is evaluated on the main
+        # picture's frames; overlay's enable is evaluated on the layer's frames too
+        ov = f"overlay={windowed_overlay_x(x, enable) if enable else x}:{y}" + (overlay_format(meta) or ":format=auto")
         # a VP9 layer stored with an alpha layer is decoded with libvpx-vp9: FFmpeg's own decoder
         # drops the alpha, and the layer covered the picture as an opaque rectangle
         cmd = ffmpeg_base() + ["-i", args.input] + decoder_args_for(pip_meta, args.video) + ["-i", args.video]

package/scripts/pad.py

@@ -16,8 +16,8 @@ Examples:
 import argparse
 import sys
 
-from _common.emit import record_fallback
-from _common.decision import silence_filter
+from _common.emit import note, record_fallback
+from _common.decision import silence_filter, tpad_length
 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
 
 
@@ -65,8 +65,16 @@ def main() -> int:
             # 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)
-        # the silence is counted in samples when --start/--end is not a whole millisecond
-        af = silence_filter(meta["audio"].get("sample_rate"), args.start, args.end)
+        # The sound is delayed by what the picture is: tpad puts whole frames ahead of the clip
+        # (--start 0.23425 at 25 fps: 6 frames, 0.240 s), and a delay of --start itself moved the
+        # sound 5.75 ms ahead of its picture (tpad_length). The silence after the clip moves
+        # nothing and is --end as asked. Either is counted in samples when it is not a whole
+        # millisecond (silence_filter).
+        lead = tpad_length(args.start, meta)
+        if abs(lead - args.start) > 1e-9:
+            note(f"--start {args.start:g}: the picture can only be padded by whole frames, {lead:.6f} s here; "
+                 f"the sound is delayed by the same {lead:.6f} s so the clip keeps its sync")
+        af = silence_filter(meta["audio"].get("sample_rate"), lead, args.end)
         cmd += ["-filter_complex", f"[0:v:0]{even}{vf}[v];[0:a:0]{af}[a]", "-map", "[v]", "-map", "[a]"]
     else:
         cmd += ["-vf", vf, "-map", "0:v:0"]