ffmpeg-skill 3.1.4 → 3.1.6

package/scripts/overlay.py

@@ -30,8 +30,12 @@ import sys
 from typing import List, Optional
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, safe_margins_px, resolve as resolve_platform
-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 still_input_args  # noqa: E402
+from _common import STATE, script_font_for_text, drawtext_clean, drawtext_line_metrics, drawtext_text_opts, drawtext_draws_newline_glyph, is_multiline, needs_shaping, LANGUAGE_NAMES, has_emoji, detect_script, emoji_clusters, load_brand, drawn_chain, label_chain, layer_base_chain, matrix_chain, 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
 
@@ -73,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 ""
@@ -150,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
@@ -160,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))
@@ -303,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.
@@ -372,11 +421,11 @@ def main() -> int:
         if enable:
             ov += f":enable='{enable}'"
         # -loop 1 turns the still into a timed stream so fade/enable expressions see real timestamps
-        cmd = ffmpeg_base() + ["-i", args.input, "-loop", "1", "-i", args.image]
+        cmd = ffmpeg_base() + ["-i", args.input, "-loop", "1", *still_input_args(args.image), "-i", args.image]
         # the RGBA still is converted to the BT.709 the output is tagged with (overlay's own
         # 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}?"]
@@ -397,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")
@@ -414,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:
@@ -435,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)
@@ -463,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.
@@ -482,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/render.py

@@ -342,6 +342,11 @@ def render_pack(names: List[str], args) -> int:
     and platform check), so the pack reports per-platform results rather than one verdict."""
     stem = Path(args.input).with_suffix("").name
     outdir = Path(args.output).parent if args.output else Path(args.input).resolve().parent
+    # the table is a file this run writes itself (#408): an existing one is refused without
+    # --overwrite, before the first destination renders
+    if outdir.is_dir():  # a missing folder is the destinations' own refusal (and a dry run's plan)
+        side = [v for k, v in vars(args).items() if k != "output" and isinstance(v, str) and os.path.isfile(v)]
+        guard_sidecar(str(outdir / f"{stem}_pack.md"), args.input, *side)
     dests = {name: str((load_template(name).get("check") or {}).get("platform") or name) for name in names}
     rows: List[Dict[str, Any]] = []
     outputs: List[str] = []
@@ -399,6 +404,9 @@ def render_pack(names: List[str], args) -> int:
     lines += ["", f"{len(rows)} destinations from one edit ({os.path.basename(args.input)}).",
               "Rendered by ffmpeg-skill; `report.py --pack` turns this table into an HTML report."]
     if not STATE.dry_run:
+        if not outdir.is_dir():
+            die(f"pack: the output folder {outdir} does not exist, so the table was not written", kind="input",
+                pack=rows, outputs=outputs)
         Path(pack).write_text("\n".join(lines) + "\n", encoding="utf-8")
     info(("[dry-run] would write " if STATE.dry_run else "wrote ") + pack)
     if failed:

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", 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
 
 
 
@@ -97,16 +100,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),
@@ -502,7 +527,11 @@ def main() -> int:
     # 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)
+    # 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
@@ -512,11 +541,11 @@ def main() -> int:
     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_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 +601,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 +633,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 +647,28 @@ 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")
 
     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}?"]