ffmpeg-skill 3.1.5 → 3.1.6

package/scripts/_contract.py

@@ -276,7 +276,7 @@ REENCODE_META: Dict[str, Dict[str, str]] = {
     "speedramp": dict(video="always", audio="always", note="setpts/atempo per segment always forces a re-encode of both streams"),
     "broll":    dict(video="always", audio="conditional", note="the overlay graph always re-encodes the video stream; A's audio is stream-copied under --audio a and re-encoded to AAC under --audio b/mix"),
     "metadata": dict(video="never", audio="never", note="-c copy on every stream; only the container's chapters and tags change -- --auto-chapters decodes to measure, but still writes with -c copy"),
-    "loop":     dict(video="always", audio="conditional", note="-stream_loop always re-encodes both streams; the audio codec is always AAC when present. --boomerang re-encodes the video through reverse/loop filters and drops the audio"),
+    "loop":     dict(video="always", audio="conditional", note="the repeats (the concat demuxer, the file listed once per repeat) always re-encode both streams; the audio codec is always AAC when present. --boomerang re-encodes the video through reverse/loop filters and drops the audio"),
     "insert":    dict(video="always", audio="never", note="always encodes a fresh silent clip from the still image; there is no audio stream to touch"),
     "background": dict(video="always", audio="never", note="always encodes a fresh generated clip; there is no input to copy from"),
     "reverse":   dict(video="always", audio="conditional", note="video always re-encodes (reverse buffers and re-emits every frame); audio re-encodes to AAC when present and not dropped by --no-audio"),
@@ -454,7 +454,7 @@ DIAGNOSTIC_CODES = {
     "audit_log_unwritable": ("warnings", "an audit record could not be appended; never fails the run; {path, event, error}"),
     "plan_unbound_inputs": ("warnings", "render.py PLAN: inputs that did not exist when the plan was made, so were not checked; {paths}"),
     # the runner
-    "odd_dimensions_scaled_even": ("fallbacks", "an encode that failed on odd dimensions was run again scaled to even ones (the frame loses a row or column); {output, scale}"),
+    "odd_dimensions_scaled_even": ("fallbacks", "an encode that failed on odd dimensions was run again scaled to even ones, or a graph the retry cannot reach (broll.py's filter_complex) was scaled to even ones up front (the frame loses a row or column); {output, scale}"),
     "measurement_input_pending": ("skipped", "--dry-run: a measurement skipped because its input is an earlier stage's output that does not exist yet; {path}"),
     "non_av_streams_dropped": ("fallbacks", "the subtitle/data streams could not be copied, so the encode ran again without them (dropped_non_av_streams: true); {output, returncode, error: the first attempt's last stderr lines}; export.py adds dropped: the stream types this retry leaves out (data alone first, then subtitle too)"),
     "ffmpeg_list_unreadable": ("warnings", "`ffmpeg -encoders` / `-bsfs` could not be read; what needs the list says so instead of 'the build lacks it'; {list, tool, error}"),

package/scripts/broll.py

@@ -21,7 +21,10 @@ import argparse
 import sys
 from typing import Any, Dict, List
 
-from _common import STATE, add_common, aac_args, apply_common, cfr_args, default_output, die, draws_chroma, drawn_chain, emit, ffmpeg_base, info, time_arg, label_chain, matrix_chain, probe, run, validate_color, video_args, X264_PRESETS, fmt_secs
+from _common.decision import av_trim, frame_rate, grid_at_or_after, stream_starts
+from _common import STATE, add_common, aac_args, apply_common, cfr_args, as_limited, default_output, die, draws_chroma, drawn_chain, emit, ffmpeg_base, info, time_arg, label_chain, matrix_chain, range_chain, probe, run, validate_color, video_args, X264_PRESETS, fmt_secs
+from _common.emit import note, record_fallback
+from _common.probe import display_size, square_pixels, square_pixels_note
 
 
 def main() -> int:
@@ -55,10 +58,20 @@ def main() -> int:
     if not meta_a.get("video"):
         die("A-roll has no video stream")
     dur_a = meta_a.get("duration") or 0.0
-    w, h = meta_a["video"]["width"], meta_a["video"]["height"]
-    # the cutaway is scaled onto the frame ffmpeg has already rotated, not the stored one
-    if meta_a["video"].get("rotation") in (90, -90, 270, -270):
-        w, h = h, w
+    # the cutaway is scaled onto the frame ffmpeg has already rotated, not the stored one, and
+    # onto a non-square-pixel A-roll squared at its display aspect (#411)
+    w, h = display_size(meta_a["video"])
+    a_chain = square_pixels(meta_a["video"])
+    if a_chain:
+        note(square_pixels_note(meta_a["video"], "the A-roll"))
+    if (w % 2 or h % 2) and w and h:
+        # an odd-sized A-roll cannot be encoded 4:2:0 at its own size, and the run-time even-scale
+        # retry does not reach a filter_complex: through 3.1.3 this failed as kind "ffmpeg" (#411)
+        ew, eh = max(2, w - w % 2), max(2, h - h % 2)  # never 0, which scale reads as "keep" (#416 review)
+        record_fallback(f"the A-roll is {w}x{h}, which 4:2:0 cannot hold: scaled to {ew}x{eh}",
+                        "odd_dimensions_scaled_even", output=args.output or default_output(args.input, "broll"), scale=f"scale={ew}:{eh}")
+        a_chain = (a_chain + "," if a_chain else "") + f"scale={ew}:{eh},setsar=1"
+        w, h = ew, eh
     fps = meta_a["video"].get("fps") or 30.0
     has_audio_a = bool(meta_a.get("audio"))
 
@@ -72,13 +85,13 @@ def main() -> int:
         meta_b = probe(path)
         if not meta_b.get("video"):
             die(f"{path} has no video stream")
-        at = time_arg(args.at[i], "--at", fps)
-        start_b = time_arg(per(args.from_, i, "0"), "--from", fps)
+        at = time_arg(args.at[i], "--at", fps, source=meta_a)
+        start_b = time_arg(per(args.from_, i, "0"), "--from", fps, source=meta_b)
         if args.end:
-            end = time_arg(per(args.end, i, "0"), "--end", fps)
+            end = time_arg(per(args.end, i, "0"), "--end", fps, source=meta_a)
             length = end - at
         else:
-            length = time_arg(per(args.duration, i, "4"), "--duration", fps)
+            length = time_arg(per(args.duration, i, "4"), "--duration", fps, source=meta_a)
         if length <= 0:
             die(f"cutaway {i + 1}: length must be > 0 (at {at:g}s, got {length:g}s)")
         if dur_a and at >= dur_a:
@@ -110,16 +123,19 @@ def main() -> int:
     convert = [matrix_chain(m, meta_a) for m in [meta_a] + [c["meta"] for c in cutaways]]
     if any(convert) or draws_chroma([args.pad_color], meta_a):
         convert = [cv or label_chain(m, meta_a) for cv, m in zip(convert, [meta_a] + [c["meta"] for c in cutaways])]
-    if convert[0]:
-        parts.append(f"[0:v]{convert[0]}null[a709]")
+    # overlay mixes samples: a full-range clip over or under a limited one is taken to limited range (#410)
+    convert = [cv + range_chain(m, meta_a) for cv, m in zip(convert, [meta_a] + [c["meta"] for c in cutaways])]
+    if convert[0] or a_chain:
+        parts.append(f"[0:v]{convert[0]}{a_chain or 'null'}[a709]")
         cur = "[a709]"
     pad = f"pad={w}:{h}:(ow-iw)/2:(oh-ih)/2:color="
     for i, c in enumerate(cutaways):
         geo = (f"scale={w}:{h}:force_original_aspect_ratio=decrease,"
-               + drawn_chain(pad + args.pad_color, c["meta"], [args.pad_color], pad + "black", line_meta=meta_a,
+               + drawn_chain(pad + args.pad_color, as_limited(c["meta"]), [args.pad_color], pad + "black", line_meta=meta_a,
                              tag=f"pad{i}", labelled=True))
+        b_sq = (square_pixels(c["meta"]["video"]) + ",") if square_pixels(c["meta"]["video"]) else ""
         parts.append(f"[{i + 1}:v]trim=start={c['from']:.3f}:duration={c['length']:.3f},setpts=PTS-STARTPTS+{c['at']:.3f}/TB,"
-                     f"{convert[i + 1]}{geo},setsar=1,fps={fps:g},format={'yuv420p10le' if (meta_a.get('video') or {}).get('bt2020_or_hdr') else 'yuv420p'}[b{i}]")
+                     f"{convert[i + 1]}{b_sq}{geo},setsar=1,fps={fps:g},format={'yuv420p10le' if (meta_a.get('video') or {}).get('bt2020_or_hdr') else 'yuv420p'}[b{i}]")
         parts.append(f"{cur}[b{i}]overlay=0:0:eof_action=pass:enable='between(t,{c['at']:.3f},{c['at'] + c['length']:.3f})'[v{i}]")
         cur = f"[v{i}]"
     vout = cur
@@ -137,7 +153,12 @@ def main() -> int:
                 parts.append(f"[0:a:0]aformat=sample_rates=48000:channel_layouts=stereo{gate}[a0]")
                 layers.append("[a0]")
             for i, c in enumerate(cutaways):
-                parts.append(f"[{i + 1}:a:0]atrim=start={c['from']:.3f}:duration={c['length']:.3f},asetpts=PTS-STARTPTS,"
+                # B's sound is shifted by the same constant as its picture, whose first frame (the
+                # first at or after --from) lands on --at; rebasing the sound to its own first
+                # sample moved a track that starts 0.3 s late 0.279 s early (#409)
+                v0b = stream_starts(c["meta"])[0]
+                first = max(v0b, grid_at_or_after(c["from"], v0b, frame_rate(c["meta"])))
+                parts.append(f"[{i + 1}:a:0]{av_trim(first, first + c['length'])[1]},"
                              f"aformat=sample_rates=48000:channel_layouts=stereo,adelay={int(c['at'] * 1000)}|{int(c['at'] * 1000)}[ab{i}]")
                 layers.append(f"[ab{i}]")
             parts.append(f"{''.join(layers)}amix=inputs={len(layers)}:normalize=0:dropout_transition=0,atrim=duration={dur_a:.3f}[aout]")

package/scripts/caption.py

@@ -45,7 +45,7 @@ from _platforms import (PLATFORMS, PLATFORM_CHOICES, ASS_SCRIPT_HEIGHT, ass_unit
                         resolve as resolve_platform)
 from _ass_overlay import EMOJI_SENTINEL, emoji_placeholder, ass_escape
 from _common.emit import refuse  # noqa: E402
-from _common import require_filter, emoji_filter_chain, EMOJI_ASSET_HINT, emoji_asset_for, emoji_codepoint_name, emoji_support, resolve_emoji_assets, ADVANCE_EM, LATIN_EM, NO_SPACE_SCRIPTS, _char_em, char_script, text_width_em, emoji_clusters, has_emoji, detect_script, BIDI_SCRIPTS, STATE, brand_states_font, script_font_for_text, signed_time_arg, brand_caption_style, color_hex, drawn_chain, label_chain, load_brand, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, escape_filter_path, ffmpeg_base, fmt_srt_time, fmt_smpte_time, info, MissingFpsError, parse_time, probe, run, x264_args, X264_PRESETS, read_text_or_die, fmt_secs, refuse_existing_outputs, guard_sidecar
+from _common import require_filter, emoji_filter_chain, EMOJI_ASSET_HINT, emoji_asset_for, emoji_codepoint_name, emoji_support, resolve_emoji_assets, ADVANCE_EM, LATIN_EM, NO_SPACE_SCRIPTS, _char_em, char_script, text_width_em, emoji_clusters, has_emoji, detect_script, BIDI_SCRIPTS, STATE, brand_states_font, script_font_for_text, signed_time_arg, brand_caption_style, color_hex, drawn_chain, label_chain, layer_base_chain, load_brand, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, escape_filter_path, ffmpeg_base, fmt_srt_time, fmt_smpte_time, info, MissingFpsError, parse_time, probe, run, x264_args, X264_PRESETS, read_text_or_die, fmt_secs, refuse_existing_outputs, guard_sidecar
 # The line breaker, lifted into _common/text.py in 1.16.0 so graphics.py can use the same rules.
 # The ASR bridge and the SRT reader/writer live in _common.asr since 1.17 (silence.py --filler
 # shares them). They stay caption.py's public names -- every caller and test that reached for
@@ -53,6 +53,7 @@ from _common import require_filter, emoji_filter_chain, EMOJI_ASSET_HINT, emoji_
 from _common import asr as _asr
 from _common.asr import ENGINE_CHOICES
 from _common.emit import warn
+from _common.probe import display_size, square_pixels, square_pixels_note
 from _common.fonts import font_choice, record_font_choice
 from _common import (ASR_INSTALL_HINT, die_no_engine, parse_srt, transcribe, whisper_word_timings,
                      write_srt)
@@ -1139,9 +1140,9 @@ def main() -> int:
 
     play_w = play_h = None
     if meta and meta.get("video"):
-        play_w, play_h = meta["video"]["width"], meta["video"]["height"]
-        if meta["video"].get("rotation") in (90, -90, 270, -270):
-            play_w, play_h = play_h, play_w
+        # the displayed frame: rotation applied, non-square pixels squared (#411) -- the burn
+        # below draws on the square-pixel picture, so a cue is not stretched by the player's SAR
+        play_w, play_h = display_size(meta["video"])
     # A --plan or --dry-run written before the input exists has no geometry to fit against, and a
     # plan that describes a different FontSize from the run that executes it is not a plan. When
     # --platform names a destination, that destination's frame IS the geometry the real run will
@@ -1589,9 +1590,7 @@ def main() -> int:
             args._word_timings = whisper_word_timings(srt_path)
         ass_path = args.write_ass or os.path.splitext(output)[0] + ".ass"
         claim([(ass_path, "ASS")])
-        w, h = meta["video"]["width"], meta["video"]["height"]
-        if meta["video"].get("rotation") in (90, -90, 270, -270):
-            w, h = h, w
+        w, h = display_size(meta["video"])
         if not STATE.dry_run:  # the generated ASS is an artifact of this run: a plan writes nothing
             write_ass(cues_for_ass, ass_path, args, w, h, video=args.input if meta.get("audio") else None)
         info(f"wrote {ass_path} ({len(cues_for_ass)} cues, animate={args.animate}, karaoke={args.karaoke})")
@@ -1681,9 +1680,12 @@ def main() -> int:
         vf = drawn_chain(vf, meta, [args.color, args.outline_color]
                          + ([args.highlight_color, args.upcoming_color] if args.karaoke else []))
 
+    if square_pixels((meta or {}).get("video")):
+        vf = square_pixels(meta["video"]) + "," + vf
+        side_notes.append(square_pixels_note(meta["video"]))
     cmd = ffmpeg_base() + ["-i", args.input]
     chains, emoji_inputs = (emoji_filter_chain(emoji_plan or {}, "vsub", "vout", to_yuv=rgb_chain_to_bt709(meta),
-                                               base_chain=label_chain(meta, meta) if rgb_chain_to_bt709(meta) else "")
+                                               base_chain=layer_base_chain(meta))
                             if emoji_plan else ([], []))
     if chains:
         for spec in emoji_inputs:

package/scripts/color.py

@@ -43,7 +43,7 @@ CORRECTION = {
     "exposure":    (0.0,   -3.0,    3.0,   "stops"),   # exposure filter's own full range (linear-domain stops)
     "contrast":    (1.0,    0.0,    2.0,   "x"),       # eq filter; 0=flat grey, 1=unchanged, 2=double contrast
     "saturation":  (1.0,    0.0,    2.0,   "x"),       # eq filter; 0=grayscale, 1=unchanged, 2=double saturation
-    "temperature": (6500.0, 2000.0, 12000.0, "K"),     # colortemperature filter; 6500=unchanged (its own default)
+    "temperature": (6500.0, 2000.0, 12000.0, "K"),     # colortemperature filter; 6500=unchanged (no term: the filter itself tints at 6500)
     "tint":        (0.0,   -1.0,    1.0,   "x"),       # mapped to colorbalance midtones, see correction_chain()
     "gamma":       (1.0,    0.1,   10.0,   "x"),       # eq filter's own gamma option; 1=unchanged (its own default)
     "lift":        (0.0,   -1.0,    1.0,   "x"),       # colorbalance shadows (rs=gs=bs); 0=unchanged
@@ -116,11 +116,13 @@ def correction_chain(args: argparse.Namespace) -> str:
         die(f"--levels-out-black {out_black} must be less than --levels-out-white {out_white}")
 
     gm, rm, bm = -tint, tint / 2.0, tint / 2.0
-    rgb = [
-        f"exposure=exposure={exposure:g}",
-        f"colortemperature=temperature={temperature:g}",
-        f"colorbalance=rs={lift:g}:gs={lift:g}:bs={lift:g}:rm={rm:g}:gm={gm:g}:bm={bm:g}:rh={gain:g}:gh={gain:g}:bh={gain:g}",
-    ]
+    rgb = [f"exposure=exposure={exposure:g}"]
+    if temperature != CORRECTION["temperature"][0]:
+        # colortemperature at 6500 K is not the identity it is documented as here: it multiplies by
+        # its own approximation of that white point, which tinted grey 808080 to 7E7E7B (#410), so
+        # "unchanged" adds no term at all
+        rgb.append(f"colortemperature=temperature={temperature:g}")
+    rgb.append(f"colorbalance=rs={lift:g}:gs={lift:g}:bs={lift:g}:rm={rm:g}:gm={gm:g}:bm={bm:g}:rh={gain:g}:gh={gain:g}:bh={gain:g}")
     terms = [_rgb_stage(rgb), f"eq=contrast={contrast:g}:saturation={saturation:g}:gamma={gamma:g}"]
     rgb2 = []
     if (in_black, in_white, out_black, out_white) != (0, 255, 0, 255):
@@ -156,6 +158,31 @@ def _rgb_stage(filters: list) -> str:
             + ",scale=out_color_matrix=bt601,format=yuv420p")
 
 
+# swscale's names for the non-BT.709 matrices a --codec prores re-encode keeps (it does not convert)
+_SWS_MATRIX = {"smpte170m": "bt601", "bt470bg": "bt601", "smpte240m": "smpte240m", "fcc": "fcc"}
+
+
+def lut_legs(meta=None) -> "tuple":
+    """(to RGB, back to YUV) around --lut's lut3d: explicit BT.709 conversions through float RGB,
+    the matrix the picture holds when it reaches them (an untagged or BT.709 source as it is, a
+    BT.601 or RGB one after x264_args(source=...)'s conversion), limited range on the way out.
+
+    lut3d takes RGB, and left to libavfilter the way in honoured the frame's BT.709 tag while the
+    way back used swscale's BT.601 default, so even an identity LUT shifted every colour (2FAE4E to
+    249A4B, #410); --correct had its legs pinned for the same reason in #159. A LUT maps the RGB the
+    picture really shows, so unlike --correct's working-space pair (bt601 both ways, see
+    _rgb_stage) these legs use the BT.709 the picture is: an identity LUT then returns every sample
+    as --lut-strength 0, which applies none, does (6.1, BT.709/BT.601/untagged, limited and full
+    range, 8- and 10-bit). The input range is read from the frames, as every scale here reads it."""
+    # --codec prores keeps a BT.601 (or other non-BT.709) source's matrix and tags instead of
+    # converting it (decision.video_args), so the legs use that matrix (#416 review)
+    matrix = "bt709"
+    if STATE.codec == "prores":
+        matrix = _SWS_MATRIX.get(((meta or {}).get("video") or {}).get("color_space"), "bt709")
+    return (f"scale=in_color_matrix={matrix},format=gbrpf32le",
+            f"scale=out_color_matrix={matrix}:out_range=tv,format=yuv420p")
+
+
 def hdr_to_sdr_chain(meta: dict, tonemap: str, peak: float, desat: float) -> str:
     v = meta["video"]
     trc = v.get("color_transfer") or "smpte2084"
@@ -442,6 +469,7 @@ def main() -> int:
         if not (0.0 <= args.lut_strength <= 1.0):
             die(f"--lut-strength {args.lut_strength:g} is outside 0..1")
         lut = f"lut3d=file={escape_filter_path(args.lut)}:interp=tetrahedral"
+        to_rgb, to_yuv = lut_legs(meta)
         if args.lut_strength == 0.0:
             # 0 means "no LUT at all" -- without this branch, 0 (falling outside the open interval
             # below) landed in the same "apply the LUT at full strength" fallback as an out-of-range
@@ -450,9 +478,10 @@ def main() -> int:
             vf = "format=yuv420p"
         elif args.lut_strength < 1.0:
             # blend graded and original
-            vf = f"split[o][g];[g]{lut}[g2];[o][g2]blend=all_mode=normal:all_opacity={args.lut_strength:g},format=yuv420p"
+            # blended in RGB, both pictures through the same two legs
+            vf = f"{to_rgb},split[o][g];[g]{lut}[g2];[o][g2]blend=all_mode=normal:all_opacity={args.lut_strength:g},{to_yuv}"
         else:
-            vf = f"{lut},format=yuv420p"
+            vf = f"{to_rgb},{lut},{to_yuv}"
         output = args.output or default_output(args.input, "lut")
         tag = "lut"
 

package/scripts/crop.py

@@ -22,6 +22,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, video_args, X264_PRESETS, fmt_secs
+from _common.probe import display_size, square_pixels, square_pixels_note
+from _common.emit import note
 
 
 def main() -> int:
@@ -51,15 +53,18 @@ 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 cropdetect.py reports: rotation applied, and a
+    # non-square-pixel source squared at its display aspect first (#411)
+    sw, sh = display_size(meta["video"])
     if args.x + args.width > sw or args.y + args.height > sh:
         die(f"crop rectangle ({args.x},{args.y},{args.width}x{args.height}) exceeds the source frame ({sw}x{sh})")
     has_audio = bool(meta.get("audio"))
 
     output = args.output or default_output(args.input, "crop")
     vf = [f"crop={args.width}:{args.height}:{args.x}:{args.y}", "setsar=1"]
+    if square_pixels(meta["video"]):
+        vf.insert(0, square_pixels(meta["video"]))
+        note(square_pixels_note(meta["video"]))
     cmd = ffmpeg_base() + ["-i", args.input, "-vf", ",".join(vf)]
     cmd += video_args(meta, args.crf, args.preset)
     cmd += cfr_args(meta, args.fps)

package/scripts/cropdetect.py

@@ -34,7 +34,8 @@ from collections import Counter
 from typing import Dict, List, Optional, Tuple
 
 from _common import add_common, apply_common, die, emit, info, print_json, probe, require_tool, run_analysis, decode_gray_frames, frame_flow
-from _common.emit import warn
+from _common.emit import note, warn
+from _common.probe import display_size, square_pixels, square_pixels_note
 
 MOTION_CENTRE_FPS = 2.0
 MOTION_CENTRE_W, MOTION_CENTRE_H = 64, 36
@@ -43,10 +44,11 @@ CROP_RE = re.compile(r"crop=(\d+):(\d+):(\d+):(\d+)")
 
 
 def detect(path: str, seconds: float, samples: int, limit: float, round_to: int, duration: float,
-           failed: "Optional[List[Dict]]" = None) -> List[Tuple[int, int, int, int]]:
+           failed: "Optional[List[Dict]]" = None, square: str = "") -> List[Tuple[int, int, int, int]]:
     """Crop rectangles from `samples` windows spread over the file. A window ffmpeg cannot decode
     is skipped, and appended to `failed` as {start, seconds, error} when the caller passes a list,
-    so the result can say how many of the readings it stands on."""
+    so the result can say how many of the readings it stands on. `square` is the source's
+    square_pixels() scale, run first so the rectangle is in the frame crop.py crops (#411)."""
     ffmpeg = require_tool("ffmpeg")
     per_window = max(0.5, seconds / max(1, samples))
     rects: List[Tuple[int, int, int, int]] = []
@@ -55,7 +57,7 @@ def detect(path: str, seconds: float, samples: int, limit: float, round_to: int,
         start = 0.0 if duration <= 0 else (duration - per_window) * i / max(1, samples - 1) if samples > 1 else 0.0
         start = max(0.0, start)
         cmd = [ffmpeg, "-hide_banner", "-nostdin", "-ss", f"{start:.3f}", "-i", path, "-t", f"{per_window:.3f}",
-               "-vf", f"cropdetect=limit={limit:g}:round={round_to}:reset=1", "-f", "null", "-"]
+               "-vf", (square + "," if square else "") + f"cropdetect=limit={limit:g}:round={round_to}:reset=1", "-f", "null", "-"]
         proc = run_analysis(cmd, check=False)
         if proc.returncode != 0:
             # One window ffmpeg cannot decode (a damaged stretch) is skipped; the other windows
@@ -144,16 +146,18 @@ 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"]
     # cropdetect and the grey decode both see the frame after ffmpeg applies rotation, so the
     # rectangle and the motion points are in that frame. Reporting the stored size made a
-    # 176x320 crop look taller than a 320x180 source.
-    if meta["video"].get("rotation") in (90, -90, 270, -270):
-        sw, sh = sh, sw
+    # 176x320 crop look taller than a 320x180 source. A non-square-pixel source is measured
+    # squared at its display aspect, the frame crop.py then crops (#411).
+    sw, sh = display_size(meta["video"])
+    if square_pixels_note(meta["video"]):
+        note(square_pixels_note(meta["video"]))
     duration = meta.get("duration") or 0.0
 
     failed: List[Dict] = []
-    rects = detect(args.input, args.seconds, args.samples, args.limit, args.round_to, duration, failed)
+    rects = detect(args.input, args.seconds, args.samples, args.limit, args.round_to, duration, failed,
+                   square_pixels(meta["video"]))
     # windows_failed: a window ffmpeg could not decode was skipped without a word, so a
     # crop measured on one window of five read as well-founded as one measured on all five
     result: Dict = {"file": args.input, "source_width": sw, "source_height": sh,

package/scripts/cut.py

@@ -61,6 +61,7 @@ from typing import List, Tuple
 from _common import (beat_grid, snap_points, decode_pcm_mono, rms_envelope, BEAT_MIN_CONFIDENCE)
 from _common import require_tool
 from _common.probe import TS_EXTS, signatures_match, stream_signature
+from _common.decision import grid_at_or_after
 from _common import warn, sibling_temp, source_codec_video_args, STATE, add_common, apply_common, audio_codec_for, emit, aac_args, cfr_args, default_output, die, ffmpeg_base, info, is_audio_output, time_arg, probe, run, X264_PRESETS, keyframes_near, MissingFpsError, concat_list_line, place_output, refuse_output_is_input, fmt_secs, measure_frame_timing, dry_run_input_pending
 
 # outputs whose re-encode dropped a subtitle/data stream (reported as dropped_non_av_streams)
@@ -1013,10 +1014,9 @@ def _fraction_rate(text: str) -> float:
     return float(num) / float(den or 1)
 
 
-def _grid_at_or_after(t: float, v0: float, rate: float) -> float:
-    """The time of the first frame at or after `t` on a constant-rate grid starting at `v0`."""
-    import math
-    return v0 + math.ceil((t - v0) * rate - 1e-6) / rate
+# the first frame at or after t on the source's grid; shared with the tools that cut both streams
+# on one set of bounds (#409)
+_grid_at_or_after = grid_at_or_after
 
 
 def _join_chunk(src: str, segments: List[Tuple[float, float]], dst: str, meta: dict, crf: int, preset: str,

package/scripts/export.py

@@ -38,9 +38,10 @@ import tempfile
 from pathlib import Path
 from typing import Dict, List
 
-from _common import STATE, run_analysis, add_common, apply_common, bt709_matrix_args, bt709_tag_args, child_args, emit, cfr_args, default_output, die, encoder_args, ffmpeg_base, info, probe, require_tool, run, run_tool, validate_color, pad_filters, add_pad_fill_args, fmt_secs
+from _common import STATE, run_analysis, add_common, apply_common, bt709_label_filter, bt709_matrix_args, bt709_tag_args, child_args, emit, cfr_args, default_output, die, encoder_args, ffmpeg_base, info, probe, require_tool, run, run_tool, validate_color, pad_filters, add_pad_fill_args, fmt_secs
 from _common.decision import hw_preset_video, restate_last_swap
 from _common.emit import note, record_fallback, record_skip, warn
+from _common.probe import square_pixels, square_pixels_note
 from check import SPECS as PLATFORMS, measure_loudness
 from _platforms import ALIASES as _ALIASES, PLATFORMS as PLATFORM_TABLE, TP_TOLERANCE_DB, resolve as resolve_platform
 # Frame and duration limit come from the one platform table (scripts/_platforms.py) rather than
@@ -358,6 +359,9 @@ def main() -> int:
     out_ext = Path(output).suffix.lstrip(".").lower()
 
     vf: List[str] = []
+    # A GIF is RGB: an untagged SDR source is labelled BT.709 (tags only) for palettegen's conversion,
+    # which read "unknown" as BT.601 (C03028 came out B31F28, #410); a tagged one is read by its tag
+    gif_label = bt709_label_filter(meta) if args.preset == "gif" else None
     if p["w"] and not args.no_scale:
         if p["h"]:
             if args.fit == "crop":
@@ -370,6 +374,11 @@ def main() -> int:
             vf.append("setsar=1")
         else:
             vf.append(f"scale={p['w']}:-2")
+        # sized in square pixels: a non-square-pixel master is squared at its display aspect
+        # first, or the preset's frame would squash it (#411)
+        if square_pixels(meta["video"]):
+            vf.insert(0, square_pixels(meta["video"]))
+            note(square_pixels_note(meta["video"]))
     if args.repair and args.preset != "copy":
         die("--repair is a remux: use it with --preset copy (a re-encoding preset already rebuilds every frame)")
     if args.max_mb is not None and args.preset == "gif":
@@ -387,7 +396,7 @@ def main() -> int:
         cmd += ["-map", "0:V:0"] + (["-map", "0:a:0"] if has_audio else [])
 
     if args.preset == "gif":
-        chain = ",".join(["fps=12"] + vf) if vf else "fps=12"
+        chain = ",".join(([gif_label] if gif_label else []) + ["fps=12"] + vf)
         fc = f"[0:v]{chain},split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle"
         cmd += ["-filter_complex", fc, "-loop", "0", output]
         run(cmd)

package/scripts/fit.py

@@ -39,7 +39,7 @@ import sys
 from fractions import Fraction
 from typing import List
 
-from _common import video_args, STATE, add_common, apply_common, emit, aac_args, aspect_ratio, cfr_args, default_output, die, ffmpeg_base, info, parse_time, probe, run, run_keeping_subtitles, validate_color, x264_args, pad_filters, add_pad_fill_args, X264_PRESETS, time_arg, fmt_secs, frame_size
+from _common import video_args, STATE, add_common, apply_common, emit, aac_args, aspect_ratio, cfr_args, default_output, die, ffmpeg_base, info, parse_time, probe, run, run_keeping_subtitles, validate_color, x264_args, pad_filters, add_pad_fill_args, X264_PRESETS, time_arg, fmt_secs, frame_size, display_size, square_pixels, square_pixels_note, note
 BLUR_DARKEN = 0.15  # how much --fit blur dims the blurred background copy (eq brightness)
 
 
@@ -125,9 +125,8 @@ def main() -> int:
     if args.audio_stream and not audio_streams:
         die("--audio-stream needs an input with audio streams")
     src_dur = meta["duration"] or 0.0
-    sw, sh = meta["video"]["width"], meta["video"]["height"]
-    if meta["video"].get("rotation") in (90, -90, 270, -270):
-        sw, sh = sh, sw
+    # the displayed frame: rotation applied and non-square pixels squared (#411)
+    sw, sh = display_size(meta["video"])
     if args.rotate in (90, 270):
         sw, sh = sh, sw
     has_audio = bool(meta.get("audio"))
@@ -204,6 +203,11 @@ def main() -> int:
         else:
             vf.append(pad_filters(out_w, out_h, args.pad_fill, args.pad_color, args.pad_blur, meta=meta))
         vf.append("setsar=1")
+        # a non-square-pixel source is made square at its display aspect before anything else
+        # (the size above is computed in that frame), so the fitted picture is not squashed
+        if square_pixels(meta["video"]):
+            vf.insert(0, square_pixels(meta["video"]))
+            note(square_pixels_note(meta["video"]))
 
     if args.fps:
         vf.append(f"fps={args.fps:g}")

package/scripts/freeze.py

@@ -19,6 +19,7 @@ Examples:
 import argparse
 import sys
 
+from _common.decision import av_trim, frame_durations, frame_rate, grid_at_or_after, stream_starts
 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
 
 
@@ -55,14 +56,24 @@ def main() -> int:
     has_audio = bool(meta.get("audio"))
     output = args.output or default_output(args.input, "freeze")
 
-    if args.mode == "extend":
+    # Both streams are cut at the same frame time and shifted by the same constants (#409): the
+    # head runs from the first frame, the tail from the first frame at or after --at. Rebasing each
+    # stream to its own start moved a sound that starts 0.3 s late 0.279 s early, and a picture that
+    # starts 0.1 s late 0.1 s early (147 frames for 150).
+    v0 = stream_starts(meta)[0]
+    rate = frame_rate(meta) or fps
+    cut_at = grid_at_or_after(at, v0, rate)
+    # no frame at or after --at (no --at holds at the clip's end): the insert tail would be empty
+    # and the hold lost, so hold the last frame as --mode extend does (#416 review)
+    vend = v0 + (meta["video"].get("duration") or dur - v0)
+    if args.mode == "extend" or cut_at >= vend - 0.5 / rate:
         # tpad's stop_duration clones the last frame for the given duration; no PTS surgery
         # needed since it only ever appends past the real end.
         vf = f"tpad=stop_mode=clone:stop_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", f"apad=pad_dur={args.hold:.3f}"]
-    elif at == 0:
+    elif at == 0 or cut_at <= v0 + 1e-6:
         # A freeze at the very start has no preceding "head" segment to hold on to (the
         # split/trim/concat approach below needs a non-empty head, which trim=end=0 can't give
         # it -- ffmpeg fails filtering an empty stream). Symmetric to --mode extend at the other
@@ -73,22 +84,39 @@ def main() -> int:
             cmd += ["-map", "0:a:0?", "-af", f"adelay={int(args.hold * 1000)}:all=1"]
     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`, freeze-frame the first
-        # part's last frame for --hold seconds via tpad, concat with the remainder.
+        # resuming the rest of the clip: split the timeline at `at` and hold the remainder's
+        # FIRST frame -- the frame shown at `at` -- for --hold seconds (a segment of its own, below).
+        # Through 3.1.3 the head's last frame was held, the frame before `at`: at a cut, the last
+        # frame of the previous shot (#411).
         n = max(1, round(args.hold * fps))
         # The video hold length is rounded to a whole number of frames (n / fps), but the audio
         # side used to pad by the raw --hold value -- up to half a frame duration off from what
         # the video actually holds for, a permanent A/V drift from this point on. Pad audio by
         # the same, frame-rounded duration the video actually gets.
         actual_hold = n / fps
-        vf = (f"[0:v]split[a][b];[a]trim=end={at:.3f},setpts=PTS-STARTPTS[head];"
-              f"[b]trim=start={at:.3f},setpts=PTS-STARTPTS[tail];"
-              f"[head]tpad=stop_mode=clone:stop={n}[frozen];"
-              f"[frozen][tail]concat=n=2:v=1:a=0[outv]")
+        head_v, head_a = av_trim(v0, cut_at, rate)
+        tail_v, tail_a = av_trim(cut_at, None, rate)
+        # The hold is its own segment: the frame at cut_at, cut on the input's clock and cloned to
+        # n frames there (tpad's stop clone), then shifted like the tail. From FFmpeg 7.0 setpts
+        # leaves its output's frame rate unknown and its frames' durations 0, so the earlier tpad
+        # start clone after av_trim's setpts stamped every clone 0 and the hold was dropped (a 3 s
+        # freeze came out 1.97 s on 7.1). Cloning before setpts and concatenating the hold before
+        # the tail reads the same on every version; the tail's first frame then shows n + 1 times,
+        # as tpad's start clone showed it.
+        # The held frame is the first frame at or after the cut, whatever its time: on a variable
+        # frame rate a nominal one-frame window around cut_at can hold no frame (frames at 0.033
+        # and 0.100, --at 0.06), and the hold was lost (#416 review). A second trim keeps that one
+        # frame; on a constant rate it is the frame at cut_at, as before.
+        half = 0.5 / rate
+        hold_v = (f"trim=start={cut_at - half:.6f},trim=end_frame=1,"
+                  f"tpad=stop_mode=clone:stop={n - 1},setpts=PTS-STARTPTS")
+        vf = (f"[0:v]split=3[a][b][c];[a]{head_v}[head];"
+              f"[b]{hold_v}[hold];[c]{tail_v}[tail];"
+              f"[head][hold][tail]concat=n=3:v=1:a=0,{frame_durations(meta, rate)}[outv]")
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", vf, "-map", "[outv]"]
         if has_audio:
-            af = (f"[0:a]asplit[aa][ab];[aa]atrim=end={at:.3f},asetpts=PTS-STARTPTS[ahead];"
-                  f"[ab]atrim=start={at:.3f},asetpts=PTS-STARTPTS[atail];"
+            af = (f"[0:a]asplit[aa][ab];[aa]{head_a}[ahead];"
+                  f"[ab]{tail_a}[atail];"
                   f"[ahead]apad=pad_dur={actual_hold:.6f}[afrozen];"
                   f"[afrozen][atail]concat=n=2:v=0:a=1[outa]")
             cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", f"{vf};{af}", "-map", "[outv]", "-map", "[outa]"]