ffmpeg-skill 3.1.5 → 3.1.6

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}?"]

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,