ffmpeg-skill 3.1.5 → 3.1.6

package/scripts/loop.py

@@ -21,11 +21,15 @@ Examples:
   python3 loop.py wave.mp4 --boomerang --times 4
 """
 import argparse
+import json
 import math
+import os
 import sys
+import tempfile
 
-from _common import add_common, aac_args, apply_common, cfr_args, default_output, die, emit, ffmpeg_base, info, parse_time, probe, run, video_args, X264_PRESETS, time_arg, fmt_secs
+from _common import concat_list_line, add_common, aac_args, apply_common, cfr_args, default_output, die, emit, ffmpeg_base, info, parse_time, probe, refuse_output_is_input, require_tool, run, video_args, X264_PRESETS, time_arg, fmt_secs
 from _common.emit import warn
+from _common.decision import av_trim
 
 
 # The loop filter's size is capped at 32767 frames, so one boomerang cycle (2N-2 frames) must fit.
@@ -95,6 +99,21 @@ def _nominal_rate(v) -> str:
     return f"{counted:g}" if 0 < counted <= MAX_PLAUSIBLE_FPS else "30"
 
 
+def concat_first_frame(listfile: str) -> float:
+    """Where the first frame sits on the clock ffmpeg reads a concat list on: the list's first video
+    start minus its start_time. The concat demuxer counts an MP4's hidden AAC priming packet into its
+    start (-0.021 s) where the MP4 demuxer does not, so ffmpeg moves both streams 21 ms later, and a
+    frame-rate time base then rounded the picture's move to 33 ms (12 ms off). 0.0 when unmeasured."""
+    proc = run([require_tool("ffprobe"), "-v", "error", "-f", "concat", "-safe", "0", "-i", listfile,
+                "-select_streams", "v:0", "-show_entries", "stream=start_time:format=start_time", "-of", "json"],
+               quiet=True, check=False)
+    try:
+        doc = json.loads(proc.stdout or "")
+        return float(doc["streams"][0]["start_time"]) - float(doc["format"]["start_time"])
+    except (ValueError, KeyError, IndexError, TypeError):
+        return 0.0
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("input")
@@ -119,6 +138,8 @@ def main() -> int:
     has_audio = bool(meta.get("audio")) and not args.boomerang
     notes = []
     output = args.output or default_output(args.input, "loop")
+    # the concat list is the only -i, so run() never sees the source next to -o (#416 review)
+    refuse_output_is_input(output, args.input)
 
     if args.times is not None:
         if args.times < (1 if args.boomerang else 2):
@@ -137,10 +158,24 @@ def main() -> int:
         if meta.get("audio"):
             notes.append("audio dropped: a boomerang plays half its sound backwards -- add a bed with audio.py")
     else:
-        # -stream_loop repeats the whole input read (video and audio together) at the demuxer level
-        # -- exact and lossless-in-intent for a re-encode target, unlike a filter-graph loop that
-        # would need separate video/audio filters kept in lockstep by hand.
-        cmd = ffmpeg_base() + ["-stream_loop", str(stream_loop), "-i", args.input]
+        # The concat demuxer reads the clip once per repeat and starts each repeat at the previous
+        # one's start plus the file's duration (#409): both streams keep their offset from the
+        # file's start in every repeat. -stream_loop took the repeat's length from its streams'
+        # spans without the last video frame, so a sound that starts 0.3 s late shortened every
+        # repeat by a frame and slid against the picture (346 frames for 360, 68 ms off).
+        # Both streams start at the first frame, shifted by one constant (av_trim), and the gap a
+        # late sound leaves at each repeat's start is filled with silence, at any length.
+        workdir = tempfile.TemporaryDirectory(prefix="ffskill_loop_")
+        listfile = os.path.join(workdir.name, "loop.txt")
+        with open(listfile, "w", encoding="utf-8") as fh:
+            fh.write((concat_list_line(os.path.abspath(args.input)) + "\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]
+        if has_audio:
+            cmd += ["-filter_complex", f"[0:v:0]{vtrim}[v];[0:a:0]{atrim}[a]",
+                    "-map", "[v]", "-map", "[a]"]
+        else:
+            cmd += ["-map", "0:v:0", "-vf", vtrim]
     if target is not None:
         cmd += ["-t", f"{target:.3f}"]
     cmd += video_args(meta, args.crf, args.preset)
@@ -150,7 +185,11 @@ def main() -> int:
     else:
         cmd += ["-an"]
     cmd.append(output)
-    run(cmd)
+    try:
+        run(cmd)
+    finally:
+        if not args.boomerang:
+            workdir.cleanup()
 
     result = probe(output, role="output")
     v = result["video"]

package/scripts/multicam.py

@@ -31,8 +31,10 @@ import math
 import sys
 from typing import Dict, List, Tuple
 
-from _common import guard_sidecar, label_chain, matrix_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 record_fallback, warn
+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.decision import av_trim
+from _common.probe import display_size, square_pixels, square_pixels_note
 from sync import measure_offset
 
 ENERGY_WINDOW_S = 0.25  # --switch energy: loudness measured over this window on the reference timeline
@@ -263,14 +265,16 @@ def main() -> int:
         info(f"wrote {args.edl}")
 
     v0 = metas[0]["video"]
-    w, h = args.width or v0["width"], args.height or v0["height"]
-    if v0.get("rotation") in (90, -90, 270, -270) and not (args.width or args.height):
-        w, h = h, w
+    # 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]
     fps = args.fps or v0.get("fps") or 30.0
     fps = round(fps) if abs(fps - round(fps)) < 0.02 else fps
     pixfmt = "yuv420p10le" if v0.get("bt2020_or_hdr") else "yuv420p"
     geo = f"scale={w}:{h}:force_original_aspect_ratio=decrease,pad={w}:{h}:(ow-iw)/2:(oh-ih)/2,setsar=1,fps={fps:g},format={pixfmt}"
 
+    for p, m in zip(args.inputs, metas):
+        if square_pixels(m.get("video")):
+            note(square_pixels_note(m["video"], p))
     cmd = ffmpeg_base()
     for p in args.inputs:
         cmd += ["-i", p]
@@ -283,6 +287,8 @@ def main() -> int:
     convert = [matrix_chain(m, metas[0]) for m in metas]
     if any(convert):
         convert = [c or label_chain(m, metas[0]) for c, m in zip(convert, metas)]
+    # concat mixes samples: a full-range camera beside a limited one is taken to limited range (#410)
+    convert = [c + range_chain(m, metas[0]) for c, m in zip(convert, metas)]
     # what is actually rendered: a range whose camera has not started yet plays camera 0, and the
     # result says so (`cuts` names the camera on screen, diagnostics.fallbacks the one asked for)
     rendered: List[Tuple[float, float, int]] = []
@@ -296,7 +302,8 @@ def main() -> int:
                             requested_camera=c, camera=0, starts_at=round(offsets[c], 3))
             c, src_s, src_e = 0, s, e
         rendered.append((s, e, c))
-        parts.append(f"[{c}:v]trim=start={src_s:.4f}:end={src_e:.4f},setpts=PTS-STARTPTS,{convert[c]}{geo}[v{i}]")
+        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}]")
         labels.append(f"[v{i}]")
         project_clips.append({"src": args.inputs[c], "in": round(src_s, 3), "out": round(src_e, 3)})
     parts.append("".join(labels) + f"concat=n={len(filled)}:v=1:a=0[vout]")
@@ -306,7 +313,9 @@ def main() -> int:
     # applied before asetrate/aresample rescale that axis -- otherwise the trim lands at the wrong
     # point once the stream's timebase has already been stretched/compressed by the drift ratio
     # (mirrors sync.py, which seeks with -ss, an input-level operation, before its drift_af filters).
-    afx = [f"atrim=start={a_start:.4f}", "asetpts=PTS-STARTPTS"]
+    # shifted by a_start, not to its own first sample: a sound that starts after its file's start
+    # keeps that offset (padded with silence), as the offset was measured on the file's clock (#409)
+    afx = [av_trim(a_start, None)[1]]
     if abs(ratios[a] - 1.0) > 1e-7:
         sr = metas[a]["audio"].get("sample_rate") or 48000
         afx += [f"asetrate={sr * ratios[a]:.6f}", f"aresample={sr}"]

package/scripts/overlay.py

@@ -31,8 +31,11 @@ from typing import 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, matrix_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 warn
+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, 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.probe import display_size, square_pixels, square_pixels_note
+from _common.wrap import wrap_text
+from _common import text_width_em
 from _common.fonts import font_choice, record_font_choice
 from _common import drawtext_fontfile  # noqa: E402
 
@@ -74,6 +77,48 @@ def position_exprs(pos: str, margin: int, text_mode: bool, margins: Optional[dic
     return x, y
 
 
+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.
+    drawtext never wraps, so through 3.1.3 a long line ran off the frame with no word (#411). The
+    width is the averaged advance table's estimate, so a wrapped run says so in its notes."""
+    text = args.text or ""
+    if not (frame_w and text and args.font_size > 0):
+        return text
+    m = {edge: int((margins or {}).get(edge, args.margin)) for edge in ("left", "right")}
+    left, right = m["left"], m["right"]
+    if args.position not in POS:
+        try:
+            xv = int(args.position.split(",")[0])
+            left, right = (xv, right) if xv >= 0 else (0, -xv)
+        except ValueError:
+            pass
+    inset = 2 * args.border + (24 if args.box else 0)  # the border on both sides, boxborderw=12
+    room = frame_w - left - right - inset
+    if room <= args.font_size:
+        # a position this close to the edge leaves no room to wrap in: say the text runs off
+        # rather than draw it past the edge without a word (#416 review)
+        if max(text_width_em(ln) for ln in text.split("\n")) * args.font_size > max(room, 0):
+            note(f"--text does not fit: --position {args.position} leaves {max(room, 0)} px to the frame's edge "
+                 f"at --font-size {args.font_size}, so the text runs past it")
+        return text
+    lines: List[str] = []
+    for para in text.split("\n"):
+        lines.extend(wrap_text(para, room / float(args.font_size), lang=getattr(args, "lang", None),
+                               slice_overlong=True) if para.strip() else [para])
+    wrapped = "\n".join(lines)
+    if wrapped != text:
+        note(f"--text is wider than the frame at --font-size {args.font_size} "
+             f"({frame_w} px, {left}/{right} px margins): wrapped to {len(lines)} lines")
+        # the wrap only measures width: a block taller than the frame loses the lines past its
+        # edge (at a bottom position, the first ones), so that is said too (#416 review)
+        tall = args.font_size + (len(lines) - 1) * int(args.font_size * 1.2)
+        if frame_h and tall > frame_h:
+            note(f"the {len(lines)} wrapped lines are about {tall} px tall, taller than the {frame_h} px frame: "
+                 f"the lines past its edge are not drawn -- lower --font-size or shorten --text")
+    return wrapped
+
+
 def enable_expr(start: Optional[float], end: Optional[float]) -> str:
     if start is None and end is None:
         return ""
@@ -151,7 +196,8 @@ def per_line_drawtext(lines: List[str], x: str, y: str, font_opt: str, args: arg
 _PLACE_TIME = r"[^@\-]+(?:@[0-9.]+)?"
 
 
-def parse_placements(specs: List[str], main_fps: Optional[float], layer_fps: Optional[float]) -> List[tuple]:
+def parse_placements(specs: List[str], main_fps: Optional[float], layer_fps: Optional[float],
+                     layer_meta: Optional[dict] = None, main_meta: Optional[dict] = None) -> List[tuple]:
     """--place SRC_START-SRC_END@AT -> [(src_start, src_end, at)], refusing empty, negative or
     overlapping placements (two pieces on screen at once would stack in an order nobody asked for).
     SRC_START/SRC_END are positions in the layer, so an hh:mm:ss:ff timecode there counts the
@@ -161,9 +207,9 @@ def parse_placements(specs: List[str], main_fps: Optional[float], layer_fps: Opt
         m = re.fullmatch(rf"\s*({_PLACE_TIME})-({_PLACE_TIME})@({_PLACE_TIME})\s*", spec)
         if not m:
             die(f"--place {spec!r}: use SRC_START-SRC_END@AT, e.g. 0-2.5@12 (times are not negative)")
-        a = time_arg(m.group(1), "--place", layer_fps)
-        b = time_arg(m.group(2), "--place", layer_fps)
-        at = time_arg(m.group(3), "--place", main_fps)
+        a = time_arg(m.group(1), "--place", layer_fps, source=layer_meta)
+        b = time_arg(m.group(2), "--place", layer_fps, source=layer_meta)
+        at = time_arg(m.group(3), "--place", main_fps, source=main_meta)
         if b <= a:
             die(f"--place {spec!r}: the layer range ends before it starts")
         out.append((a, b, at))
@@ -304,12 +350,14 @@ def main() -> int:
         die(f"--audio-stream {args.audio_stream}: input has {len(audio_streams)} audio stream(s), 0..{len(audio_streams) - 1}")
     if args.audio_stream and not audio_streams:
         die("--audio-stream needs an input with audio streams")
-    vw = meta["video"]["width"] or 0
-    vh = meta["video"].get("height") or 0
     # ffmpeg applies display rotation before the filter graph, so the frame this overlay is
     # composited on is the displayed one. A 320x180 phone file tagged 90 degrees is 180 wide here.
-    if meta["video"].get("rotation") in (90, -90, 270, -270):
-        vw, vh = vh, vw
+    # A non-square-pixel source is made square at its display aspect first (#411), so a logo or
+    # a line of text is not drawn stretched by the player's SAR.
+    vw, vh = display_size(meta["video"])
+    square = square_pixels(meta["video"])
+    if square:
+        note(square_pixels_note(meta["video"]))
     # --platform: the edges this destination's own UI covers, in pixels of this frame. An
     # explicit --margin (or a brand safe_margin, applied above) is the more specific statement
     # and wins; without either, the historical 24 px default is unchanged.
@@ -377,7 +425,7 @@ def main() -> int:
         # the RGBA still is converted to the BT.709 the output is tagged with (overlay's own
         # RGB-to-YUV step used BT.601), and an untagged main is labelled BT.709 (tags only) so
         # 7.1+'s negotiation does not convert one picture to the other's "unknown" matrix
-        base = label_chain(meta, meta) if rgb_chain_to_bt709(meta) else ""
+        base = layer_base_chain(meta)
         fc = (f"[1:v]{','.join(chain)},setpts=PTS-STARTPTS{rgb_chain_to_bt709(meta)}[ov];"
               + (f"[0:v]{base}null[base];[base]" if base else "[0:v]") + f"[ov]{ov}[out]")
         cmd += ["-filter_complex", fc, "-map", "[out]", "-map", f"0:a:{args.audio_stream}?"]
@@ -398,7 +446,7 @@ def main() -> int:
         if not pip_meta.get("video"):
             die(f"--video {args.video} has no video stream")
         layer_fps = pip_meta["video"].get("fps")
-        placements = parse_placements(args.place, fps, layer_fps) if args.place else []
+        placements = parse_placements(args.place, fps, layer_fps, pip_meta, meta) if args.place else []
         # bounds from the video streams (a longer audio track would let a range run past the last
         # picture); the container duration only when a stream has none
         layer_dur = pip_meta["video"].get("duration") or pip_meta.get("duration")
@@ -415,7 +463,7 @@ def main() -> int:
                 die(f"--place {a:g}-{b:g}@{at:g}: the layer is only {layer_dur:.3f} s long")
             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 = []
+        chain = [square_pixels(pip_meta["video"])] if square_pixels(pip_meta["video"]) else []
         if args.scale_percent:
             chain.append(f"scale={int(vw * args.scale_percent / 100)}:-2")
         elif args.scale:
@@ -436,6 +484,8 @@ def main() -> int:
         base, pip = matrix_chain(meta, meta), matrix_chain(pip_meta, meta)
         if base or pip:
             base, pip = base or label_chain(meta, meta), pip or label_chain(pip_meta, meta)
+        # overlay mixes samples: a full-range picture is taken to limited range (#410)
+        base, pip = base + range_chain(meta, meta), pip + range_chain(pip_meta, meta)
         if placements:
             # each placed piece: its range of the layer, re-timed to start at AT; eof_action=pass shows
             # the main picture untouched once a piece ends (the default would freeze its last frame)
@@ -464,6 +514,7 @@ def main() -> int:
         else:
             cmd += ["-shortest"]
     else:
+        args.text = _wrap_to_frame(args, vw, safe_margins, vh)
         x, y = position_exprs(args.position, args.margin, text_mode=True, margins=safe_margins)
         # 1.15: the text goes in a FILE with expansion off, so `'` and `%` survive verbatim
         # (they used to be dropped by escape_drawtext) and no character can reach the graph parser.
@@ -483,10 +534,13 @@ def main() -> int:
             drawing = "drawtext=" + ":".join(opts)
         # a font/border/box colour with chroma lands in the BT.709 the output is tagged with
         colours = [args.font_color] + ([args.border_color] if args.border else []) + ([args.box_color] if args.box else [])
-        cmd += ["-vf", drawn_chain(drawing, meta, colours), "-map", "0:v:0"]
+        cmd += ["-vf", (square + "," if square else "") + drawn_chain(drawing, meta, colours), "-map", "0:v:0"]
         if meta.get("audio"):
             cmd += ["-map", f"0:a:{args.audio_stream}"]
 
+    if square and "-filter_complex" in cmd:
+        i = cmd.index("-filter_complex") + 1
+        cmd[i] = f"[0:v]{square}[sq];" + cmd[i].replace("[0:v]", "[sq]")
     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"]
     dropped_streams = run_keeping_subtitles(cmd, output)

package/scripts/proxy.py

@@ -26,6 +26,8 @@ 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.emit import note
+from _common.probe import display_size, square_pixels, square_pixels_note
 
 
 def even(n: float) -> int:
@@ -56,15 +58,17 @@ def main() -> int:
     meta = probe(args.input)
     if not meta.get("video"):
         die("input has no video stream")
-    sw, sh = meta["video"]["width"], meta["video"]["height"]
-    if meta["video"].get("rotation") in (90, -90, 270, -270):
-        sw = sh
+    # the displayed width: rotation applied, non-square pixels squared first (#411)
+    sw = display_size(meta["video"])[0]
+    square = square_pixels(meta["video"])
+    if square:
+        note(square_pixels_note(meta["video"]))
     has_audio = bool(meta.get("audio")) and not args.no_audio
 
     out_w = even(sw * args.scale) if args.scale is not None else even(args.width)
     output = args.output or default_output(args.input, "proxy")
 
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", f"scale={out_w}:-2"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", (square + "," if square else "") + f"scale={out_w}:-2"]
     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

@@ -28,6 +28,8 @@ import argparse
 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.emit import note
+from _common.probe import display_size, square_pixels, square_pixels_note
 
 
 def main() -> int:
@@ -67,9 +69,12 @@ def main() -> int:
     meta = probe(args.input)
     if not meta.get("video"):
         die("input has no video stream")
-    sw, sh = meta["video"]["width"], meta["video"]["height"]
-    if meta["video"].get("rotation") in (90, -90, 270, -270):
-        sw, sh = sh, sw
+    # the rectangle is in the displayed frame: rotation applied, and a non-square-pixel source
+    # squared at its display aspect first (#411), the frame look.py and cropdetect.py show
+    sw, sh = display_size(meta["video"])
+    square = square_pixels(meta["video"])
+    if square:
+        note(square_pixels_note(meta["video"]))
     if args.x + args.width > sw or args.y + args.height > sh:
         die(f"redaction rectangle ({args.x},{args.y},{args.width}x{args.height}) exceeds the source frame ({sw}x{sh})")
     if args.mode == "delogo":
@@ -93,7 +98,7 @@ def main() -> int:
     output = args.output or default_output(args.input, "redact")
     if args.mode == "delogo":
         cmd = ffmpeg_base() + ["-i", args.input, "-vf",
-                               f"delogo=x={args.x}:y={args.y}:w={args.width}:h={args.height}",
+                               (square + "," if square else "") + f"delogo=x={args.x}:y={args.y}:w={args.width}:h={args.height}",
                                "-map", "0:v:0"]
     else:
         crop = f"crop={args.width}:{args.height}:{args.x}:{args.y}"
@@ -105,7 +110,7 @@ def main() -> int:
             region = f"{crop},boxblur={radius}:{radius}:{chroma}:{radius}"
         else:
             region = f"{crop},scale={max(1, args.width // args.block_size)}:{max(1, args.height // args.block_size)}:flags=neighbor,scale={args.width}:{args.height}:flags=neighbor"
-        fc = f"[0:v]split=2[base][region];[region]{region}[patched];[base][patched]overlay={args.x}:{args.y}[out]"
+        fc = f"[0:v]{square + ',' if square else ''}split=2[base][region];[region]{region}[patched];[base][patched]overlay={args.x}:{args.y}[out]"
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", fc, "-map", "[out]"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]

package/scripts/reverse.py

@@ -12,10 +12,12 @@ Examples:
   python3 reverse.py input.mp4 --no-audio -o backwards.mp4
 """
 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, video_args, X264_PRESETS, fmt_secs
 from _common.emit import warn
+from _common.decision import av_clip_length, av_trim, frame_durations, frame_rate, stream_starts
 
 
 def main() -> int:
@@ -39,9 +41,32 @@ def main() -> int:
         warn(f"reverse buffers every decoded frame in memory; {meta['duration']:.0f}s of "
              f"{meta['video']['width']}x{meta['video']['height']} can exhaust RAM -- cut the part to reverse first (cut.py)",
              "memory_heavy", duration=meta["duration"])
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", "reverse"]
+    cmd = ffmpeg_base() + ["-i", args.input]
     if has_audio:
-        cmd += ["-af", "areverse"]
+        # Both streams are reversed about one end (#409); each reversed about its own end put a sound
+        # 0.6 s longer than its picture 0.396 s off. As in a join, both start at the first frame (the
+        # sound shifted by the same constant, padded when it starts late) and end together, on the
+        # first frame time at or after the clip's one length (av_clip_length: the picture's, or the
+        # sound's when it runs more than a frame past it). The last frame is held and the sound
+        # padded with silence to that end; the end is a frame time because a copied cut's stated
+        # video length can run past its last frame (7.517 s for frames ending at 7.5). One graph for
+        # both streams, as pad.py's padding needs. areverse keeps its input's timestamps in order,
+        # so the reversed sound is retimed by its samples. The hold (tpad) runs before av_trim's
+        # setpts: from FFmpeg 7.0 setpts leaves its output's frame rate unknown and its frames'
+        # durations 0, so a tpad after it clones nothing (the picture stayed 0.6 s short on 7.1);
+        # the closing fps gives the frames their durations back (frame_durations).
+        rate = frame_rate(meta) or meta["video"].get("fps") or 30.0
+        length = av_clip_length(meta, rate)
+        vlen = meta["video"].get("duration") or length
+        end = math.ceil(length * rate - 1e-6) / rate
+        vtrim, atrim = av_trim(stream_starts(meta)[0], None)
+        cmd += ["-filter_complex",
+                f"[0:v:0]tpad=stop_mode=clone:stop_duration={max(0.0, end - vlen) + 2 / rate:.6f},{vtrim},"
+                f"trim=end={end - 0.5 / rate:.6f},reverse,{frame_durations(meta, rate)}[v];"
+                f"[0:a:0]{atrim},apad=whole_dur={end:.6f},atrim=end={end:.6f},areverse,asetpts=N/SR/TB[a]",
+                "-map", "[v]", "-map", "[a]"]
+    else:
+        cmd += ["-vf", "reverse"]
     cmd += video_args(meta, args.crf, args.preset)
     cmd += cfr_args(meta)
     if has_audio:

package/scripts/scenes.py

@@ -29,6 +29,8 @@ from _common import (guard_sidecar, detect_scenes, STATE, add_common, apply_comm
 from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
+from _common.color import bt709_label_filter  # noqa: E402
+from _common.probe import square_pixels  # noqa: E402
 
 SHOT_FPS = 4.0          # frames/second sampled for --shots' flow estimate
 SHOT_W, SHOT_H = 48, 27  # decode size for --shots (16:9-ish; enough blocks, still a few KB/shot)
@@ -285,9 +287,13 @@ def main() -> int:
         cols = min(4, max(1, n))
         rows = max(1, math.ceil(n / cols))
         tile_w = 1280 // cols // 2 * 2
-        # exactly one frame per scene: the frame index at the scene start
-        fps = meta["video"].get("fps") or 30.0
-        expr = "+".join(f"eq(n\\,{int(round(sc['start'] * fps))})" for sc in scenes)
+        # exactly one frame per scene: the first frame at or after the scene start. The starts are
+        # presentation times, so the frame is chosen by its time, not by start x fps as a frame
+        # number -- on a variable-frame-rate source that number is another frame (#411)
+        def first_at(t: float) -> str:
+            a = f"{max(0.0, t - 0.0006):.4f}"
+            return f"gte(t\\,{a})*(isnan(prev_t)+lt(prev_t\\,{a}))"
+        expr = "+".join(first_at(sc["start"]) for sc in scenes)
         stamp = ""
         if not args.no_timecode and ffmpeg_filters() and "drawtext" not in ffmpeg_filters():
             # as look.py (#394): the sheet needs drawtext only for its stamps
@@ -300,9 +306,14 @@ def main() -> int:
             default_font = default_font_file("DejaVu Sans")
             font_prefix = f"{drawtext_fontfile(default_font)}:" if default_font else ""
             stamp = f",drawtext=text='%{{pts\\:hms}}':{font_prefix}fontcolor=white:fontsize=h/14:box=1:boxcolor=black@0.55:boxborderw=4:x=6:y=6"
-        vf = (f"select='{expr}',scale={tile_w}:-2{stamp},"
+        # an untagged source is labelled BT.709 (tags only), or the sheet's RGB read it as BT.601 (#410);
+        # a non-square-pixel source is squared at its display aspect (#411)
+        lab = bt709_label_filter(meta)
+        square = square_pixels(meta["video"])
+        vf = (f"select='{expr}'," + (lab + "," if lab else "") + (square + "," if square else "")
+              + f"scale={tile_w}:-2{stamp},"
               f"tile={cols}x{rows}:padding=2:margin=2:color=0x202020")
-        run(ffmpeg_base() + ["-i", args.input, "-vf", vf, "-frames:v", "1", "-fps_mode", "vfr", "-update", "1", args.sheet])
+        run(ffmpeg_base() + ["-i", args.input, "-an", "-vf", vf, "-frames:v", "1", "-fps_mode", "vfr", "-update", "1", args.sheet])
         info(f"wrote {args.sheet}")
         result["sheet"] = args.sheet
 

package/scripts/sequence.py

@@ -21,7 +21,8 @@ import tempfile
 from pathlib import Path
 
 from _common import add_common, apply_common, default_output, die, emit, ffmpeg_base, info, probe, run, video_args, X264_PRESETS, concat_list_line, fmt_secs
-from _common.emit import warn
+from _common.emit import note, warn
+from _common.probe import display_size, square_pixels_note
 
 
 def even(n: float) -> int:
@@ -105,7 +106,10 @@ def main() -> int:
     frame_meta = probe(str(frames[0]))
     if not frame_meta.get("video"):
         die(f"{frames[0]} is not a readable image")
-    sw, sh = frame_meta["video"]["width"], frame_meta["video"]["height"]
+    # the displayed frame: an EXIF rotation applied, non-square pixels squared (#411)
+    sw, sh = display_size(frame_meta["video"])
+    if square_pixels_note(frame_meta["video"], "the first frame"):
+        note(square_pixels_note(frame_meta["video"], "the first frame"))
 
     if args.width and args.height:
         out_w, out_h = even(args.width), even(args.height)