ffmpeg-skill 3.1.5 → 3.1.7

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)

package/scripts/silence.py

@@ -3,7 +3,8 @@
 
 Detects quiet stretches with ffmpeg's silencedetect, keeps a margin on each
 side so words are not clipped, drops gaps shorter than --min-silence, and
-writes a frame-accurate re-encode in one pass (select, and ametadata for the sound).
+writes a frame-accurate re-encode: the kept ranges are re-cut from the source the way
+cut.py --segments --accurate cuts them (both streams on one set of frame-grid bounds).
 
 Examples:
   python3 silence.py talk.mp4                                 # -35 dB, gaps >= 0.6 s, 0.2 s margin
@@ -13,6 +14,7 @@ Examples:
 """
 import argparse
 import json
+import math
 import os
 import sys
 from typing import Any, Dict, List, Optional, Tuple
@@ -25,7 +27,8 @@ from _common import asr as _asr
 from _common.emit import warn
 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, video_args, add_common, apply_common, audio_codec_for, cfr_args, default_output, die, emit, ffmpeg_base, info, is_audio_output, print_json, probe, run, X264_PRESETS, measured_level_dbfs, fmt_secs
+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
+from _common.decision import frame_rate, stream_starts
 
 
 
@@ -80,10 +83,29 @@ def speech_aware_silences(path: str, threshold: float, min_silence: float) -> "T
     return boundaries, breaths
 
 
+def inside_margin(silences: List[Tuple[float, float]], duration: float, margin: float) -> List[Tuple[float, float]]:
+    """Each silence with --margin kept on both sides: the stretch actually removed. A silence too
+    short to hold two margins removes nothing (it is dropped, never turned inside out).
+
+    The margin is applied to the silences alone, before they are merged with filler spans (#414):
+    a filler word's span is the word itself plus --filler-pad, and taking a 0.2 s margin off each
+    side of it turned every word narrower than 2 x --margin inside out -- kept, and still counted
+    as removed."""
+    out: List[Tuple[float, float]] = []
+    for s, e in silences:
+        a = s + margin
+        b = duration if e == float("inf") else min(duration, e - margin)
+        if b > a:
+            out.append((a, b))
+    return out
+
+
 def keep_ranges(silences: List[Tuple[float, float]], duration: float, margin: float, min_keep: float) -> List[Tuple[float, float]]:
     keeps: List[Tuple[float, float]] = []
     cursor = 0.0
     for s, e in sorted(silences):
+        if e != float("inf") and e - margin <= s + margin:
+            continue  # narrower than two margins: nothing of it is removed (#414)
         s_adj = max(cursor, s + margin)
         if s_adj - cursor >= min_keep:
             keeps.append((cursor, s_adj))
@@ -97,16 +119,38 @@ def keep_ranges(silences: List[Tuple[float, float]], duration: float, margin: fl
     return keeps
 
 
+def rendered_ranges(keeps: List[Tuple[float, float]], meta: Dict[str, Any], duration: float,
+                    video_out: bool) -> List[Tuple[float, float]]:
+    """The source ranges the render holds, and is given: with a picture, each bound moves to the
+    nearest frame time, for the sound too, so cut.py's re-cut (which cuts at the first frame at or
+    after a bound) cuts exactly there. A measured bound sits a few microseconds off a frame
+    (silencedetect's 4.00002), which "at or after" would have turned into a whole frame dropped.
+    Sound alone is cut where asked. --timemap is built from these, so its times are the output's."""
+    rate = frame_rate(meta) if video_out else 0.0
+    if not rate:
+        return list(keeps)
+    v0 = stream_starts(meta)[0]
+
+    def snap(t: float) -> float:
+        return min(v0 + round((t - v0) * rate) / rate, duration)
+    return [(a, b) for a, b in ((snap(s), snap(e)) for s, e in keeps) if b > a]
+
+
+def _edl_time(t: float, on_frames: bool) -> str:
+    """An EDL bound: a frame time truncated to the millisecond (below 1000 fps the frame at or
+    after it is still that frame), any other time rounded as before."""
+    return f"{math.floor(t * 1000 + 1e-6) / 1000:.3f}" if on_frames else f"{t:.3f}"
+
+
 def time_map(keeps: List[Tuple[float, float]], duration: float) -> Dict[str, Any]:
     """Each kept range with its time in the source and in the output, and each removed range with
-    the output time it was cut at: re-timing subtitles, or finding a removed sentence again."""
+    the output time it was cut at: re-timing subtitles, or finding a removed sentence again.
+    `keeps` are the ranges the render holds (rendered_ranges): the output advances by each one's
+    exact length, rounded only for display."""
     kept: List[Dict[str, float]] = []
     removed: List[Dict[str, float]] = []
     out, prev = 0.0, 0.0
     for s, e in keeps:
-        # the render cuts on bounds rounded to the millisecond (between(t,s,e) below): advance by
-        # that rounded length, or every off-grid range adds its own error to every later time
-        s, e = round(s, 3), round(e, 3)
         if s - prev > 0.0005:
             removed.append({"source_start": round(prev, 3), "source_end": round(s, 3), "output_time": round(out, 3)})
         kept.append({"source_start": round(s, 3), "source_end": round(e, 3),
@@ -478,6 +522,9 @@ def main() -> int:
     media_out = None if (args.list or args.filler_list) else (args.output or default_output(args.input, "tight"))
     guard_sidecar(args.edl, args.input, args.words, args.filler_words, siblings=(media_out,))
 
+    if not math.isfinite(args.margin) or args.margin < 0:
+        # nan made inside_margin() drop every silence and re-encode the whole file unchanged
+        die(f"--margin must be a finite number of seconds, 0 or more (got {args.margin:g})", kind="input")
     if args.filler_pad < 0:
         die("--filler-pad cannot be negative: a negative pad turns each word's span inside out "
             "(end before start) and the span is then silently dropped, so nothing is removed",
@@ -500,9 +547,15 @@ def main() -> int:
     filler_info, filler_ranges = resolve_filler(args, meta) if args.filler else (None, [])
     # One sorted, merged removal list through the graph the tool already has: filler removal IS
     # time-range removal, so it reuses keep_ranges() and the same select chain.
-    removals = merge_spans(list(silences) + list(filler_ranges))
-    keeps = keep_ranges(removals, duration, args.margin, args.min_keep)
-    kept = sum(e - s for s, e in keeps)
+    # --margin is kept around the silences only (inside_margin), not around filler spans, whose
+    # own trim is --filler-pad (#414); the merged list then goes through with no further margin.
+    removals = merge_spans(inside_margin(silences, duration, args.margin) + list(filler_ranges))
+    keeps = keep_ranges(removals, duration, 0.0, args.min_keep)
+    # what the render holds (on a picture, each bound on its nearest frame): the report, the EDL
+    # and the time map all describe these, so a re-cut or a sum of `keep` is the rendered edit
+    video_out = bool(meta.get("video")) and not (media_out and is_audio_output(media_out))
+    held = rendered_ranges(keeps, meta, duration, video_out)
+    kept = sum(e - s for s, e in held)
     removed = max(0.0, duration - kept)
     # `removed_seconds` keeps the meaning it has had since this tool existed: the seconds of
     # SILENCE this run removes. It must not quietly start counting filler time as well, because a
@@ -511,12 +564,12 @@ def main() -> int:
     # the silences alone; everything removed is `removed_seconds_total`.
     silence_only = removed
     if args.filler:
-        silence_keeps = keep_ranges(merge_spans(list(silences)), duration, args.margin, args.min_keep)
-        silence_only = max(0.0, duration - sum(e - s for s, e in silence_keeps))
+        silence_keeps = keep_ranges(merge_spans(inside_margin(silences, duration, args.margin)), duration, 0.0, args.min_keep)
+        silence_only = max(0.0, duration - sum(e - s for s, e in rendered_ranges(silence_keeps, meta, duration, video_out)))
     kinds = silence_kinds(args.input, silences, duration, args.threshold)
     summary = {
         "silences": [[round(s, 3), None if e == float("inf") else round(e, 3)] for s, e in silences],
-        "keep": [[round(s, 3), round(e, 3)] for s, e in keeps],
+        "keep": [[round(s, 3), round(e, 3)] for s, e in held],
         "input_duration": round(duration, 3),
         "kept_duration": round(kept, 3),
         "removed_seconds": round(silence_only, 3),
@@ -572,7 +625,7 @@ def main() -> int:
             summary["hint"] = f"no passage sits below {args.threshold:g} dBFS for {args.min_silence:g}s; try a higher --threshold (e.g. -25) or a shorter --min-silence"
         info("hint: " + summary["hint"])
 
-    tm = time_map(keeps, duration)
+    tm = time_map(held, duration)
     points: Any = False  # False: not measured (a dry run over a pending input); None: the decode failed
     if not (STATE.dry_run and not os.path.exists(args.input)):
         points = cut_levels(args.input, tm, duration, list(filler_ranges))
@@ -604,8 +657,11 @@ def main() -> int:
     if args.edl:
         if not STATE.dry_run:  # the EDL is an artifact like the cut itself: a plan writes nothing
             with open(args.edl, "w", encoding="utf-8") as fh:
-                for s, e in keeps:
-                    fh.write(f"{s:.3f}-{e:.3f}\n")
+                on_frames = bool(video_out and frame_rate(meta))
+                for s, e in held:
+                    # a frame-time bound is written down to the millisecond, not rounded up past
+                    # its frame: cut.py --segments cuts at the first frame at or after it (#416 review)
+                    fh.write(f"{_edl_time(s, on_frames)}-{_edl_time(e, on_frames)}\n")
         info(f"wrote {args.edl}")
 
     if args.list or args.filler_list:
@@ -615,29 +671,29 @@ def main() -> int:
         else:
             print_json(summary)
         return 0
-    if not keeps:
+    if not keeps or not held:
         die("nothing would be kept; raise --threshold (e.g. -45) or check the audio")
-    if not silences or removed < 0.05:
-        info("no removable silence found; output would equal the input")
+    if removed < 0.05:
+        # what the render removes, filler spans included: --filler alone has no silences at all
+        info(f"no removable {'filler' if filler_only else 'silence or filler' if args.filler else 'silence'} found; output would equal the input")
 
     output = args.output or default_output(args.input, "tight")
-    expr = "+".join(f"between(t,{s:.3f},{e:.3f})" for s, e in keeps)
-    vf = f"select='{expr}',setpts=N/FRAME_RATE/TB"
-    # Not `aselect='{expr}'`: FFmpeg 8.0 and 8.0.1 (Ubuntu 26.04's apt build) ship an aselect that
-    # passes every frame through (its activate callback was lost when the filter was converted;
-    # fixed in 8.0.2/8.1), which cut the picture and left the sound whole. Tagging the frames the
-    # expression keeps (timeline `enable`, the same per-frame t) and selecting the tagged ones keeps
-    # exactly the frames aselect keeps, on every release, in a command no longer than before.
-    af = (f"ametadata=mode=add:key=ffskill_keep:value=1:enable='{expr}',"
-          "ametadata=mode=select:key=ffskill_keep,asetpts=N/SR/TB")
-    cmd = ffmpeg_base() + ["-i", args.input]
-    audio_only = is_audio_output(output) or not meta.get("video")
-    if audio_only:
-        cmd += ["-vn"]
-    else:
-        cmd += ["-vf", vf] + video_args(meta, args.crf, args.preset) + cfr_args(meta)
-    cmd += ["-af", af] + audio_codec_for(output) + [output]
-    run(cmd)
+    # the join of more than 32 ranges concats a list of chunks, so its last command never names the
+    # source and run()'s own check cannot see -o replace it (#416 review)
+    refuse_output_is_input(output, args.input)
+    # The kept ranges are re-cut from the source as cut.py --segments --accurate cuts them (#409):
+    # each range is its own seeked input, both streams cut on the same frame-grid bounds and shifted
+    # by one constant, the sound padded to the range's origin, at most 32 ranges per ffmpeg call.
+    # The one-pass select/ametadata graph this replaced rounded every range twice, the picture to
+    # whole frames and the sound to whole AAC frames, and the errors added up (150 ms over 21 ranges
+    # on a 61 s source); its asetpts=N/SR also moved a sound that starts late by its whole offset.
+    # No declick fade: the joins sit in the --margin the tool keeps, as they always have.
+    # imported here, not at the top: the contract and MCP load every tool's parser on its own
+    import cut as _cut
+    _cut.DECLICK_S = 0.0
+    import tempfile
+    with tempfile.TemporaryDirectory(prefix="ffskill_silence_") as tmp:
+        _cut.join_from_source(args.input, held, output, meta, args.crf, args.preset, tmp)
     r = probe(output, role="output")
     info(f"wrote {output} ({fmt_secs(r['duration'])}, expected ~{kept:.3f}s)")
     finish_time_map()

package/scripts/speedramp.py

@@ -19,6 +19,7 @@ import argparse
 import sys
 from typing import List, Tuple
 
+from _common.decision import av_trim, 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
 
 MAX_SPEED = 20.0
@@ -89,15 +90,26 @@ def main() -> int:
     # the last factor. The end bound is omitted only when the stated end is the file's end
     # (within 50 ms): a trim a few milliseconds short of the last packet drops that packet.
     last_runs_to_eof = abs(segments[-1][1] - dur) <= 0.05
+    # Every boundary is a frame time and both streams of a segment are cut on it and shifted by the
+    # same constant before the speed change (#409), as cut.py's re-cut does. Rebasing each stream
+    # of each segment to its own first sample moved a sound that starts 0.3 s late 0.3 s early, and
+    # 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)
+    bounds = [v0] + [grid_at_or_after(end, v0, rate) for _, end, _ in segments[:-1]]
     for i, (start, end, factor) in enumerate(segments):
         vlabel, alabel = f"v{i}", f"a{i}"
-        end_expr = f"{end:.3f}" if not (i == len(segments) - 1 and last_runs_to_eof) else None
-        trim = f"trim=start={start:.3f}" + (f":end={end_expr}" if end_expr else "")
-        vparts.append(f"[0:v]{trim},setpts=(PTS-STARTPTS)/{factor:.6f}[{vlabel}]")
+        to_eof = i == len(segments) - 1 and last_runs_to_eof
+        seg_end = None if to_eof else (bounds[i + 1] if i + 1 < len(bounds) else grid_at_or_after(end, v0, rate))
+        if seg_end is not None and seg_end <= bounds[i] + 1e-6:
+            # both ends on the same frame: the trims would be empty and the factor reach no frame
+            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)
+        vparts.append(f"[0:v]{vtrim},setpts=PTS/{factor:.6f}[{vlabel}]")
         labels.append(f"[{vlabel}]")
         if has_audio:
-            atrim = f"atrim=start={start:.3f}" + (f":end={end_expr}" if end_expr else "")
-            aparts.append(f"[0:a]{atrim},asetpts=PTS-STARTPTS,{atempo_chain(factor)}[{alabel}]")
+            aparts.append(f"[0:a]{atrim},{atempo_chain(factor)}[{alabel}]")
 
     if has_audio:
         concat_inputs = "".join(f"[v{i}][a{i}]" for i in range(len(segments)))

package/scripts/straighten.py

@@ -23,6 +23,8 @@ 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.emit import note
+from _common.probe import display_size, square_pixels, square_pixels_note
 
 
 def main() -> int:
@@ -68,15 +70,25 @@ def main() -> int:
         rotate = drawn_chain(f"rotate={radians:.8f}:fillcolor={args.fill_color}:{geometry}", meta, [args.fill_color],
                              f"rotate={radians:.8f}:fillcolor=black:{geometry}")
     else:
-        # Pre-scale the frame up by a safe, conservative factor (|cos|+|sin|, the exact growth
-        # factor for a square, over-generous for a rectangle) so the rotated content fully
-        # covers the original W:H window with no black corner, then rotate in place (canvas
-        # stays at the scaled size) and crop back down to the original W:H, centred.
-        s = abs(math.cos(radians)) + abs(math.sin(radians))
+        # Pre-scale the frame up so the rotated content fully covers the original W:H window with
+        # no black corner, then rotate in place (canvas stays at the scaled size) and crop back
+        # down to the original W:H, centred. The window turned back by the angle must fit inside
+        # the scaled frame: W*cos + H*sin <= s*W and W*sin + H*cos <= s*H, so
+        # s = |cos| + max(W/H, H/W) * |sin| for the displayed (squared, upright) frame. Through
+        # 3.1.5 it was |cos| + |sin|, a square's factor, which left two corners black on 16:9
+        # (#416 review).
+        dw, dh = display_size(meta["video"])
+        aspect = max(dw / dh, dh / dw) if dw and dh else 1.0
+        s = abs(math.cos(radians)) + aspect * abs(math.sin(radians))
         # crop dimensions must round down to even (4:2:0 chroma); trunc(.../2)*2 floors to the
         # nearest even value instead of leaving an odd width/height that the encoder would refuse.
         rotate = f"scale=iw*{s:.8f}:ih*{s:.8f},rotate={radians:.8f},crop=trunc(iw/{s:.8f}/2)*2:trunc(ih/{s:.8f}/2)*2"
 
+    # a rotation of non-square pixels is a shear on screen: the picture is squared at its
+    # display aspect first (#411)
+    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"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]

package/scripts/sync.py

@@ -34,6 +34,7 @@ from typing import Dict, List
 
 from _common import video_args, add_common, apply_common, emit, aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, x264_args, decode_pcm_mono, rms_envelope
 from _common.emit import record_skip, warn
+from _common.decision import stream_starts
 
 SR = 8000  # decode sample rate
 
@@ -355,6 +356,11 @@ def main() -> int:
         if abs(drift_ratio - 1.0) > 1e-7:
             # the second file runs long by drift_ratio -> play it faster by that ratio (pitch shift is ~ppm, inaudible)
             drift_af = [f"asetrate={sec_sr * drift_ratio:.6f}", f"aresample={sec_sr}"]
+        # the offset is measured between the files' clocks (decode_pcm_mono pads a late sound), so
+        # the second's sound is placed on its own clock first: one that starts 0.3 s after its
+        # file's start keeps that 0.3 s instead of being delayed from its first sample (#409).
+        # Only then, so the command for an ordinary file is the one it always was.
+        on_clock = ["aresample=async=1:first_pts=0"] if stream_starts(second_meta)[1] > 0.0005 else []
 
         if args.replace_audio:
             cmd = ffmpeg_base() + ["-i", args.reference]
@@ -367,7 +373,7 @@ def main() -> int:
             # its length instead of -shortest, which cut the reference's tail whenever the second
             # file started earlier (head_trim > 0) or was simply shorter
             ref_dur = probe(args.reference).get("duration")
-            af_parts = drift_af + ([f"adelay={delay_ms}:all=1"] if delay_ms > 0 else []) + ["apad"]
+            af_parts = on_clock + drift_af + ([f"adelay={delay_ms}:all=1"] if delay_ms > 0 else []) + ["apad"]
             cmd += ["-af", ",".join(af_parts)]
             cmd += aac_args() + (["-t", f"{ref_dur:.3f}"] if ref_dur else ["-shortest"]) + [output]
             proc = run(cmd, check=False)
@@ -391,7 +397,7 @@ def main() -> int:
                 if head_trim > 0:
                     cmd += ["-ss", f"{head_trim:.4f}"]
                 cmd += ["-i", args.second]
-                af_parts = list(drift_af)
+                af_parts = on_clock + drift_af
                 if delay_ms > 0:
                     af_parts.append(f"adelay={delay_ms}:all=1")
                 if has_video:

package/scripts/waveform.py

@@ -35,12 +35,12 @@ import os
 import sys
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, resolve as resolve_platform
-from _common.probe import SILENT_PEAK_DBFS
+from _common.probe import SILENT_PEAK_DBFS, square_pixels, square_pixels_note
 from _common import still_input_args  # noqa: E402
 from _common import (add_common, apply_common, aac_args, default_output, die, draws_chroma, emit, ffmpeg_base,
                      info, load_brand, pad_filters, probe, rgb_chain_to_bt709, run, STATE, validate_color, video_args, X264_PRESETS,
                      fmt_secs, child_args, run_tool, measured_level_dbfs, sibling_temp)
-from _common.emit import absorb_stage_hw, warn
+from _common.emit import absorb_stage_hw, note, warn
 
 WAVEFORM_MODES = ["point", "line", "p2p", "cline"]
 
@@ -184,7 +184,12 @@ def main() -> int:
             plate = pad_filters(args.width, args.height,
                                 "blur" if args.image_fit == "blur" else "color",
                                 args.background, 20)
-        graph = f"[1:v]{plate},format=rgba[plate];[0:a:{args.audio_stream}]{vf},format=rgba"
+        # a non-square-pixel still is squared at its display aspect before it is fitted (#411)
+        plate_v = probe(args.image, role="input").get("video") if not STATE.dry_run else None
+        plate_sq = square_pixels(plate_v)
+        if plate_sq:
+            note(square_pixels_note(plate_v, "--image"))
+        graph = f"[1:v]{plate_sq + ',' if plate_sq else ''}{plate},format=rgba[plate];[0:a:{args.audio_stream}]{vf},format=rgba"
         if args.opacity < 1.0:
             graph += f",colorchannelmixer=aa={args.opacity:g}"
         # the composite is RGBA (the plate is): converted to the BT.709 the output is tagged with,