ffmpeg-skill 3.8.15 → 3.8.17

package/scripts/overlay.py

@@ -29,13 +29,14 @@ A VP9 --video layer stored with an alpha layer (a WebM from export.py --preset v
 with libvpx-vp9, so its transparency reaches the composite (FFmpeg's own VP9 decoder drops it).
 """
 import argparse
+import ast
 import re
 import sys
 from typing import Any, Dict, List, Optional
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, safe_margins_px, resolve as resolve_platform
 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, probe, run_keeping_subtitles, validate_color, X264_PRESETS, time_arg, fmt_secs
+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, cfr_filter, cfr_at_input, with_cfr, default_output, die, escape_drawtext, ffmpeg_base, info, probe, run_keeping_subtitles, validate_color, 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, window_expr, windowed_overlay_x
@@ -86,6 +87,56 @@ def position_exprs(pos: str, margin: int, text_mode: bool, margins: Optional[dic
     return x, y
 
 
+def _scaled_height(w: int, src_w: int, src_h: int, factor: int) -> int:
+    """The height scale=W:-1 (factor 1) or scale=W:-2 (factor 2) gives a src_w x src_h picture:
+    av_rescale(w, ih, iw * factor) * factor, rounded half away from zero as FFmpeg rounds it."""
+    den = src_w * factor
+    return max(factor, (2 * w * src_h + den) // (2 * den) * factor)
+
+
+def on_grid(x: str, y: str, main: "tuple", layer: "tuple") -> "Optional[tuple]":
+    """Where the layer goes so its top-left pixel is at (x, y) in luma, x and y being the overlay
+    expressions position_exprs() gives, as overlay evaluates them (the integer part).
+
+    overlay places a layer on a 4:2:0 picture on the chroma grid: an odd x or y is taken down to
+    the even one before it (#512: --position 11,13 drew the logo at 10,12, and a centred or
+    right-aligned layer whose position came out odd moved the same way). So the layer gets one
+    transparent column/row on the left/top where x/y is odd, and is overlaid at the even position
+    before it: its luma lands where it was asked, and the chroma sample on that edge is shared
+    with the pixel outside it. Returns (x_even, y_even, pad filter or ""), or None when a size is
+    unknown (a dry run's pending input): the overlay then gets the expressions, as before."""
+    (mw, mh), (lw, lh) = main, layer
+    if not (mw and mh and lw and lh):
+        return None
+
+    def arith(node: Any) -> float:
+        # the four operations on whole numbers position_exprs() writes, and nothing else
+        if isinstance(node, ast.Expression):
+            return arith(node.body)
+        if isinstance(node, ast.Constant) and isinstance(node.value, int):
+            return float(node.value)
+        if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.USub, ast.UAdd)):
+            return -arith(node.operand) if isinstance(node.op, ast.USub) else arith(node.operand)
+        if isinstance(node, ast.BinOp) and isinstance(node.op, (ast.Add, ast.Sub, ast.Mult, ast.Div)):
+            a, b = arith(node.left), arith(node.right)
+            return {ast.Add: a + b, ast.Sub: a - b, ast.Mult: a * b}.get(type(node.op), a / b if b else 0.0)
+        raise ValueError(f"not a position: {ast.dump(node)}")
+
+    def value(expr: str, big: int, small: int, axis: str) -> Optional[int]:
+        num = re.sub(axis.upper(), str(big), re.sub(axis, str(small), expr))
+        try:
+            return int(arith(ast.parse(num, mode="eval")))  # the integer part, as overlay's (int) cast takes it
+        except (SyntaxError, ValueError):
+            return None
+
+    px, py = value(x, mw, lw, "w"), value(y, mh, lh, "h")
+    if px is None or py is None:
+        return None
+    ox, oy = px & 1, py & 1  # two's complement: -3 is one column right of -4
+    pad = f"pad=iw+{ox}:ih+{oy}:{ox}:{oy}:color=black@0" if ox or oy else ""
+    return px - ox, py - oy, pad
+
+
 def _wrap_to_frame(args, frame_w: int, margins: Optional[dict], frame_h: int = 0) -> str:
     """--text broken into lines that fit between the frame's side margins at --font-size, by the
     same phrase rules graphics.py and caption.py wrap with; text that fits comes back unchanged.
@@ -443,11 +494,22 @@ def main() -> int:
     cmd = ffmpeg_base() + ["-i", args.input]
 
     if args.image:
-        refuse_not_a_still(args.image, probe(args.image), "--image",
+        image_meta = probe(args.image)
+        refuse_not_a_still(args.image, image_meta, "--image",
                            "--video composites a moving layer; `look.py FILE --at T` writes one frame of it as a PNG")
         chain: List[str] = ["format=rgba"]
+        # a still that stores non-square pixels (a PNG's pHYs, a JPEG's density) is made square at
+        # its display aspect first, as a --video layer is: its size and position are computed in
+        # that frame, and placed from it at its stored size a 100x100 PNG at SAR 2:1 drew 100 px
+        # wide at x=120 of a 320 px main for top-right, 100 px short of the edge
+        if square_pixels(image_meta.get("video")):
+            chain.append(square_pixels(image_meta.get("video")))
+            note(square_pixels_note(image_meta.get("video"), "the --image"))
+        iw, ih = display_size(image_meta.get("video"))
+        lw = int(vw * args.scale_percent / 100) if args.scale_percent else args.scale or iw
+        lh = _scaled_height(lw, iw, ih, 1) if lw != iw and iw and ih else ih
         if args.scale_percent:
-            chain.append(f"scale={int(vw * args.scale_percent / 100)}:-1")
+            chain.append(f"scale={lw}:-1")
         elif args.scale:
             chain.append(f"scale={args.scale}:-1")
         if args.opacity < 1:
@@ -461,6 +523,11 @@ def main() -> int:
             if end is not None and end > args.fade:
                 chain.append(f"fade=t=out:st={end - args.fade:.3f}:d={args.fade:g}:alpha=1")
         x, y = position_exprs(args.position, args.margin, text_mode=False, margins=safe_margins)
+        grid = on_grid(x, y, (vw, vh), (lw, lh))
+        if grid:
+            # padded in RGBA, where a one-pixel offset is exact, before the layer is made YUV
+            x, y = grid[0], grid[1]
+            chain += [grid[2]] if grid[2] else []
         # 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)
         # a --start/--end window is in the layer's position, which is evaluated on the main
@@ -510,8 +577,11 @@ def main() -> int:
             if main_dur and at >= main_dur:
                 die(f"--place {a:g}-{b:g}@{at:g}: starts after the main video ends ({main_dur:.3f} s)")
         chain = [square_pixels(pip_meta["video"])] if square_pixels(pip_meta["video"]) else []
+        iw, ih = display_size(pip_meta["video"])
+        lw = int(vw * args.scale_percent / 100) if args.scale_percent else args.scale or iw
+        lh = _scaled_height(lw, iw, ih, 2) if (args.scale_percent or args.scale) and iw and ih else ih
         if args.scale_percent:
-            chain.append(f"scale={int(vw * args.scale_percent / 100)}:-2")
+            chain.append(f"scale={lw}:-2")
         elif args.scale:
             chain.append(f"scale={args.scale}:-2")
         # an alpha line composites at 4:4:4: the layer is not taken through 4:2:0 on the way
@@ -544,6 +614,15 @@ 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)
+        grid = on_grid(x, y, (vw, vh), (lw, lh))
+        if grid:
+            x, y = grid[0], grid[1]
+            if grid[2]:
+                # padded at 4:4:4, where a one-pixel offset is exact; overlay takes the layer back
+                # to the main's 4:2:0 on its own grid, as the layer is now aligned with it
+                if not any(c.endswith("yuva444p") or c.endswith("yuva444p10le") for c in chain):
+                    chain.append("format=yuva444p10le" if deep else "format=yuva444p")
+                chain.append(grid[2])
         # 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")
@@ -646,6 +725,15 @@ def main() -> int:
     else:
         cmd += video_args(meta, args.crf, args.preset, convert_matrix=not args.video) + cfr_args(meta)
         cmd += aac_args() if meta.get("audio") else ["-an"]
+    if cfr_filter(meta):
+        # the conform of a VFR source is the fps filter (in a graph, on the main picture as it is
+        # decoded): the encoder line's -fps_mode cfr alone let a frame run up to two frames late (#512)
+        if "-filter_complex" in cmd:
+            i = cmd.index("-filter_complex") + 1
+            cmd[i] = cfr_at_input(cmd[i], meta)
+        else:
+            i = cmd.index("-vf") + 1
+            cmd[i] = with_cfr(cmd[i], meta)
     dropped_streams = run_keeping_subtitles(cmd, output)
     if not STATE.dry_run:
         result = probe(output, role="output")

package/scripts/pad.py

@@ -18,7 +18,7 @@ import sys
 
 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
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, 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
 
 
 def main() -> int:
@@ -51,7 +51,12 @@ def main() -> int:
     tpad = f"tpad=start_duration={args.start:.3f}:stop_duration={args.end:.3f}:color="
     # a --color with chroma lands in the BT.709 the output is tagged with (tpad's own YUV is BT.601
     # before FFmpeg 7.1, and for an untagged picture after it); black is the same under every matrix
-    vf = drawn_chain(tpad + args.color, meta, [args.color], tpad + "black")
+    # the conform of a VFR source is the fps filter right after tpad, which pads by time: before
+    # it, the padding was rounded to the delivered grid on top of the frames' own rounding (37 ms
+    # late), and after a drawn chain's maskedmerge the last frame was lost (#512)
+    conform = with_cfr("", meta)
+    vf = drawn_chain(tpad + args.color + ("," + conform if conform else ""), meta, [args.color],
+                     tpad + "black" + ("," + conform if conform else ""))
     cmd = ffmpeg_base() + ["-i", args.input]
     if has_audio:
         # One -filter_complex, not a -vf and an -af: the ffmpeg scheduler of Ubuntu 26.04's 8.0.1 and

package/scripts/proxy.py

@@ -26,7 +26,7 @@ Examples:
 import argparse
 import sys
 
-from _common import add_common, apply_common, cfr_args, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, fmt_secs
+from _common import add_common, apply_common, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, fmt_secs
 from _common.emit import note
 from _common.probe import display_size, square_pixels, square_pixels_note
 
@@ -77,7 +77,7 @@ def main() -> int:
              + (f"the source is {sw}px wide and a proxy is not upscaled" if asked > ceiling else "2px is the smallest width"))
     output = args.output or default_output(args.input, "proxy")
 
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", (square + "," if square else "") + f"scale={out_w}:-2"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr((square + "," if square else "") + f"scale={out_w}:-2", meta, args.fps)]
     cmd += video_args(meta, args.crf, "veryfast")
     cmd += cfr_args(meta, args.fps)
     cmd += ["-map", "0:v:0"] + (["-map", "0:a:0", "-c:a", "aac", "-b:a", "96k"] if has_audio else ["-an"])

package/scripts/redact.py

@@ -27,7 +27,7 @@ Examples:
 import argparse
 import sys
 
-from _common import add_common, overlay_format, apply_common, aac_args, cfr_args, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
+from _common import add_common, overlay_format, apply_common, aac_args, cfr_args, cfr_at_input, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
 from _common.emit import note
 from _common.probe import display_size, square_pixels, square_pixels_note
 
@@ -98,7 +98,8 @@ def main() -> int:
     output = args.output or default_output(args.input, "redact")
     if args.mode == "delogo":
         cmd = ffmpeg_base() + ["-i", args.input, "-vf",
-                               (square + "," if square else "") + f"delogo=x={args.x}:y={args.y}:w={args.width}:h={args.height}",
+                               with_cfr((square + "," if square else "") + f"delogo=x={args.x}:y={args.y}:w={args.width}:h={args.height}",
+                                        meta, args.fps),
                                "-map", "0:v:0"]
     else:
         # exact=1: crop rounds an odd x/y down to the chroma grid of a 4:2:0 frame otherwise, and
@@ -127,6 +128,8 @@ def main() -> int:
                        f"pad={args.width + 2 * ox}:{args.height + 2 * oy}:{ox}:{oy}:color=black@0")
         fc = (f"[0:v]{square + ',' if square else ''}split=2[base][region];[region]{region}[patched];"
               f"[base][patched]overlay={args.x - ox}:{args.y - oy}{overlay_format(meta)}[out]")
+        # a VFR source (or --fps) is conformed by the fps filter as it is decoded (#512)
+        fc = cfr_at_input(fc, meta, args.fps)
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", fc, "-map", "[out]"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]

package/scripts/render.py

@@ -76,7 +76,7 @@ from export import PRESETS, PLATFORM_OF
 from _platforms import PLATFORMS, caption_defaults, resolve as resolve_platform
 from _common import guard_sidecar, STATE, add_common, aspect_ratio, brand_caption_style, load_brand, apply_common, child_args, die, emit as _emit, info, option_args, probe, require_tool, run, run_tool, place_output, refuse_output_is_input, _check_existing_output, _check_output_path, fingerprint, PLAN_VERSION, ffmpeg_version, X264_PRESETS
 from _common.runner import HW_ENV, HW_FORCED_ENV, add_hw_orchestrator_args, child_exit_code, found_exe, kept_clause, kept_deliverables, mark_delivered, owned_identity, read_json, remember_written
-from _common.emit import absorb_stage, audit, record_fallback, record_skip, refuse, warn
+from _common.emit import absorb_stage, audit, is_output_shape_flag, record_fallback, record_skip, refuse, stderr_records, warn
 from _common.decision import rebase_project_paths
 import subprocess
 from _contract import CONTRACT_VERSION
@@ -405,9 +405,7 @@ def render_pack(names: List[str], args) -> int:
             doc = {}
         # the child ran with --json, so its planned commands come back in the document: the pack
         # is the one path that writes seven files, and --dry-run has to show all of them
-        for line in proc.stderr.splitlines():
-            if line.startswith("$ ") or line.startswith("[dry-run]"):
-                STATE.commands.append(line[2:] if line.startswith("$ ") else line)
+        STATE.commands.extend(text for is_command, text in stderr_records(proc.stderr) if is_command)
         STATE.commands.extend(str(c) for c in (doc.get("commands") or []))
         absorb_stage(name, doc)
         out = doc.get("output") or dest_out
@@ -806,9 +804,9 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
     cmd = [str(HERE / script)] + [str(a) for a in argv] + (extra or []) + own + child_args() + ["--json"]
     info("→ " + " ".join(os.path.basename(c) if i < 1 else c for i, c in enumerate(cmd[:-1])))
     proc = run_tool(cmd)
-    for line in proc.stderr.splitlines():
-        if line.startswith("$ ") or line.startswith("[dry-run]"):
-            STATE.commands.append(line[2:] if line.startswith("$ ") else line)
+    for is_command, line in stderr_records(proc.stderr):
+        if is_command:
+            STATE.commands.append(line)
         elif line.strip():
             info("    " + line)
     try:
@@ -1212,7 +1210,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
         os.chdir(plan["cwd"])
     if not isinstance(plan.get("argv"), list):
         _reject_plan(path, digest, "plan_argv_invalid", f"{path}: argv must be a list", argv_type=type(plan.get("argv")).__name__)
-    argv = [str(a) for a in plan["argv"]]
+    # a plan an earlier version recorded with --json-brief (A181): the tool is run for its full
+    # document, as every plan written now asks for
+    argv = [str(a) for a in plan["argv"] if not is_output_shape_flag(str(a))]
     if STATE.dry_run:
         for c in plan.get("commands") or []:
             STATE.commands.append(c)
@@ -1226,9 +1226,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
         return 0
     info(f"executing plan {path}: {tool} " + " ".join(argv))
     proc = run_tool([str(script)] + argv + child_args() + ["--json"])
-    for line in proc.stderr.splitlines():
-        if line.startswith("$ "):
-            STATE.commands.append(line[2:])
+    for is_command, line in stderr_records(proc.stderr):
+        if is_command and not line.startswith("[dry-run]"):
+            STATE.commands.append(line)
         elif line.strip():
             info("    " + line)
     try:
@@ -1326,7 +1326,19 @@ def export_timeline(proj: Dict[str, Any], rel, dest: str) -> int:
     export = proj.get("export")
     frame_from_preset(frame, export if isinstance(export, dict) else {})
     fit = proj.get("fit")
-    if isinstance(fit, dict) and fit.get("aspect") and frame.get("aspect") and aspect_ratio(frame["aspect"]) is None:
+    if isinstance(fit, dict) and len(proj.get("clips") or []) == 1:
+        # one clip: the render's fit stage reframes the clip's own picture with the fit object's
+        # aspect, mode, sides and rate, the frame's only where the fit object has none (the
+        # render's setdefault), so the sequence takes them by the same rule (#506: frame 16:9 with
+        # fit 1:1 rendered a square and exported 1920x1080). Several clips are fitted inside the
+        # join, which join.py sizes from the frame first; their sequence stays the frame's
+        if fit.get("aspect") and aspect_ratio(str(fit["aspect"])) is None:
+            die(f"--export-timeline: fit.aspect {fit['aspect']!r}: use W:H with whole numbers, like 16:9 "
+                "(fit.py refuses it too)", kind="input")
+        if fit.get("fit") is not None and fit["fit"] not in ("pad", "crop", "blur"):
+            die(f"--export-timeline: fit.fit {fit['fit']!r}: use pad, crop or blur (fit.py's --fit)", kind="input")
+        frame.update({k: fit[k] for k in ("aspect", "fit", "width", "height", "fps") if fit.get(k) is not None})
+    elif isinstance(fit, dict) and fit.get("aspect") and frame.get("aspect") and aspect_ratio(frame["aspect"]) is None:
         # the render hands fit.py the fit object's own aspect, never this one (only the preset
         # match above reads it), and completes: the sequence is the frame's size without it
         del frame["aspect"]

package/scripts/silence.py

@@ -29,7 +29,7 @@ from _common import (filler_spans, FILLER_WORDS, FILLER_AMBIGUOUS, FILLER_DISCOU
 from _common import asr as _asr
 from _common.emit import warn
 from _common.asr import _dicts
-from _common.runner import parse_json, replace_checked
+from _common.runner import parse_json, replace_checked, same_file
 from _common import guard_sidecar, refuse_existing_outputs, refuse_output_is_input, _check_output_path
 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
@@ -672,7 +672,7 @@ def main() -> int:
         # --overwrite allows replacing an old map, never the source, the cut or the EDL
         refuse_output_is_input(args.timemap, *[p for p in (args.input, args.words, args.filler_words) if p])
         for flag, other in (("-o", args.output), ("--edl", args.edl), ("--plan", getattr(args, "plan", None))):
-            if other and os.path.realpath(other) == os.path.realpath(args.timemap):
+            if other and same_file(other, args.timemap):
                 refuse("input", "timemap_path_taken",
                        f"--timemap {args.timemap} is the same file as {flag}; give the map its own path",
                        timemap=args.timemap, flag=flag, path=other)

package/scripts/speedramp.py

@@ -17,9 +17,10 @@ Examples:
 """
 import argparse
 import sys
+from fractions import Fraction
 from typing import List, Tuple
 
-from _common.decision import av_trim, frame_durations, frame_rate, grid_at_or_after, stream_starts
+from _common.decision import av_trim, conform_filter, delivered_rate, frame_durations, frame_rate, grid_at_or_after, stream_starts
 from _common import add_common, apply_common, aac_args, default_output, die, emit, ffmpeg_base, info, probe, run, video_args, X264_PRESETS, fmt_secs, time_arg
 from _common.emit import input_length
 
@@ -85,7 +86,7 @@ def main() -> int:
     has_audio = bool(meta.get("audio"))
     output = args.output or default_output(args.input, "ramp")
 
-    vparts, aparts, labels = [], [], []
+    vparts, aparts = [], []
     # The coverage check above allows the last end to sit up to 0.5 s off the probed duration.
     # That slack is for a caller who rounded the duration, not a reason to redraw the tail at
     # the last factor. The end bound is omitted only when the stated end is the file's end
@@ -97,7 +98,12 @@ def main() -> int:
     # the factor scaled that (+570 ms at 0.5x). The first segment starts at the first frame.
     v0 = stream_starts(meta)[0]
     rate = frame_rate(meta)
+    # on a VFR source the picture is delivered at the rate the encoder line forces (its average):
+    # closed on r_frame_rate, -r then resampled the joined picture and it drifted 113 ms late (#512)
+    out_rate = delivered_rate(meta) or rate
+    srate = int((meta.get("audio") or {}).get("sample_rate") or 0)
     bounds = [v0] + [grid_at_or_after(end, v0, rate) for _, end, _ in segments[:-1]]
+    retimed = 0.0  # where the segment starts on the output's clock
     for i, (start, end, factor) in enumerate(segments):
         vlabel, alabel = f"v{i}", f"a{i}"
         to_eof = i == len(segments) - 1 and last_runs_to_eof
@@ -107,23 +113,52 @@ def main() -> int:
             die(f"--segment {start:g}-{end:g}:{factor:g} holds no frame: both ends fall on the frame at "
                 f"{bounds[i]:.3f}s; widen it or merge it into a neighbour")
         vtrim, atrim = av_trim(bounds[i], seg_end, rate)
-        # the closing fps puts the sped-up frames back on the source's grid with its frame
+        # the closing fps puts the sped-up frames back on the delivered grid with its frame
         # duration: concat starts the next segment after the last frame's duration, which setpts
         # leaves at the unscaled 1/rate, so every 2x segment pushed the rest of the picture two
         # frames late against the sound (and added those frames)
-        vparts.append(f"[0:v]{vtrim},setpts=PTS/{factor:.6f},{frame_durations(meta, rate)}[{vlabel}]")
-        labels.append(f"[{vlabel}]")
+        vchain = f"[0:v]{vtrim},setpts=PTS/{factor:.6f},{frame_durations(meta, out_rate)}"
+        achain = f"[0:a]{atrim},{atempo_chain(factor)}"
+        if out_rate:
+            # Each segment holds the frames (and samples) between its retimed ends on the whole
+            # output's grid, not its own length rounded: eight 0.5 s segments at 27 fps rounded
+            # to 14 frames each, concat advanced 14/27 s per segment and the last flash landed
+            # 130 ms late. The picture is sampled on the output's grid (an offset of under half
+            # a frame, and fps's start_time) and, but for a last segment that runs to the end,
+            # padded by a frame or two and cut to its count; the sound is padded or cut to its
+            # own count, so neither stream drifts across segments.
+            first = round(retimed * out_rate)
+            shift = first / out_rate - retimed
+            vchain = (f"[0:v]{vtrim},setpts=PTS/{factor:.6f}{-shift:+.6f}/TB,"
+                      f"{frame_durations(meta, out_rate)}:start_time=0")
+            if seg_end is not None:
+                after = retimed + (seg_end - bounds[i]) / factor
+                vchain += f",tpad=stop=2:stop_mode=clone,trim=end_frame={round(after * out_rate) - first}"
+                if srate:
+                    achain += f",{conform_filter(round(after * srate) - round(retimed * srate), srate)}"
+                retimed = after
+        vparts.append(f"{vchain}[{vlabel}]")
         if has_audio:
-            aparts.append(f"[0:a]{atrim},{atempo_chain(factor)}[{alabel}]")
-
+            aparts.append(f"{achain}[{alabel}]")
+
+    # the two streams are joined by two concats: one concat over both started each segment after
+    # the longer of its two streams, so a picture a frame longer than its sound moved both late
+    n = len(segments)
+    # Every segment's picture is a whole count of frames on one grid, so the joined picture's
+    # timestamps are rebuilt from the running frame count: FFmpeg 6.1.1's video-only concat gave a
+    # one-frame segment no length (it takes a segment's end from its last frame's timestamp), so
+    # three one-frame segments put the rest of the picture a frame before its sound. The closing
+    # fps gives the frames their durations back (from 7.0 setpts leaves them 0, frame_durations)
+    regrid = ""
+    if out_rate:
+        grid = frame_durations(meta, out_rate)
+        q = Fraction(grid[len("fps="):]) if "/" in grid else Fraction(out_rate).limit_denominator(1001)
+        regrid = f",setpts=N*{q.denominator}/({q.numerator}*TB),{grid}"
+    fc = ";".join(vparts) + ";" + "".join(f"[v{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=0{regrid}[outv]"
+    maps = ["-map", "[outv]"]
     if has_audio:
-        concat_inputs = "".join(f"[v{i}][a{i}]" for i in range(len(segments)))
-        fc = ";".join(vparts + aparts) + f";{concat_inputs}concat=n={len(segments)}:v=1:a=1[outv][outa]"
-        maps = ["-map", "[outv]", "-map", "[outa]"]
-    else:
-        concat_inputs = "".join(f"[v{i}]" for i in range(len(segments)))
-        fc = ";".join(vparts) + f";{concat_inputs}concat=n={len(segments)}:v=1:a=0[outv]"
-        maps = ["-map", "[outv]"]
+        fc += ";" + ";".join(aparts) + ";" + "".join(f"[a{i}]" for i in range(n)) + f"concat=n={n}:v=0:a=1[outa]"
+        maps += ["-map", "[outa]"]
 
     cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", fc] + maps
     cmd += video_args(meta, args.crf, args.preset)

package/scripts/sphere.py

@@ -33,7 +33,7 @@ import argparse
 import math
 import sys
 
-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, fmt_secs
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
 from _common.emit import note
 
 # v360's own AVOption names for the input projections real 360 cameras/exports actually
@@ -124,7 +124,7 @@ def main() -> int:
             f"yaw={args.yaw:g}:pitch={args.pitch:g}:roll={args.roll:g}:"
             f"h_fov={args.h_fov:g}:v_fov={args.v_fov:g}:"
             f"w={args.width}:h={args.height}:interp={args.interp}")
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", v360, "-map", "0:v:0"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr(v360, meta, args.fps), "-map", "0:v:0"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]
     cmd += video_args(meta, args.crf, args.preset)

package/scripts/stabilize.py

@@ -29,7 +29,7 @@ from pathlib import Path
 
 from _common.probe import PROBED_VIDEO
 from _common.runner import ffmpeg_failure_extra, default_selection_maps, require_filter
-from _common import 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
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, 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
 
 
 def main() -> int:
@@ -104,7 +104,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] + default_selection_maps(meta, output) + ["-vf", transform_vf]
+        cmd = ffmpeg_base() + ["-i", args.input] + default_selection_maps(meta, output) + ["-vf", with_cfr(transform_vf, meta)]
         cmd += video_args(meta, args.crf, args.preset)
         cmd += cfr_args(meta)
         if has_audio:

package/scripts/straighten.py

@@ -22,7 +22,7 @@ import argparse
 import math
 import sys
 
-from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, drawn_chain, emit, ffmpeg_base, info, probe, run_keeping_subtitles, validate_color, video_args, X264_PRESETS, fmt_secs
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, drawn_chain, emit, ffmpeg_base, info, probe, run_keeping_subtitles, validate_color, video_args, X264_PRESETS, fmt_secs
 from _common.emit import note
 from _common.probe import display_size, square_pixels, square_pixels_note
 
@@ -100,7 +100,7 @@ def main() -> int:
     if square_pixels(meta["video"]):
         rotate = square_pixels(meta["video"]) + "," + rotate
         note(square_pixels_note(meta["video"]))
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", rotate, "-map", "0:v:0"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr(rotate, meta, args.fps), "-map", "0:v:0"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]
     cmd += video_args(meta, args.crf, args.preset)

package/scripts/verify.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from _common import STATE, add_common, apply_common, die, emit, guard_sidecar, info, probe, refuse_output_is_input, MEDIA_EXT as _MEDIA_EXT
+from _common.runner import _stop_child, _unwatch, _watch
 
 HERE = Path(__file__).resolve().parent
 # _common's one list less the stills, as batch.py walks a folder: verify kept a list of its own,
@@ -140,13 +141,24 @@ def step(name: str, argv: List[str], timeout: float) -> Dict:
         if not ok:
             r.update(kind="verification", reason="hdr_lost", message=r["error"])
         return r
+    child = subprocess.Popen([sys.executable, str(HERE / argv[0])] + argv[1:] + _forwarded(argv) + ["--json"], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace")
+    # watched like run_tool()'s child (review of #530): a SIGTERM or Ctrl-C to verify.py stops the
+    # step through stop_children() -- its own handler removes its partial output and lock --
+    # instead of leaving it running and writing after verify.py has exited
+    _watch(child, [])
     try:
-        proc = subprocess.run([sys.executable, str(HERE / argv[0])] + argv[1:] + _forwarded(argv) + ["--json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                              text=True, encoding="utf-8", errors="replace", timeout=timeout or None)
+        out, err = child.communicate(timeout=timeout or None)
+        proc = subprocess.CompletedProcess(child.args, child.returncode, out, err)
     except subprocess.TimeoutExpired:
+        # stopped as run_tool() stops a sibling script past its ceiling (#465 A183's sweep): the
+        # SIGKILL subprocess.run() sent left the step's partial output and output lock in --out
+        _stop_child(child)
         msg = f"timeout after {timeout:.0f}s"
         return {"step": name, "ok": False, "seconds": round(time.time() - t0, 1), "error": msg,
                 "kind": "timeout", "reason": "step_timeout", "message": msg}
+    finally:
+        _unwatch(child)
     try:
         doc = json.loads(proc.stdout)
     except ValueError:
@@ -198,10 +210,27 @@ def main() -> int:
     files = collect(args.paths)
     FORWARD.update(overwrite=STATE.overwrite, fast=STATE.fast)
     tmp = None
+    started = {"step": False}
     if args.out:
         # made first, so a --report inside a new --out folder passes the guard below (#413 review)
         outdir = Path(args.out)
+        made = [d for d in (outdir, *outdir.parents) if not d.exists()]
         outdir.mkdir(parents=True, exist_ok=True)
+        if made:
+            import atexit
+
+            def _remove_unused_dirs() -> None:
+                # a run refused before its first step (a --report guard) leaves no empty --out
+                # folder behind, as batch.py leaves no out/ (#465 A187's sibling); once a step has
+                # run the folder is the caller's, empty or not
+                if started["step"]:
+                    return
+                for d in made:  # deepest first
+                    try:
+                        d.rmdir()
+                    except OSError:
+                        pass
+            atexit.register(_remove_unused_dirs)
     if args.report:
         # a file this run writes itself (#408): not one of the media it verifies (a folder's
         # files included), nor an existing file without --overwrite
@@ -301,6 +330,7 @@ def main() -> int:
             refuse_output_is_input(out, *every_input, why=f"it is where verify writes the {name!r} step's output for {str(f)!r}")
 
     results = []
+    started["step"] = True
     for f, entry, plan, cues in jobs:
         info(f"=== {f}")
         if cues: