ffmpeg-skill 3.8.14 → 3.8.16

package/docs/contract.md

@@ -26,7 +26,7 @@ The contract is derived from the code that runs, not maintained beside it:
 | Field | Meaning | Changes when |
 |---|---|---|
 | `contract_version` | shape of this document (`2.0`) | a key is renamed, removed or changes meaning |
-| `skill.version` | the npm / package.json version (`3.8.14`) | any release |
+| `skill.version` | the npm / package.json version (`3.8.16`) | any release |
 
 A release that adds a tool or a flag keeps `contract_version`; a breaking change to the
 ToolSpec shape bumps it. Consumers pin on `contract_version` and read `skill.version`
@@ -154,7 +154,7 @@ JSON would have been rewritten for that. The flat keys, typed per tool in `outpu
   "deprecated": [],
   "removed": [{"what": "...", "since": "1.10.0", "replacement": "...", "removed_in": "2.0.0", "where": "cli | json | mcp | behaviour"},
               {"what": "running on FFmpeg 5.x (the requirements.ffmpeg floor)", "since": "2.14.0", "replacement": "FFmpeg 6.1 or later; ...", "removed_in": "3.0.0", "where": "behaviour"}],
-  "skill": {"id": "ffmpeg-skill", "version": "3.8.14", "execution_mode": "local", "kind": "execution",
+  "skill": {"id": "ffmpeg-skill", "version": "3.8.16", "execution_mode": "local", "kind": "execution",
             "entrypoints": {"cli": "...", "mcp": "...", "contract": "...", "doctor": "..."},
             "not_provided": ["AI reasoning", "decisions", "production plans", "project IR", "approvals", "network access", "transcription engine"]},
   "requirements": {"python": ">=3.10 (standard library only)", "ffmpeg": ">=6.1", "ffprobe": ">=6.1"},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ffmpeg-skill",
-  "version": "3.8.14",
+  "version": "3.8.16",
   "mcpName": "io.github.kajisho5/ffmpeg-skill",
   "description": "Agent Skill that gives coding agents (Claude Code, Cursor, Codex) a local video editor: 42 FFmpeg tools with a machine-readable contract, contract-derived MCP server, FFmpeg capability detection, probe-first / verify-last workflow. Cut, join, silence removal, fit, captions and karaoke, overlays, motion graphics, HDR to SDR, LUTs, audio clean-up and typed dynamics, sync with drift correction, multicam, loudness, delivery checks, project rendering, batch. No API keys, no cloud, no dependencies.",
   "keywords": [

package/references/gotchas.md

@@ -117,8 +117,18 @@ wrong frame — respect the automatic re-encode rather than forcing the copy.
 
 ### Variable frame rate
 `probe.py` sets `variable_frame_rate_suspected` when `r_frame_rate` and
-`avg_frame_rate` disagree (phone and screen recordings). Every re-encoding
-script then adds `-fps_mode cfr` at the source's average rate. That flag is a
+`avg_frame_rate` disagree (phone and screen recordings). On that flag `crop`, `denoise`,
+`deinterlace`, `proxy`, `sphere`, `stabilize`, `straighten`, `redact`, `overlay`, `caption`,
+`color`, `graphics`, `pad`, `freeze`, `loop`, `broll`, `cut` (a re-encode, `--segments`),
+`export`, `fit` and `speedramp` conform the picture with the `fps` filter (the nearest frame
+for each slot; `-fps_mode cfr` alone let a frame run up to two frames late against the sound,
+#512); `join`, `multicam` and `grid` put each input on the output's rate with their own `fps`
+filter. `reverse.py` is not changed: its `fps` filter comes after `reverse`, which hands the frames
+the forward timestamps in order, so a reversed VFR picture keeps its gaps where they were in
+forward time (each flash 0.19 s late on
+a 27 fps average clip; see docs/design-decisions.md). The rate is `cfr_args()`'s: the probed
+average, written as the nearest whole number when it is within 0.02 of one (29.98 is
+conformed to 30, 29.97 stays 29.97), and 30 when no average was probed. That flag is a
 whole-file average, and a phone clip at 29.98 against a nominal 30 trips it, so
 `cut.py` decides on packet timestamps sampled in up to five windows (`vfr_check`)
 instead: by default (`--vfr-guard sampled`, since 3.0.0) it switches to

package/scripts/_common/__init__.py

@@ -83,7 +83,7 @@ from _common.decision import (
     BEAT_REFRACTORY_S, BEAT_WINDOW_S, BEAT_SUPPORT_DIVISOR, BEAT_ALIGN_DIVISOR,
     BEAT_Z_FLOOR, BEAT_Z_SPAN,
     _onset_strength, _pick_onsets, _autocorrelation_peak, _grid_score,
-    brand_states_font, cfr_args, concat_list_line, db_to_linear, default_output, encoder_args, escape_filter_path,
+    brand_states_font, cfr_args, cfr_at_input, cfr_filter, graph_with_cfr, with_cfr, concat_list_line, db_to_linear, default_output, encoder_args, escape_filter_path,
     fmt_secs, fmt_smpte_time, fmt_srt_time, frame_size, is_audio_output, load_brand, MissingFpsError, pad_filters, parse_time,
     signed_time_arg, source_codec_video_args, drawn_chain, draws_chroma, label_chain, layer_base_chain, matrix_chain, overlay_format, range_chain, rgb_chain_to_bt709, SVT_PRESET, time_arg, video_args, x264_args, _x264_raw
 )
@@ -182,7 +182,7 @@ __all__ = [
     "platform", "re", "shutil", "subprocess", "sys", "unicodedata",
     "aac_args", "add_common", "add_pad_fill_args", "ADVANCE_EM", "analyze_levels", "LEGAL_RANGE_CHOICES", "LEGAL_RANGES", "legal_limits", "measure_signal_range", "apply_common", "detect_scenes", "detect_silences", "SCORE_RE", "SIL_RE", "_aspect_string",
     "audio_codec_for", "AUDIO_CODECS", "BIDI_SCRIPTS", "_bit_depth", "brand_caption_style", "BRAND_DEFAULTS",
-    "brand_states_font", "_brief", "_BRIEF_DROP", "_brief_summary", "bt709_matrix_args", "bt709_matrix_filter", "bt709_tag_args", "cfr_args", "_char_em",
+    "brand_states_font", "_brief", "_BRIEF_DROP", "_brief_summary", "bt709_matrix_args", "bt709_matrix_filter", "bt709_tag_args", "cfr_args", "cfr_at_input", "cfr_filter", "graph_with_cfr", "with_cfr", "_char_em",
     "char_script", "_check_existing_output", "refuse_existing_outputs", "guard_sidecar", "_check_no_overwrite_input", "_check_output_path", "child_args", "option_args",
     "child_limit", "_CHILDREN", "_cleanup_partial_output", "_cmdline", "CODECS", "color_hex", "_COLOR_TOKEN_RE",
     "concat_list_line", "Context", "_CURRENT_CTX", "db_to_linear", "decode_pcm_mono", "description_block", "_evidence_rank", "fmt_chapter_time", "propose_chapters",

package/scripts/_common/decision.py

@@ -655,6 +655,63 @@ def cfr_args(meta: Optional[Dict[str, Any]], fps: Optional[float] = None) -> Lis
     return ["-fps_mode", "cfr", "-r", f"{rate:g}"]
 
 
+def cfr_filter(meta: Optional[Dict[str, Any]], fps: Optional[float] = None) -> str:
+    """The `fps` filter that puts the picture on the grid cfr_args() delivers, as the last filter of
+    the video chain; "" when cfr_args() forces no rate. The encoder line's `-fps_mode cfr -r` alone
+    let a frame fall up to about two frames behind its slot before it dropped one, so a VFR clip
+    conformed at its average rate showed its picture up to 56 ms after its sound (#512); the
+    filter takes the nearest frame for every slot. The encoder line keeps cfr_args(), which then
+    moves no frame."""
+    args = cfr_args(meta, fps)
+    return f"fps={args[-1]}" if args else ""
+
+
+def with_cfr(chain: str, meta: Optional[Dict[str, Any]], fps: Optional[float] = None) -> str:
+    """`chain` (a -vf value or one filtergraph chain) with cfr_filter() appended when there is one.
+    A -vf value that is a graph of its own (drawn_chain()'s split/maskedmerge) gets it first
+    instead: maskedmerge, like overlay, ends its output at its last frame's start, and an fps
+    filter after it lost the last frame (graphics.py --template chapter: 3.963 s of 4)."""
+    return chain_with_rate(chain, cfr_filter(meta, fps))
+
+
+def chain_with_rate(chain: str, rate_filter: str) -> str:
+    """`chain` with an `fps` filter `rate_filter` placed as with_cfr() places cfr_filter(): last in
+    a plain chain, first in a -vf that is a graph of its own (fit/export's blur pad, a drawn pad
+    with chroma), whose overlay or maskedmerge ends its output at its last frame's start on FFmpeg
+    6.1 and lost the last frame to an fps filter after it. For a rate that is not cfr_args()'s
+    own (export.py's preset and platform rates)."""
+    if not rate_filter:
+        return chain
+    if ";" in chain:
+        return f"{rate_filter},{chain}"
+    return f"{chain},{rate_filter}" if chain else rate_filter
+
+
+def graph_with_cfr(graph: str, label: str, meta: Optional[Dict[str, Any]],
+                   fps: Optional[float] = None) -> Tuple[str, str]:
+    """A -filter_complex graph and the video output label to map, with cfr_filter() after that
+    label when there is one: (graph + ";[v]fps=R[vcfr]", "[vcfr]"), else both unchanged."""
+    f = cfr_filter(meta, fps)
+    if not f:
+        return graph, label
+    bare = label.strip("[]")
+    return f"{graph};[{bare}]{f}[{bare}cfr]", f"[{bare}cfr]"
+
+
+def cfr_at_input(graph: str, meta: Optional[Dict[str, Any]], fps: Optional[float] = None, src: str = "[0:v]") -> str:
+    """A -filter_complex graph with cfr_filter() on its main picture as it is decoded (`src`, which
+    the graph reads once), for a graph that composites onto that picture and moves no frame in
+    time. After an overlay the conform comes too late: FFmpeg 6.1's overlay ends its output at its
+    last frame's start, so an fps filter there lost the last frame (3.963 s of a 4 s picture)."""
+    f = cfr_filter(meta, fps)
+    if not f:
+        return graph
+    if graph.count(src) != 1:
+        # a graph that read the picture twice, or not at all, would go unconformed or not parse
+        raise ValueError(f"cfr_at_input: the graph reads {src} {graph.count(src)} times, not once")
+    return f"{src}{f}[cfrin];" + graph.replace(src, "[cfrin]")
+
+
 def delivered_rate(meta: Optional[Dict[str, Any]], fps: Optional[float] = None) -> Optional[float]:
     """The constant rate cfr_args() forces on the output (its -r), or None when it forces none and
     the output keeps the source's rate -- what a start timecode is counted at

package/scripts/broll.py

@@ -24,7 +24,7 @@ from typing import Any, Dict, List
 
 from _common.decision import (av_trim, conform_output_t, conform_to_length, frame_durations, frame_rate, frame_window,
                               grid_at_or_after, silence_filter, stream_starts, window_expr, windowed_overlay_x)
-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, overlay_format, range_chain, probe, run, validate_color, video_args, X264_PRESETS, fmt_secs
+from _common import STATE, add_common, aac_args, apply_common, cfr_args, cfr_at_input, as_limited, default_output, die, draws_chroma, drawn_chain, emit, ffmpeg_base, info, time_arg, label_chain, matrix_chain, overlay_format, 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
 from _common.emit import input_length
@@ -242,7 +242,10 @@ def main() -> int:
             parts.append(f"{''.join(layers)}amix=inputs={len(layers)}:normalize=0:dropout_transition=0,{tail}[aout]")
             aout = "[aout]"
 
-    cmd += ["-filter_complex", ";".join(parts), "-map", vout]
+    # a VFR A-roll is conformed by the fps filter as it is decoded, at the rate cfr_args() delivers:
+    # -fps_mode cfr alone let a frame run up to two frames late against the sound (#512)
+    graph = cfr_at_input(";".join(parts), meta_a)
+    cmd += ["-filter_complex", graph, "-map", vout]
     if aout:
         cmd += ["-map", aout]
     cmd += video_args(meta_a, args.crf, args.preset, convert_matrix=False) + cfr_args(meta_a, None)

package/scripts/caption.py

@@ -46,7 +46,7 @@ from _ass_overlay import (EMOJI_SENTINEL, emoji_placeholder, ass_escape_markup,
                           strip_srt_markup, reinsert_srt_markup, carry_srt_markup, srt_alignment)
 from _common.emit import refuse  # noqa: E402
 from _common.emoji import emoji_missing_asset_note, emoji_mono_on_colour_note
-from _common import require_filter, emoji_filter_chain, EMOJI_ASSET_HINT, emoji_asset_for, emoji_codepoint_name, emoji_support, resolve_emoji_assets, NO_SPACE_SCRIPTS, 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, layer_base_chain, load_brand, overlay_format, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, default_output, die, escape_filter_path, ffmpeg_base, fmt_smpte_time, info, MissingFpsError, parse_time, probe, run, 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, NO_SPACE_SCRIPTS, 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, layer_base_chain, load_brand, overlay_format, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, cfr_at_input, with_cfr, default_output, die, escape_filter_path, ffmpeg_base, fmt_smpte_time, info, MissingFpsError, parse_time, probe, run, 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
@@ -2082,10 +2082,11 @@ def main() -> int:
             asset = spec[-1]
             if asset not in STATE.plan_inputs:
                 STATE.plan_inputs.append(asset)
-        graph = ";".join([f"[0:v]{vf}[vsub]"] + chains)
+        # the conform of a VFR source is the fps filter at the end of the chain (#512)
+        graph = cfr_at_input(";".join([f"[0:v]{vf}[vsub]"] + chains), meta)
         cmd += ["-filter_complex", graph, "-map", "[vout]"]
     else:
-        cmd += ["-map", "0:v:0", "-vf", vf]
+        cmd += ["-map", "0:v:0", "-vf", with_cfr(vf, meta)]
     if meta.get("audio"):
         cmd += ["-map", f"0:a:{args.audio_stream}"]
     cmd += video_args(meta, args.crf, args.preset) + cfr_args(meta)

package/scripts/color.py

@@ -33,7 +33,7 @@ import sys
 from typing import List, Optional
 
 from _common.runner import carried_stream_maps, fail_if_classified
-from _common import STATE, add_common, analyze_levels, LEGAL_RANGE_CHOICES, legal_limits, measure_signal_range, apply_common, emit, aac_args, cfr_args, default_output, die, escape_filter_path, ffmpeg_base, ffmpeg_bsfs, info, probe, require_tool, run, run_analysis, run_keeping_subtitles, x264_args, X264_PRESETS, fmt_secs
+from _common import STATE, add_common, analyze_levels, LEGAL_RANGE_CHOICES, legal_limits, measure_signal_range, apply_common, emit, aac_args, cfr_args, cfr_at_input, with_cfr, default_output, die, escape_filter_path, ffmpeg_base, ffmpeg_bsfs, info, probe, require_tool, run, run_analysis, run_keeping_subtitles, x264_args, X264_PRESETS, fmt_secs
 from _common.emit import note, warn
 from _common.color import is_rgb, rgb_to_bt709_filter
 from _common.alpha import (add_alpha_args, audio_line, check_alpha_args, decoder_args_for, default_ext, finish_chain,
@@ -648,13 +648,14 @@ def main() -> int:
         # converts the graded YUV in front of alphamerge, so the matrix is labelled there too
         fc = (f"[0:v]split[ka_c][ka_a];[ka_c]{vf}{matrix_label(meta)}[ka_g];[ka_a]alphaextract[ka_m];"
               f"[ka_g][ka_m]alphamerge,{finish_chain(alpha_codec, args.alpha_mode, meta)}[ka_v]")
+        fc = cfr_at_input(fc, meta)  # the conform of a VFR source: the fps filter (#512)
         cmd = ffmpeg_base() + decoder_args_for(meta, args.input) + ["-i", args.input, "-filter_complex", fc,
                                                                      "-map", "[ka_v]", "-map", f"0:a:{args.audio_stream}?"]
         cmd += video_line(alpha_codec) + tag_args(meta) + cfr_args(meta) + (audio_line(alpha_codec) if has_audio else [])
         if STATE.hw:
             note(f"--hw: --alpha-codec {alpha_codec} stays on the CPU (no VideoToolbox encoder writes it with its alpha)")
     else:
-        cmd = ffmpeg_base() + ["-i", args.input, "-vf", vf, "-map", "0:v:0", "-map", f"0:a:{args.audio_stream}?"]
+        cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr(vf, meta), "-map", "0:v:0", "-map", f"0:a:{args.audio_stream}?"]
         # --lut/--correct grade the source's own pixels, so a BT.601 source is converted to the BT.709
         # the line is tagged with; --to-sdr's zscale chain already writes BT.709 and converts nothing more
         cmd += x264_args(args.crf, args.preset, source=None if args.to_sdr else meta) + cfr_args(meta) + (aac_args() if has_audio else [])

package/scripts/crop.py

@@ -22,7 +22,7 @@ Examples:
 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 import add_common, apply_common, aac_args, cfr_args, with_cfr, 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.runner import default_selection_maps
 from _common.emit import note
@@ -70,7 +70,7 @@ def main() -> int:
         vf.insert(0, square_pixels(meta["video"]))
         note(square_pixels_note(meta["video"]))
     # the picture the rectangle was checked against, not the largest one default selection takes
-    cmd = ffmpeg_base() + ["-i", args.input] + default_selection_maps(meta, output) + ["-vf", ",".join(vf)]
+    cmd = ffmpeg_base() + ["-i", args.input] + default_selection_maps(meta, output) + ["-vf", with_cfr(",".join(vf), meta, args.fps)]
     cmd += video_args(meta, args.crf, args.preset)
     cmd += cfr_args(meta, args.fps)
     if has_audio:

package/scripts/cut.py

@@ -65,7 +65,7 @@ from _common.probe import PROBED_AUDIO, PROBED_VIDEO, TS_EXTS, probed_maps, seve
 from _common.runner import subtitle_codec_for, subtitle_container_holds
 from _common.decision import SEEK_MARGIN, delivered_rate, frame_rate, grid_at_or_after, stream_starts
 from _common.timeline import output_timecode_args
-from _common import warn, record_fallback, refuse_existing_outputs, 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, concat_list_line, place_output, refuse_output_is_input, fmt_secs, measure_frame_timing, dry_run_input_pending
+from _common import warn, record_fallback, refuse_existing_outputs, sibling_temp, source_codec_video_args, STATE, add_common, apply_common, audio_codec_for, emit, aac_args, cfr_args, cfr_filter, graph_with_cfr, default_output, die, ffmpeg_base, info, is_audio_output, time_arg, probe, run, X264_PRESETS, keyframes_near, 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)
 DROPPED_STREAMS: List[str] = []
@@ -925,6 +925,9 @@ def cut_one(src: str, start: float, end: float, dst: str, reencode: bool, crf: i
             m = min(SEEK_MARGIN, start)
             cmd = ffmpeg_base() + ["-ss", f"{start - m:.6f}", "-i", src, "-ss", f"{m:.6f}", "-t", f"{dur:.6f}"]
             cmd += stream_maps(meta, dst, copy=False)
+            # a VFR source is conformed by the fps filter at the rate cfr_args() delivers: the
+            # encoder line's -fps_mode cfr alone let a frame run up to two frames late (#512)
+            cmd += ["-vf", cfr_filter(meta)] if cfr_filter(meta) else []
         # ffmpeg's default stream selection also picks one subtitle stream; a re-encode cannot
         # trim it (the cues kept their timestamps and the container grew to 2 s for a 1 s cut,
         # sweep F2), so the re-encode carries video/audio only and the result says so
@@ -1162,8 +1165,11 @@ def _join_chunk(src: str, segments: List[Tuple[float, float]], dst: str, meta: d
             pads += f"[a{i}]"
     outs = ("[v]" if has_v else "") + ("[a]" if has_a else "")
     graph.append(f"{pads}concat=n={len(segments)}:v={int(has_v)}:a={int(has_a)}{outs}")
-    cmd += ["-filter_complex", ";".join(graph)]
-    for pad in ("[v]" if has_v else None, "[a]" if has_a else None):
+    # a VFR source is conformed by the fps filter after the concat, at the rate cfr_args() delivers
+    # (#512); a constant-rate source's graph is unchanged
+    fc, vpad = graph_with_cfr(";".join(graph), "[v]", meta) if has_v else (";".join(graph), None)
+    cmd += ["-filter_complex", fc]
+    for pad in (vpad, "[a]" if has_a else None):
         if pad:
             cmd += ["-map", pad]
     if intermediate:

package/scripts/deinterlace.py

@@ -22,7 +22,7 @@ Examples:
 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 import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
 
 MODES = {"frame": 0, "field": 1}
 PARITIES = {"auto": -1, "tff": 0, "bff": 1}
@@ -58,16 +58,21 @@ def main() -> int:
     output = args.output or default_output(args.input, "deint")
 
     vf = f"yadif=mode={MODES[args.mode]}:parity={PARITIES[args.parity]}:deint={1 if args.only_interlaced else 0}"
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", vf, "-map", "0:v:0"]
-    if has_audio:
-        cmd += ["-map", f"0:a:{args.audio_stream}?"]
-    cmd += video_args(meta, args.crf, args.preset)
+    # the conform is the fps filter at the end of the chain, the rate the encoder line delivers:
+    # its -fps_mode cfr alone let a frame run up to two frames late (#512)
     if args.mode == "field":
         v = meta["video"]
         src_fps = v.get("fps") or 30.0
-        cmd += ["-fps_mode", "cfr", "-r", f"{src_fps * 2:g}"]
+        rate_args = ["-fps_mode", "cfr", "-r", f"{src_fps * 2:g}"]
+        vf += f",fps={src_fps * 2:g}"
     else:
-        cmd += cfr_args(meta)
+        rate_args = cfr_args(meta)
+        vf = with_cfr(vf, meta)
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", vf, "-map", "0:v:0"]
+    if has_audio:
+        cmd += ["-map", f"0:a:{args.audio_stream}?"]
+    cmd += video_args(meta, args.crf, args.preset)
+    cmd += rate_args
     if has_audio:
         cmd += aac_args()
     else:

package/scripts/denoise.py

@@ -18,7 +18,7 @@ Examples:
 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 import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
 
 # hqdn3d's own AVOptions default to 0 (off); these tested presets are the light/medium/heavy
 # starting points its own documentation and common usage recommend (spatial then temporal,
@@ -72,7 +72,7 @@ def main() -> int:
     output = args.output or default_output(args.input, "denoise")
 
     vf = f"hqdn3d={ls:g}:{cs:g}:{lt:g}:{ct:g}"
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", vf, "-map", "0:v:0"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr(vf, meta, args.fps), "-map", "0:v:0"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]
     cmd += video_args(meta, args.crf, args.preset)

package/scripts/export.py

@@ -48,8 +48,8 @@ from pathlib import Path
 from typing import Dict, List, Optional
 
 from _common.runner import carried_stream_maps, child_exit_code, fail_if_classified, kept_clause, mark_delivered
-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 import STATE, run_analysis, add_common, apply_common, bt709_label_filter, bt709_matrix_args, bt709_tag_args, child_args, emit, cfr_args, cfr_filter, 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 chain_with_rate, hw_preset_video, restate_last_swap
 from _common.emit import note, record_fallback, record_skip, warn
 from _common.probe import PROBED_AUDIO, PROBED_VIDEO, probed_maps, square_pixels, square_pixels_note
 from _common.runner import ffmpeg_encoders, guard_sidecar, remember_written, replace_checked, replace_checked_together, reserve_sibling, subtitle_codec_for
@@ -203,10 +203,15 @@ def _key_fill(args, p: Dict, meta: Dict, output: str, cmd: List[str], vf: List[s
         note(f"--hw: --preset {args.preset} stays on {p['video'][p['video'].index('-c:v') + 1]}: one ffmpeg run writes "
              "the fill and the key as a pair, and VideoToolbox's ProRes encoder is not used for it")
     fill_chain = ",".join(vf + (["premultiply=inplace=1"] if args.alpha_mode == "premultiplied" else []) + ["format=yuv422p10le"])
-    key_chain = ",".join(vf + ["alphaextract", "format=yuv422p10le"])
+    # Alpha uses full range even when the source picture is tagged limited range.
+    key_chain = ",".join(vf + ["alphaextract", "scale=in_range=pc:out_range=tv", "format=yuv422p10le"])
     tc = ((meta.get("timecode") or {}).get("value"))
     tc_args = ["-timecode", tc] if tc else []
-    cmd = cmd + ["-filter_complex", f"[0:{PROBED_VIDEO}]split[f][k];[f]{fill_chain}[fill];[k]{key_chain}[key]"]
+    # a VFR source is conformed by the fps filter, once, ahead of the split: both files hold the same
+    # frames, and -fps_mode cfr alone let a frame run up to two frames late against the sound (#512)
+    conform = cfr_filter(meta)
+    cmd = cmd + ["-filter_complex", f"[0:{PROBED_VIDEO}]{conform + ',' if conform else ''}split[f][k];"
+                                    f"[f]{fill_chain}[fill];[k]{key_chain}[key]"]
     cmd += ["-map", "[fill]"] + probed_maps(meta, video=False, audio=has_audio) + p["video"] + tc_args + cfr_args(meta)
     # the fill is always written to a hidden sibling and moved into place only after the encode
     # succeeds: run() stages and cleans up only ffmpeg's last output (the key), so a failed encode
@@ -695,8 +700,23 @@ def main() -> int:
     if args.preset != "copy":
         # a stream copy can't be frame-rate-conformed or retagged without decoding it — that would
         # no longer be a copy, and would silently mislabel colour the agent never actually looked at
+        rate_args: List[str] = []
         if "-r" not in video:
-            cmd += _platform_rate_args(args.preset, meta) or cfr_args(meta)
+            rate_args = _platform_rate_args(args.preset, meta) or cfr_args(meta)
+            cmd += rate_args
+        # the rate the line delivers (a preset's own -r, a platform's divided rate, or a VFR
+        # source's average) is reached by the fps filter, the nearest frame for each slot: the
+        # encoder line's -r alone let a frame run up to two frames late against the sound before
+        # it dropped one (#512)
+        rate_f = (f"fps={video[video.index('-r') + 1]}" if "-r" in video
+                  else f"fps={rate_args[rate_args.index('-r') + 1]}" if "-r" in rate_args else "")
+        # it is placed as with_cfr() places it: first in a -vf that is a graph (a blur pad's
+        # split/overlay, a drawn pad's maskedmerge), whose last frame an fps filter after it lost
+        # on FFmpeg 6.1 (reels --pad-fill blur: 119 frames of a 4 s 30 fps picture)
+        if rate_f and "-vf" in cmd:
+            cmd[cmd.index("-vf") + 1] = chain_with_rate(cmd[cmd.index("-vf") + 1], rate_f)
+        elif rate_f:
+            cmd += ["-vf", rate_f]
         if tag_bt709 and not video[video.index("-c:v") + 1].endswith("_videotoolbox"):
             cmd += bt709_tag_args(video[video.index("-c:v") + 1])
         if not p.get("intermediate"):

package/scripts/fit.py

@@ -38,9 +38,9 @@ import sys
 from fractions import Fraction
 from typing import List
 
-from _common.decision import SEEK_MARGIN, delivered_rate, frame_rate, grid_at_or_after, length_output_t, stream_starts
+from _common.decision import SEEK_MARGIN, delivered_rate, frame_durations, frame_rate, grid_at_or_after, length_output_t, stream_starts
 from _common.timeline import exact_rate, output_timecode_args
-from _common import video_args, STATE, add_common, apply_common, emit, aac_args, aspect_ratio, cfr_args, default_output, die, ffmpeg_base, info, probe, run, run_keeping_subtitles, validate_color, pad_filters, add_pad_fill_args, X264_PRESETS, time_arg, fmt_secs, frame_size, display_size, square_pixels, square_pixels_note, note
+from _common import video_args, STATE, add_common, apply_common, emit, aac_args, aspect_ratio, cfr_args, cfr_filter, default_output, die, ffmpeg_base, info, probe, run, run_keeping_subtitles, validate_color, pad_filters, add_pad_fill_args, X264_PRESETS, time_arg, fmt_secs, frame_size, display_size, square_pixels, square_pixels_note, note
 from _common.emit import input_length
 BLUR_DARKEN = 0.15  # how much --fit blur dims the blurred background copy (eq brightness)
 
@@ -162,6 +162,7 @@ def main() -> int:
     post: List[str] = []
     factor = 1.0
     tc_first = None  # seconds from the source's first frame to the output's, when a trim moves it
+    regridded = False  # a speed change already put the picture on the delivered grid
 
     # ---- rotate / flip
     if args.rotate == 90:
@@ -204,6 +205,15 @@ def main() -> int:
                 elif factor < 1.0 and args.smooth == "blend":
                     vf.append(f"fps={src_fps:g}")
                     vf.append("tblend=all_mode=average")
+                elif not args.fps:
+                    # the retimed frames are put back on the output's grid by the fps filter, the
+                    # nearest frame for each slot: left to the encoder line's rate, a 1.11x speed-up
+                    # showed every picture up to two frames late against its sound (#512's class).
+                    # A rate the caller names is that grid (the conform below): conformed here to
+                    # the source's 30 first, a 2x speed-up to --fps 60 dropped every other picture
+                    # and the second fps filter repeated the rest
+                    vf.append(frame_durations(meta, delivered_rate(meta) or frame_rate(meta) or src_fps))
+                    regridded = True
                 if has_audio:
                     af.append(atempo_chain(factor))
             # atempo's sound is not the input's length over the factor (it comes out some
@@ -243,11 +253,43 @@ def main() -> int:
             else:
                 info(f"source ({src_dur:.2f}s) is already shorter than {target:.2f}s; trim does nothing")
 
+    # ---- the output's rate: after any retiming, ahead of the frame's own filters. --fit blur and
+    # --pad-fill blur are a split/overlay graph, and FFmpeg 6.1's overlay ends its output at its
+    # last frame's start, so an fps filter after it lost the last frame (#512's placement).
+    # A speed change without --fps has already been put on the delivered grid above
+    if args.fps:
+        vf.append(f"fps={args.fps:g}")
+    elif meta["video"].get("variable_frame_rate_suspected") and not regridded:
+        info("source looks variable-frame-rate; conforming to constant fps automatically")
+        # the conform is the fps filter, as --fps is: -fps_mode cfr alone let a frame run up to
+        # two frames late against the sound (#512)
+        vf.append(cfr_filter(meta))
+
     # ---- aspect / size
     if args.aspect or args.width or args.height:
         # the one sizing rule, shared with render.py --export-timeline's sequence frame
         out_w, out_h = frame_size(parse_aspect(args.aspect) if args.aspect else None, args.width, args.height, sw, sh)
-        if args.fit == "crop":
+        if args.fit == "crop" and sw and sh:
+            # The scaled frame's margin on each axis is a multiple of 4 and the offset is computed
+            # here, to even: crop floors an odd offset to the chroma grid of a 4:2:0 frame, so
+            # --crop-x 1 lost the source's last column and showed one column of the margin, and a
+            # centred crop sat a pixel left of / above the centre (#512). exact=1 would put the
+            # chroma half a sample off the luma instead. The size is the one
+            # force_original_aspect_ratio=increase gives (av_rescale rounds half away from zero),
+            # widened by at most 3 px on the cropped axis.
+            sc_w = max(out_w, (2 * out_h * sw + sh) // (2 * sh))
+            sc_h = max(out_h, (2 * out_w * sh + sw) // (2 * sw))
+            mx, my = (-(-(sc - o) // 4) * 4 for sc, o in ((sc_w, out_w), (sc_h, out_h)))
+            ox, oy = (int(m * f / 2 + 0.5) * 2 for m, f in ((mx, args.crop_x), (my, args.crop_y)))
+            for axis, m, f, got in (("x", mx, args.crop_x, ox), ("y", my, args.crop_y, oy)):
+                if abs(m * f - got) > 1e-9:
+                    # the offset is kept even (the chroma grid); a caller who asked for another one
+                    # is told which it got, as proxy.py says which width it wrote
+                    note(f"--crop-{axis} {f:g}: crop offset {got}px, not {m * f:g}px: the offset is kept even "
+                         f"(4:2:0 chroma), on a {m}px margin")
+            vf.append(f"scale={out_w + mx}:{out_h + my}")
+            vf.append(f"crop={out_w}:{out_h}:{ox}:{oy}")
+        elif args.fit == "crop":  # a dry run's pending input has no size: the expressions, planned only
             vf.append(f"scale={out_w}:{out_h}:force_original_aspect_ratio=increase")
             vf.append(f"crop={out_w}:{out_h}:(in_w-out_w)*{args.crop_x:g}:(in_h-out_h)*{args.crop_y:g}")
         elif args.fit == "blur":
@@ -272,10 +314,6 @@ def main() -> int:
             vf.insert(0, square_pixels(meta["video"]))
             note(square_pixels_note(meta["video"]))
 
-    if args.fps:
-        vf.append(f"fps={args.fps:g}")
-    elif meta["video"].get("variable_frame_rate_suspected"):
-        info("source looks variable-frame-rate; conforming to constant fps automatically")
     # the start timecode is counted at the rate the output is delivered at: a --fps that changes
     # the rate relabels it (01:00:00:12 at 25 fps is 01:00:00:24 at 50) even with no trim, which
     # is also how a render.py clip cut at its own rate reaches the project's frame.fps

package/scripts/freeze.py

@@ -19,8 +19,8 @@ Examples:
 import argparse
 import sys
 
-from _common.decision import av_trim, frame_durations, frame_rate, grid_at_or_after, silence_filter, stream_starts, tpad_length
-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, time_arg, fmt_secs, run
+from _common.decision import av_trim, delivered_rate, frame_durations, frame_rate, grid_at_or_after, silence_filter, stream_starts, tpad_length
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, time_arg, fmt_secs, run
 from _common.emit import input_length
 
 
@@ -71,7 +71,7 @@ def main() -> int:
     if holds_end:
         # 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}"
+        vf = with_cfr(f"tpad=stop_mode=clone:stop_duration={args.hold:.3f}", meta)
         cmd = ffmpeg_base() + ["-i", args.input, "-vf", vf, "-map", "0:v:0"]
         if has_audio:
             cmd += ["-map", "0:a:0?", "-af", silence_filter(meta["audio"].get("sample_rate"), tail=args.hold)]
@@ -80,7 +80,7 @@ def main() -> int:
         # 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
         # end: tpad's start_duration clones the *first* frame backwards instead.
-        vf = f"tpad=start_mode=clone:start_duration={args.hold:.3f}"
+        vf = with_cfr(f"tpad=start_mode=clone:start_duration={args.hold:.3f}", meta)
         cmd = ffmpeg_base() + ["-i", args.input, "-vf", vf, "-map", "0:v:0"]
         if has_audio:
             # the sound waits as long as the picture is held: whole frames (tpad_length), as the
@@ -92,12 +92,12 @@ def main() -> int:
         # 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))
+        n = max(1, round(args.hold * rate))
         # 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
+        actual_hold = n / rate
         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
@@ -112,11 +112,13 @@ def main() -> int:
         # 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
+        # the graph closes on the rate the encoder line delivers (a VFR source is conformed to its
+        # average): closed on r_frame_rate, -r then resampled it and the picture ran late (#512)
         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]")
+              f"[head][hold][tail]concat=n=3:v=1:a=0,{frame_durations(meta, delivered_rate(meta) or rate)}[outv]")
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", vf, "-map", "[outv]"]
         if has_audio:
             af = (f"[0:a]asplit[aa][ab];[aa]{head_a}[ahead];"

package/scripts/graphics.py

@@ -36,7 +36,7 @@ from typing import List, Optional, Tuple
 from _platforms import PLATFORMS, PLATFORM_CHOICES, safe_margins_px, resolve as resolve_platform
 from _common.emoji import emoji_missing_asset_note, emoji_mono_on_colour_note
 from _common.drawtext import shaping_refusal
-from _common import (guard_sidecar, require_filter, aac_args, add_common, brand_caption_style, script_font_for_text, apply_common, cfr_args,
+from _common import (guard_sidecar, require_filter, aac_args, add_common, brand_caption_style, script_font_for_text, apply_common, cfr_args, cfr_at_input, with_cfr,
                      color_hex, default_output, die, draws_chroma, drawn_chain, emit, escape_drawtext, escape_filter_path,
                      ffmpeg_base, info, layer_base_chain, load_brand, overlay_format, probe, rgb_chain_to_bt709, run_keeping_subtitles, video_args,
                      drawtext_boxborderw, drawtext_center_align, X264_PRESETS, time_arg, fmt_secs, STATE, drawtext_text_opts,
@@ -837,14 +837,17 @@ def main(force_route: Optional[str] = None) -> int:
         if finish:
             chains.append(f"[{last}]{finish}[ka_v]")
             last = "ka_v"
-        cmd += ["-filter_complex", ";".join(chains), "-map", f"[{last}]",
+        # the conform of a VFR source is the fps filter on the picture as it is decoded (#512)
+        cmd += ["-filter_complex", cfr_at_input(";".join(chains), meta), "-map", f"[{last}]",
                 "-map", f"0:a:{args.audio_stream}?"]
     elif fc:
         if finish:
             fc.append(f"[vout]{finish}[ka_v]")
-        cmd += ["-filter_complex", ";".join(fc), "-map", "[ka_v]" if finish else "[vout]", "-map", f"0:a:{args.audio_stream}?"]
+        cmd += ["-filter_complex", cfr_at_input(";".join(fc), meta), "-map", "[ka_v]" if finish else "[vout]",
+                "-map", f"0:a:{args.audio_stream}?"]
     else:
-        cmd += ["-vf", ",".join(p for p in (square, text, finish) if p) if finish else (square + "," if square else "") + text,
+        vf = ",".join(p for p in (square, text, finish) if p) if finish else (square + "," if square else "") + text
+        cmd += ["-vf", with_cfr(vf, meta),
                 "-map", "0:v:0", "-map", f"0:a:{args.audio_stream}?"]
     if alpha_codec:
         cmd += video_line(alpha_codec) + tag_args(meta) + cfr_args(meta)

package/scripts/loop.py

@@ -32,7 +32,7 @@ import os
 import sys
 import tempfile
 
-from _common import STATE, concat_list_line, add_common, aac_args, apply_common, cfr_args, default_output, die, emit, ffmpeg_base, info, probe, refuse_output_is_input, require_filter, require_tool, run, video_args, X264_PRESETS, time_arg, fmt_secs
+from _common import STATE, concat_list_line, add_common, aac_args, apply_common, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, refuse_output_is_input, require_filter, require_tool, run, video_args, X264_PRESETS, time_arg, fmt_secs
 from _common.emit import warn
 from _common.decision import HELD_FRAMES_WARN_BYTES, av_trim, held_frames_bytes, length_output_t, stream_starts
 from _common.probe import decode_gray_frames, decode_pcm_mono
@@ -296,7 +296,9 @@ def main() -> int:
             die(f"--duration ({target:g}s) must be longer than one repeat ({unit:.3f}s) -- use cut.py to trim instead")
         stream_loop = math.ceil(target / unit) - 1
 
-    # a variable-rate source is conformed by the output's own -fps_mode cfr -r (cfr_args)
+    # a variable-rate source is conformed to the rate cfr_args() delivers, by the fps filter in the
+    # picture's chain (below) and the output's -fps_mode cfr -r; the fps stage for a sound that
+    # outlasts the picture is for a constant-rate clip only, so the two never meet
     forced_rate = cfr_args(meta, fps if fade_frames and v.get("variable_frame_rate_suspected") else None)
     if args.boomerang:
         cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", _boomerang_graph(meta, src_dur, args.times), "-map", "[v]"]
@@ -319,6 +321,9 @@ def main() -> int:
         with open(listfile, "w", encoding="utf-8") as fh:
             fh.write((concat_list_line(repeat) + "\n") * (stream_loop + 1))
         vtrim, atrim = av_trim(concat_first_frame(listfile), None, fill_gaps=True)
+        # the conform of a VFR source is the fps filter at the end of the picture's chain, at the
+        # rate cfr_args() below delivers (#512)
+        vtrim = with_cfr(vtrim, meta, fps if fade_frames and v.get("variable_frame_rate_suspected") else None)
         cmd = ffmpeg_base() + ["-f", "concat", "-safe", "0", "-i", listfile]
         v_end = stream_starts(meta)[0] + (v.get("duration") or 0.0)
         if has_audio and not forced_rate and not fade_frames and src_dur - v_end > 0.5 / fps:

package/scripts/overlay.py

@@ -29,13 +29,14 @@ A VP9 --video layer stored with an alpha layer (a WebM from export.py --preset v
 with libvpx-vp9, so its transparency reaches the composite (FFmpeg's own VP9 decoder drops it).
 """
 import argparse
+import ast
 import re
 import sys
 from typing import Any, Dict, List, Optional
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, safe_margins_px, resolve as resolve_platform
 from _common import still_input_args  # noqa: E402
-from _common import STATE, script_font_for_text, drawtext_clean, drawtext_line_metrics, drawtext_text_opts, drawtext_draws_newline_glyph, is_multiline, needs_shaping, LANGUAGE_NAMES, has_emoji, detect_script, emoji_clusters, load_brand, drawn_chain, label_chain, layer_base_chain, matrix_chain, overlay_format, 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, probe, run_keeping_subtitles, validate_color, X264_PRESETS, time_arg, fmt_secs
+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, overlay_format, range_chain, rgb_chain_to_bt709, video_args, add_common, apply_common, emit, aac_args, cfr_args, cfr_filter, cfr_at_input, with_cfr, default_output, die, escape_drawtext, ffmpeg_base, info, probe, run_keeping_subtitles, validate_color, X264_PRESETS, time_arg, fmt_secs
 from _common.emit import note, warn
 from _common.color import is_rgb
 from _common.decision import length_output_t, window_expr, windowed_overlay_x
@@ -86,6 +87,56 @@ def position_exprs(pos: str, margin: int, text_mode: bool, margins: Optional[dic
     return x, y
 
 
+def _scaled_height(w: int, src_w: int, src_h: int, factor: int) -> int:
+    """The height scale=W:-1 (factor 1) or scale=W:-2 (factor 2) gives a src_w x src_h picture:
+    av_rescale(w, ih, iw * factor) * factor, rounded half away from zero as FFmpeg rounds it."""
+    den = src_w * factor
+    return max(factor, (2 * w * src_h + den) // (2 * den) * factor)
+
+
+def on_grid(x: str, y: str, main: "tuple", layer: "tuple") -> "Optional[tuple]":
+    """Where the layer goes so its top-left pixel is at (x, y) in luma, x and y being the overlay
+    expressions position_exprs() gives, as overlay evaluates them (the integer part).
+
+    overlay places a layer on a 4:2:0 picture on the chroma grid: an odd x or y is taken down to
+    the even one before it (#512: --position 11,13 drew the logo at 10,12, and a centred or
+    right-aligned layer whose position came out odd moved the same way). So the layer gets one
+    transparent column/row on the left/top where x/y is odd, and is overlaid at the even position
+    before it: its luma lands where it was asked, and the chroma sample on that edge is shared
+    with the pixel outside it. Returns (x_even, y_even, pad filter or ""), or None when a size is
+    unknown (a dry run's pending input): the overlay then gets the expressions, as before."""
+    (mw, mh), (lw, lh) = main, layer
+    if not (mw and mh and lw and lh):
+        return None
+
+    def arith(node: Any) -> float:
+        # the four operations on whole numbers position_exprs() writes, and nothing else
+        if isinstance(node, ast.Expression):
+            return arith(node.body)
+        if isinstance(node, ast.Constant) and isinstance(node.value, int):
+            return float(node.value)
+        if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.USub, ast.UAdd)):
+            return -arith(node.operand) if isinstance(node.op, ast.USub) else arith(node.operand)
+        if isinstance(node, ast.BinOp) and isinstance(node.op, (ast.Add, ast.Sub, ast.Mult, ast.Div)):
+            a, b = arith(node.left), arith(node.right)
+            return {ast.Add: a + b, ast.Sub: a - b, ast.Mult: a * b}.get(type(node.op), a / b if b else 0.0)
+        raise ValueError(f"not a position: {ast.dump(node)}")
+
+    def value(expr: str, big: int, small: int, axis: str) -> Optional[int]:
+        num = re.sub(axis.upper(), str(big), re.sub(axis, str(small), expr))
+        try:
+            return int(arith(ast.parse(num, mode="eval")))  # the integer part, as overlay's (int) cast takes it
+        except (SyntaxError, ValueError):
+            return None
+
+    px, py = value(x, mw, lw, "w"), value(y, mh, lh, "h")
+    if px is None or py is None:
+        return None
+    ox, oy = px & 1, py & 1  # two's complement: -3 is one column right of -4
+    pad = f"pad=iw+{ox}:ih+{oy}:{ox}:{oy}:color=black@0" if ox or oy else ""
+    return px - ox, py - oy, pad
+
+
 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.
@@ -443,11 +494,22 @@ def main() -> int:
     cmd = ffmpeg_base() + ["-i", args.input]
 
     if args.image:
-        refuse_not_a_still(args.image, probe(args.image), "--image",
+        image_meta = probe(args.image)
+        refuse_not_a_still(args.image, image_meta, "--image",
                            "--video composites a moving layer; `look.py FILE --at T` writes one frame of it as a PNG")
         chain: List[str] = ["format=rgba"]
+        # a still that stores non-square pixels (a PNG's pHYs, a JPEG's density) is made square at
+        # its display aspect first, as a --video layer is: its size and position are computed in
+        # that frame, and placed from it at its stored size a 100x100 PNG at SAR 2:1 drew 100 px
+        # wide at x=120 of a 320 px main for top-right, 100 px short of the edge
+        if square_pixels(image_meta.get("video")):
+            chain.append(square_pixels(image_meta.get("video")))
+            note(square_pixels_note(image_meta.get("video"), "the --image"))
+        iw, ih = display_size(image_meta.get("video"))
+        lw = int(vw * args.scale_percent / 100) if args.scale_percent else args.scale or iw
+        lh = _scaled_height(lw, iw, ih, 1) if lw != iw and iw and ih else ih
         if args.scale_percent:
-            chain.append(f"scale={int(vw * args.scale_percent / 100)}:-1")
+            chain.append(f"scale={lw}:-1")
         elif args.scale:
             chain.append(f"scale={args.scale}:-1")
         if args.opacity < 1:
@@ -461,6 +523,11 @@ def main() -> int:
             if end is not None and end > args.fade:
                 chain.append(f"fade=t=out:st={end - args.fade:.3f}:d={args.fade:g}:alpha=1")
         x, y = position_exprs(args.position, args.margin, text_mode=False, margins=safe_margins)
+        grid = on_grid(x, y, (vw, vh), (lw, lh))
+        if grid:
+            # padded in RGBA, where a one-pixel offset is exact, before the layer is made YUV
+            x, y = grid[0], grid[1]
+            chain += [grid[2]] if grid[2] else []
         # a 10-bit main on a 10-bit line is composited at 10 bits in YUV: format=auto with an RGBA
         # still took the whole picture through 8-bit RGB (overlay_format)
         # a --start/--end window is in the layer's position, which is evaluated on the main
@@ -510,8 +577,11 @@ def main() -> int:
             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 = [square_pixels(pip_meta["video"])] if square_pixels(pip_meta["video"]) else []
+        iw, ih = display_size(pip_meta["video"])
+        lw = int(vw * args.scale_percent / 100) if args.scale_percent else args.scale or iw
+        lh = _scaled_height(lw, iw, ih, 2) if (args.scale_percent or args.scale) and iw and ih else ih
         if args.scale_percent:
-            chain.append(f"scale={int(vw * args.scale_percent / 100)}:-2")
+            chain.append(f"scale={lw}:-2")
         elif args.scale:
             chain.append(f"scale={args.scale}:-2")
         # an alpha line composites at 4:4:4: the layer is not taken through 4:2:0 on the way
@@ -544,6 +614,15 @@ def main() -> int:
             # which came back BT.601 under the BT.709 tag (#333's defect, on this path)
             chain.append(f"lut=y=val:u=val:v=val:a=val*{args.opacity:g}")
         x, y = position_exprs(args.position, args.margin, text_mode=False, margins=safe_margins)
+        grid = on_grid(x, y, (vw, vh), (lw, lh))
+        if grid:
+            x, y = grid[0], grid[1]
+            if grid[2]:
+                # padded at 4:4:4, where a one-pixel offset is exact; overlay takes the layer back
+                # to the main's 4:2:0 on its own grid, as the layer is now aligned with it
+                if not any(c.endswith("yuva444p") or c.endswith("yuva444p10le") for c in chain):
+                    chain.append("format=yuva444p10le" if deep else "format=yuva444p")
+                chain.append(grid[2])
         # a --start/--end window is in the layer's position, which is evaluated on the main
         # picture's frames; overlay's enable is evaluated on the layer's frames too
         ov = f"overlay={windowed_overlay_x(x, enable) if enable else x}:{y}" + (overlay_format(meta) or ":format=auto")
@@ -646,6 +725,15 @@ def main() -> int:
     else:
         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"]
+    if cfr_filter(meta):
+        # the conform of a VFR source is the fps filter (in a graph, on the main picture as it is
+        # decoded): the encoder line's -fps_mode cfr alone let a frame run up to two frames late (#512)
+        if "-filter_complex" in cmd:
+            i = cmd.index("-filter_complex") + 1
+            cmd[i] = cfr_at_input(cmd[i], meta)
+        else:
+            i = cmd.index("-vf") + 1
+            cmd[i] = with_cfr(cmd[i], meta)
     dropped_streams = run_keeping_subtitles(cmd, output)
     if not STATE.dry_run:
         result = probe(output, role="output")

package/scripts/pad.py

@@ -18,7 +18,7 @@ import sys
 
 from _common.emit import note, record_fallback
 from _common.decision import silence_filter, tpad_length
-from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, drawn_chain, emit, EVEN_SCALE, ffmpeg_base, info, probe, run_keeping_subtitles, validate_color, video_args, X264_PRESETS, time_arg, fmt_secs, run
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, drawn_chain, emit, EVEN_SCALE, ffmpeg_base, info, probe, run_keeping_subtitles, validate_color, video_args, X264_PRESETS, time_arg, fmt_secs, run
 
 
 def main() -> int:
@@ -51,7 +51,12 @@ def main() -> int:
     tpad = f"tpad=start_duration={args.start:.3f}:stop_duration={args.end:.3f}:color="
     # a --color with chroma lands in the BT.709 the output is tagged with (tpad's own YUV is BT.601
     # before FFmpeg 7.1, and for an untagged picture after it); black is the same under every matrix
-    vf = drawn_chain(tpad + args.color, meta, [args.color], tpad + "black")
+    # the conform of a VFR source is the fps filter right after tpad, which pads by time: before
+    # it, the padding was rounded to the delivered grid on top of the frames' own rounding (37 ms
+    # late), and after a drawn chain's maskedmerge the last frame was lost (#512)
+    conform = with_cfr("", meta)
+    vf = drawn_chain(tpad + args.color + ("," + conform if conform else ""), meta, [args.color],
+                     tpad + "black" + ("," + conform if conform else ""))
     cmd = ffmpeg_base() + ["-i", args.input]
     if has_audio:
         # One -filter_complex, not a -vf and an -af: the ffmpeg scheduler of Ubuntu 26.04's 8.0.1 and

package/scripts/proxy.py

@@ -26,7 +26,7 @@ Examples:
 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 import add_common, apply_common, cfr_args, with_cfr, 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
 
@@ -77,7 +77,7 @@ def main() -> int:
              + (f"the source is {sw}px wide and a proxy is not upscaled" if asked > ceiling else "2px is the smallest width"))
     output = args.output or default_output(args.input, "proxy")
 
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", (square + "," if square else "") + f"scale={out_w}:-2"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr((square + "," if square else "") + f"scale={out_w}:-2", meta, args.fps)]
     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

@@ -27,7 +27,7 @@ Examples:
 import argparse
 import sys
 
-from _common import add_common, overlay_format, 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 import add_common, overlay_format, apply_common, aac_args, cfr_args, cfr_at_input, with_cfr, 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
 
@@ -98,7 +98,8 @@ def main() -> int:
     output = args.output or default_output(args.input, "redact")
     if args.mode == "delogo":
         cmd = ffmpeg_base() + ["-i", args.input, "-vf",
-                               (square + "," if square else "") + f"delogo=x={args.x}:y={args.y}:w={args.width}:h={args.height}",
+                               with_cfr((square + "," if square else "") + f"delogo=x={args.x}:y={args.y}:w={args.width}:h={args.height}",
+                                        meta, args.fps),
                                "-map", "0:v:0"]
     else:
         # exact=1: crop rounds an odd x/y down to the chroma grid of a 4:2:0 frame otherwise, and
@@ -127,6 +128,8 @@ def main() -> int:
                        f"pad={args.width + 2 * ox}:{args.height + 2 * oy}:{ox}:{oy}:color=black@0")
         fc = (f"[0:v]{square + ',' if square else ''}split=2[base][region];[region]{region}[patched];"
               f"[base][patched]overlay={args.x - ox}:{args.y - oy}{overlay_format(meta)}[out]")
+        # a VFR source (or --fps) is conformed by the fps filter as it is decoded (#512)
+        fc = cfr_at_input(fc, meta, args.fps)
         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

@@ -1326,7 +1326,19 @@ def export_timeline(proj: Dict[str, Any], rel, dest: str) -> int:
     export = proj.get("export")
     frame_from_preset(frame, export if isinstance(export, dict) else {})
     fit = proj.get("fit")
-    if isinstance(fit, dict) and fit.get("aspect") and frame.get("aspect") and aspect_ratio(frame["aspect"]) is None:
+    if isinstance(fit, dict) and len(proj.get("clips") or []) == 1:
+        # one clip: the render's fit stage reframes the clip's own picture with the fit object's
+        # aspect, mode, sides and rate, the frame's only where the fit object has none (the
+        # render's setdefault), so the sequence takes them by the same rule (#506: frame 16:9 with
+        # fit 1:1 rendered a square and exported 1920x1080). Several clips are fitted inside the
+        # join, which join.py sizes from the frame first; their sequence stays the frame's
+        if fit.get("aspect") and aspect_ratio(str(fit["aspect"])) is None:
+            die(f"--export-timeline: fit.aspect {fit['aspect']!r}: use W:H with whole numbers, like 16:9 "
+                "(fit.py refuses it too)", kind="input")
+        if fit.get("fit") is not None and fit["fit"] not in ("pad", "crop", "blur"):
+            die(f"--export-timeline: fit.fit {fit['fit']!r}: use pad, crop or blur (fit.py's --fit)", kind="input")
+        frame.update({k: fit[k] for k in ("aspect", "fit", "width", "height", "fps") if fit.get(k) is not None})
+    elif isinstance(fit, dict) and fit.get("aspect") and frame.get("aspect") and aspect_ratio(frame["aspect"]) is None:
         # the render hands fit.py the fit object's own aspect, never this one (only the preset
         # match above reads it), and completes: the sequence is the frame's size without it
         del frame["aspect"]

package/scripts/speedramp.py

@@ -17,9 +17,10 @@ Examples:
 """
 import argparse
 import sys
+from fractions import Fraction
 from typing import List, Tuple
 
-from _common.decision import av_trim, frame_durations, frame_rate, grid_at_or_after, stream_starts
+from _common.decision import av_trim, conform_filter, delivered_rate, frame_durations, 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
 from _common.emit import input_length
 
@@ -85,7 +86,7 @@ def main() -> int:
     has_audio = bool(meta.get("audio"))
     output = args.output or default_output(args.input, "ramp")
 
-    vparts, aparts, labels = [], [], []
+    vparts, aparts = [], []
     # The coverage check above allows the last end to sit up to 0.5 s off the probed duration.
     # That slack is for a caller who rounded the duration, not a reason to redraw the tail at
     # the last factor. The end bound is omitted only when the stated end is the file's end
@@ -97,7 +98,12 @@ def main() -> int:
     # 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)
+    # on a VFR source the picture is delivered at the rate the encoder line forces (its average):
+    # closed on r_frame_rate, -r then resampled the joined picture and it drifted 113 ms late (#512)
+    out_rate = delivered_rate(meta) or rate
+    srate = int((meta.get("audio") or {}).get("sample_rate") or 0)
     bounds = [v0] + [grid_at_or_after(end, v0, rate) for _, end, _ in segments[:-1]]
+    retimed = 0.0  # where the segment starts on the output's clock
     for i, (start, end, factor) in enumerate(segments):
         vlabel, alabel = f"v{i}", f"a{i}"
         to_eof = i == len(segments) - 1 and last_runs_to_eof
@@ -107,23 +113,52 @@ def main() -> int:
             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)
-        # the closing fps puts the sped-up frames back on the source's grid with its frame
+        # the closing fps puts the sped-up frames back on the delivered grid with its frame
         # duration: concat starts the next segment after the last frame's duration, which setpts
         # leaves at the unscaled 1/rate, so every 2x segment pushed the rest of the picture two
         # frames late against the sound (and added those frames)
-        vparts.append(f"[0:v]{vtrim},setpts=PTS/{factor:.6f},{frame_durations(meta, rate)}[{vlabel}]")
-        labels.append(f"[{vlabel}]")
+        vchain = f"[0:v]{vtrim},setpts=PTS/{factor:.6f},{frame_durations(meta, out_rate)}"
+        achain = f"[0:a]{atrim},{atempo_chain(factor)}"
+        if out_rate:
+            # Each segment holds the frames (and samples) between its retimed ends on the whole
+            # output's grid, not its own length rounded: eight 0.5 s segments at 27 fps rounded
+            # to 14 frames each, concat advanced 14/27 s per segment and the last flash landed
+            # 130 ms late. The picture is sampled on the output's grid (an offset of under half
+            # a frame, and fps's start_time) and, but for a last segment that runs to the end,
+            # padded by a frame or two and cut to its count; the sound is padded or cut to its
+            # own count, so neither stream drifts across segments.
+            first = round(retimed * out_rate)
+            shift = first / out_rate - retimed
+            vchain = (f"[0:v]{vtrim},setpts=PTS/{factor:.6f}{-shift:+.6f}/TB,"
+                      f"{frame_durations(meta, out_rate)}:start_time=0")
+            if seg_end is not None:
+                after = retimed + (seg_end - bounds[i]) / factor
+                vchain += f",tpad=stop=2:stop_mode=clone,trim=end_frame={round(after * out_rate) - first}"
+                if srate:
+                    achain += f",{conform_filter(round(after * srate) - round(retimed * srate), srate)}"
+                retimed = after
+        vparts.append(f"{vchain}[{vlabel}]")
         if has_audio:
-            aparts.append(f"[0:a]{atrim},{atempo_chain(factor)}[{alabel}]")
-
+            aparts.append(f"{achain}[{alabel}]")
+
+    # the two streams are joined by two concats: one concat over both started each segment after
+    # the longer of its two streams, so a picture a frame longer than its sound moved both late
+    n = len(segments)
+    # Every segment's picture is a whole count of frames on one grid, so the joined picture's
+    # timestamps are rebuilt from the running frame count: FFmpeg 6.1.1's video-only concat gave a
+    # one-frame segment no length (it takes a segment's end from its last frame's timestamp), so
+    # three one-frame segments put the rest of the picture a frame before its sound. The closing
+    # fps gives the frames their durations back (from 7.0 setpts leaves them 0, frame_durations)
+    regrid = ""
+    if out_rate:
+        grid = frame_durations(meta, out_rate)
+        q = Fraction(grid[len("fps="):]) if "/" in grid else Fraction(out_rate).limit_denominator(1001)
+        regrid = f",setpts=N*{q.denominator}/({q.numerator}*TB),{grid}"
+    fc = ";".join(vparts) + ";" + "".join(f"[v{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=0{regrid}[outv]"
+    maps = ["-map", "[outv]"]
     if has_audio:
-        concat_inputs = "".join(f"[v{i}][a{i}]" for i in range(len(segments)))
-        fc = ";".join(vparts + aparts) + f";{concat_inputs}concat=n={len(segments)}:v=1:a=1[outv][outa]"
-        maps = ["-map", "[outv]", "-map", "[outa]"]
-    else:
-        concat_inputs = "".join(f"[v{i}]" for i in range(len(segments)))
-        fc = ";".join(vparts) + f";{concat_inputs}concat=n={len(segments)}:v=1:a=0[outv]"
-        maps = ["-map", "[outv]"]
+        fc += ";" + ";".join(aparts) + ";" + "".join(f"[a{i}]" for i in range(n)) + f"concat=n={n}:v=0:a=1[outa]"
+        maps += ["-map", "[outa]"]
 
     cmd = ffmpeg_base() + ["-i", args.input, "-filter_complex", fc] + maps
     cmd += video_args(meta, args.crf, args.preset)

package/scripts/sphere.py

@@ -33,7 +33,7 @@ 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_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, emit, ffmpeg_base, info, probe, run_keeping_subtitles, video_args, X264_PRESETS, fmt_secs
 from _common.emit import note
 
 # v360's own AVOption names for the input projections real 360 cameras/exports actually
@@ -124,7 +124,7 @@ def main() -> int:
             f"yaw={args.yaw:g}:pitch={args.pitch:g}:roll={args.roll:g}:"
             f"h_fov={args.h_fov:g}:v_fov={args.v_fov:g}:"
             f"w={args.width}:h={args.height}:interp={args.interp}")
-    cmd = ffmpeg_base() + ["-i", args.input, "-vf", v360, "-map", "0:v:0"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr(v360, meta, args.fps), "-map", "0:v:0"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]
     cmd += video_args(meta, args.crf, args.preset)

package/scripts/stabilize.py

@@ -29,7 +29,7 @@ from pathlib import Path
 
 from _common.probe import PROBED_VIDEO
 from _common.runner import ffmpeg_failure_extra, default_selection_maps, require_filter
-from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, emit, escape_filter_path, ffmpeg_base, info, probe, require_tool, run, video_args, X264_PRESETS, run_analysis, dry_run_input_pending, fmt_secs, record_fallback, EVEN_SCALE
+from _common import add_common, apply_common, aac_args, cfr_args, with_cfr, default_output, die, emit, escape_filter_path, ffmpeg_base, info, probe, require_tool, run, video_args, X264_PRESETS, run_analysis, dry_run_input_pending, fmt_secs, record_fallback, EVEN_SCALE
 
 
 def main() -> int:
@@ -104,7 +104,7 @@ def main() -> int:
             # Equivalent to relative=0:smoothing=0 -- overrides --smoothing, since averaging a
             # camera path makes no sense once every frame is locked to one fixed reference.
             transform_vf += ":tripod=1"
-        cmd = ffmpeg_base() + ["-i", args.input] + default_selection_maps(meta, output) + ["-vf", transform_vf]
+        cmd = ffmpeg_base() + ["-i", args.input] + default_selection_maps(meta, output) + ["-vf", with_cfr(transform_vf, meta)]
         cmd += video_args(meta, args.crf, args.preset)
         cmd += cfr_args(meta)
         if has_audio:

package/scripts/straighten.py

@@ -22,7 +22,7 @@ import argparse
 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 import add_common, apply_common, aac_args, cfr_args, with_cfr, 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
 
@@ -100,7 +100,7 @@ def main() -> int:
     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"]
+    cmd = ffmpeg_base() + ["-i", args.input, "-vf", with_cfr(rotate, meta, args.fps), "-map", "0:v:0"]
     if has_audio:
         cmd += ["-map", f"0:a:{args.audio_stream}?"]
     cmd += video_args(meta, args.crf, args.preset)