ffmpeg-skill 3.8.12 → 3.8.14

package/scripts/caption.py

@@ -37,17 +37,16 @@ import json
 import os
 import re
 import sys
-import unicodedata
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from _platforms import (PLATFORMS, PLATFORM_CHOICES, ASS_SCRIPT_HEIGHT, ass_units,
                         resolve as resolve_platform)
-from _ass_overlay import (EMOJI_SENTINEL, emoji_placeholder, ass_escape, ass_escape_markup,
+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, ADVANCE_EM, LATIN_EM, NO_SPACE_SCRIPTS, _char_em, char_script, text_width_em, emoji_clusters, has_emoji, detect_script, BIDI_SCRIPTS, STATE, brand_states_font, script_font_for_text, signed_time_arg, brand_caption_style, color_hex, drawn_chain, label_chain, layer_base_chain, load_brand, 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_srt_time, fmt_smpte_time, info, MissingFpsError, parse_time, probe, run, x264_args, X264_PRESETS, read_text_or_die, fmt_secs, refuse_existing_outputs, guard_sidecar
+from _common import require_filter, emoji_filter_chain, EMOJI_ASSET_HINT, emoji_asset_for, emoji_codepoint_name, emoji_support, resolve_emoji_assets, 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
 # 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

package/scripts/check.py

@@ -50,10 +50,10 @@ from typing import Any, Dict, List, Optional, Tuple
 from _platforms import PLATFORMS, PLATFORM_CHOICES, TP_TOLERANCE_DB, spec_of, upload_limit_note, resolve as resolve_platform
 from _common.probe import (CHANGE_FLOOR, CHANGE_GRID, change_mask_tiles, change_tiles, LEGAL_RANGE_CHOICES, measure_signal_range, COMPARE_SSIM_WARN, CONTENT_FLAT_STD, SILENT_PEAK_DBFS, compare_pictures, detect_content,
                            detect_flashes, first_frame_stats, presentation_times, measured_level_dbfs)
-from _common.emit import file_identity
+from _common.emit import file_identity, own_length
 from _common.probe import PROBED_AUDIO
 from _common.probe import display_size as shown_size, shorter_than_a_loudness_block
-from _common import STATE, add_common, apply_common, die, emit, info, probe, require_tool, run, run_analysis, dry_run_input_pending
+from _common import STATE, add_common, apply_common, die, emit, probe, require_tool, run_analysis, dry_run_input_pending
 
 # The one delivery table (scripts/_platforms.py): check.py's rows, export.py's presets and the
 # render.py templates all read it, so a platform's loudness spec is stated once. Only the
@@ -618,7 +618,7 @@ def main() -> int:
                 row("true peak", "WARN", "could not measure", f"<= {spec['tp']:g} dBTP", "re-run check.py, or verify true peak manually",
                     reason="ffmpeg's loudness measurement didn't produce a readable result -- this was not actually checked")
             elif (lm and lm["lufs"] == float("-inf") and lm["tp"] > SILENT_PEAK_DBFS
-                  and shorter_than_a_loudness_block(a.get("duration") or a.get("tagged_duration") or dur_read)):
+                  and shorter_than_a_loudness_block(own_length(a) or dur_read)):
                 # A257: shorter than one 400 ms gating block: a true peak but no integrated
                 # loudness. Not silence, and not a -inf LUFS that FAILs the target. Decided on
                 # the sound's length: a longer track whose every block is under the gate reads

package/scripts/color.py

@@ -581,7 +581,13 @@ def main() -> int:
         else:
             vf = hdr_to_sdr_chain(meta, args.tonemap, args.peak, args.desat)
             sdr_path = "tonemap"
-            sdr_note = f"tone-mapped {v.get('hdr_format') or 'untagged input as PQ (--force)'} to SDR BT.709 with {args.tonemap}"
+            # the note names what hdr_to_sdr_chain read the source as: its own tags, PQ / BT.2020
+            # only where a tag is missing. Through 3.8.8 any non-HDR file was called "untagged
+            # input as PQ", a BT.709-tagged one included, which the chain linearised as BT.709 (A161)
+            read_as = v.get("hdr_format") or (
+                f"a non-HDR input read as transfer {v.get('color_transfer') or 'smpte2084 (untagged, taken as PQ)'}, "
+                f"primaries {v.get('color_primaries') or 'bt2020 (untagged)'} (--force)")
+            sdr_note = f"tone-mapped {read_as} to SDR BT.709 with {args.tonemap}"
         info(f"note: {sdr_note}")
         sdr_extra = {"sdr_path": sdr_path, "notes": [sdr_note]}
         output = args.output or default_output(args.input, "sdr")

package/scripts/crop.py

@@ -12,7 +12,8 @@ The rectangle must lie entirely inside the source frame after accounting for
 any display rotation, and --width/--height must be even (required for 4:2:0
 chroma subsampling, the pixel format every encoder here uses) -- given values
 are validated and refused, never silently rounded, since a caller-specified
-rectangle should do exactly what was asked or fail loudly.
+rectangle should do exactly what was asked or fail loudly. An odd --x/--y is
+taken as given (the crop starts on that pixel), not moved to the chroma grid.
 
 Examples:
   python3 crop.py input.mp4 --x 100 --y 0 --width 1080 --height 1920
@@ -63,7 +64,7 @@ def main() -> int:
 
     output = args.output or default_output(args.input, "crop")
     # exact=1: without it crop rounds an odd --x/--y down to the chroma grid of a 4:2:0 frame,
-    # and the rectangle written was one pixel left of / above the one asked for (A170's sibling)
+    # and the rectangle written was one pixel left of / above the one asked for (A170's sibling, A157)
     vf = [f"crop={args.width}:{args.height}:{args.x}:{args.y}:exact=1", "setsar=1"]
     if square_pixels(meta["video"]):
         vf.insert(0, square_pixels(meta["video"]))

package/scripts/cropdetect.py

@@ -33,7 +33,7 @@ import sys
 from collections import Counter
 from typing import Dict, List, Optional, Tuple
 
-from _common import add_common, apply_common, die, emit, info, print_json, probe, require_tool, run_analysis, decode_gray_frames, frame_flow
+from _common import add_common, apply_common, die, emit, info, print_json, probe, require_tool, run_analysis, decode_gray_frames
 from _common.emit import note, warn
 from _common.probe import PROBED_VIDEO, display_size, square_pixels, square_pixels_note
 

package/scripts/cut.py

@@ -56,7 +56,7 @@ import os
 import sys
 import tempfile
 import zlib
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from _common.runner import ffmpeg_failure_extra, JsonTooDeep, fail_if_classified, read_json
 from _common import (beat_grid, snap_points, decode_pcm_mono, rms_envelope, BEAT_MIN_CONFIDENCE)
@@ -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, MissingFpsError, 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, 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] = []
@@ -81,12 +81,27 @@ def _t(value: str, fps, flag: str = "--segments") -> float:
     return time_arg(value, flag, fps)
 
 
-def keep_ranges_after_removing(removed: List[Tuple[float, float]], total: float, fps=None) -> List[Tuple[float, float]]:
+def keep_ranges_after_removing(removed: List[Tuple[float, float]], total: float, fps=None,
+                               picture: Optional[Tuple[float, float]] = None,
+                               dropped: Optional[List[Tuple[float, float]]] = None) -> List[Tuple[float, float]]:
     """--remove: what is left of [0, total] once `removed` is dropped (merged where they overlap,
     clamped to the file). A leftover shorter than one frame (10 ms without a frame rate) is not a
-    piece anyone asked to keep. Refuses a removal that would leave nothing."""
+    piece anyone asked to keep. With `picture` (where the video starts and ends, for a video
+    output), neither is a leftover that holds less than one frame of it: sound before the first
+    frame or after the last (a track that outlasts its picture) has no picture to cut, and was
+    kept and then refused as a segment the caller never gave (#462 A51). Such leftovers are added
+    to `dropped`. Refuses a removal that would leave nothing."""
     least = 1.0 / fps if fps else 0.01
     keep, cursor = [], 0.0
+
+    def add(a: float, b: float) -> None:
+        if b - a < least:
+            return
+        if picture is not None and min(b, picture[1]) - max(a, picture[0]) < least - 1e-6:
+            if dropped is not None:
+                dropped.append((a, b))
+            return
+        keep.append((a, b))
     outside = [(s, e) for s, e in removed if min(total, e) <= min(total, max(0.0, s))]
     if outside:
         die("--remove " + ", ".join(f"{s:g}-{e:g}" for s, e in outside) + f" lies outside the file (0-{total:.3f}s), "
@@ -94,12 +109,14 @@ def keep_ranges_after_removing(removed: List[Tuple[float, float]], total: float,
     for s, e in sorted((min(total, max(0.0, s)), min(total, e)) for s, e in removed):
         if e <= cursor:
             continue
-        if s - cursor >= least:
-            keep.append((cursor, s))
+        add(cursor, s)
         cursor = max(cursor, e)
-    if total - cursor >= least:
-        keep.append((cursor, total))
+    add(cursor, total)
     if not keep:
+        if dropped:
+            die(f"--remove leaves only sound with no picture ({', '.join(f'{a:.3f}-{b:.3f}s' for a, b in dropped)}, "
+                f"outside the video's {picture[0]:.3f}-{picture[1]:.3f}s); nothing with a picture would be left to keep. "
+                "Write the sound out with an audio -o (e.g. -o part.wav) instead", kind="input")
         die(f"--remove drops the whole file ({total:.3f}s); nothing would be left to keep")
     return keep
 
@@ -277,11 +294,12 @@ def source_skew(src: str, meta: dict, t: float) -> float:
 
 def video_end(src: str, meta: dict):
     """Where the video stream ends on the cut's clock (seconds from the file's start), or None when
-    the stream's length is unknown."""
-    v = meta.get("video") or {}
-    if not v.get("duration"):
-        return None
-    return (v.get("start_time") or 0.0) + v["duration"] - file_origin(src)
+    the stream's length is unknown. A Matroska/WebM stream states no duration, only its DURATION
+    tag, which is already that end (own_end()); read from `duration` alone, a .mkv had no picture
+    end and --remove kept a sound-only leftover past it."""
+    from _common.emit import own_end
+    end = own_end(meta.get("video"))
+    return None if end is None else end - file_origin(src)
 
 
 _SEEK_SHIFTS: dict = {}
@@ -893,9 +911,12 @@ def cut_one(src: str, start: float, end: float, dst: str, reencode: bool, crf: i
         if is_audio_output(dst) or not meta.get("video"):
             # -ss before -i seeks, then decoding discards samples up to the exact start
             # (accurate_seek); atrim bounds the decoded stream to the requested length at sample
-            # resolution.
+            # resolution. The input seek counts from the file's start, so a sound that starts after
+            # it (late against its picture) arrives at its offset from `start`; it is padded with
+            # silence from 0, as the --segments re-cut pads it (av_trim), not rebased to its own
+            # first sample, which moved it earlier and made the cut shorter than asked (#462 A46)
             cmd = ffmpeg_base() + ["-ss", f"{start:.6f}", "-i", src, "-t", f"{dur:.6f}"] + stream_maps(meta, dst, copy=False)
-            cmd += ["-af", f"atrim=end={dur:.6f},asetpts=PTS-STARTPTS"]
+            cmd += ["-af", f"atrim=end={dur:.6f},aresample=async=1:first_pts=0"]
         else:
             # Seek SEEK_MARGIN early, then drop the margin on the output side, which decodes and
             # discards it from both streams alike. An input seek straight to `start` can land (the
@@ -1515,6 +1536,7 @@ def main() -> int:
         forced.append("codec")
 
     fps = (meta.get("video") or {}).get("fps")
+    remove_notes: List[str] = []
     if args.remove:
         if args.segments or args.end or args.duration or args.start is not None:
             die("--remove names what to drop from the whole file: it does not combine with --segments, --start, --end or --duration")
@@ -1525,7 +1547,18 @@ def main() -> int:
         if not total:
             die(f"--remove needs the input's duration, which {args.input} does not report"
                 + (" yet (it is an earlier step's output)" if dry_run_input_pending(args.input) else ""))
-        args.segments = ",".join(f"{s:.6f}-{e:.6f}" for s, e in keep_ranges_after_removing(parse_segments(args.remove, fps, clamp=True), total, fps))
+        picture = None
+        if (meta.get("video") or {}).get("fps") and not is_audio_output(args.output or "") and not dry_run_input_pending(args.input):
+            vend = video_end(args.input, meta)
+            if vend is not None:
+                picture = ((meta["video"].get("start_time") or 0.0) - file_origin(args.input), vend)
+        sound_only: List[Tuple[float, float]] = []
+        args.segments = ",".join(f"{s:.6f}-{e:.6f}" for s, e in keep_ranges_after_removing(
+            parse_segments(args.remove, fps, clamp=True), total, fps, picture, sound_only))
+        for a, b in sound_only:
+            remove_notes.append(f"--remove left {a:.3f}-{b:.3f}s, which holds sound but no frame of the picture "
+                                f"(the video runs {picture[0]:.3f}-{picture[1]:.3f}s); it is not kept")
+            info(remove_notes[-1])
     elif args.segments and (args.end or args.duration or args.start is not None):
         # A50: the single-range flags were accepted beside --segments and not read, where --remove
         # refuses the same combination
@@ -1588,7 +1621,7 @@ def main() -> int:
     # clean copy). clip_length's rule, as join.py uses it: less than a frame past -> end the
     # segment with its picture; more -> hold the last frame for the sound, which only a re-cut
     # can do. The last segment is left as the source had it: nothing is placed after it.
-    join_notes: List[str] = []
+    join_notes: List[str] = list(remove_notes)
     hold_needed = False
     vend = (video_end(args.input, meta) if len(segments) > 1 and video.get("fps") and not is_audio_output(output)
             and not dry_run_input_pending(args.input) else None)

package/scripts/export.py

@@ -43,6 +43,7 @@ import re
 import os
 import sys
 import tempfile
+from fractions import Fraction
 from pathlib import Path
 from typing import Dict, List, Optional
 
@@ -51,8 +52,8 @@ from _common import STATE, run_analysis, add_common, apply_common, bt709_label_f
 from _common.decision import 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, run_analysis as _run_analysis, subtitle_codec_for
-from _common.emit import file_identity, input_length
+from _common.runner import ffmpeg_encoders, guard_sidecar, remember_written, replace_checked, replace_checked_together, reserve_sibling, subtitle_codec_for
+from _common.emit import file_identity, input_length, own_length
 from check import SPECS as PLATFORMS, measure_loudness
 from _common.probe import SILENT_PEAK_DBFS, shorter_than_a_loudness_block
 from _platforms import ALIASES as _ALIASES, PLATFORMS as PLATFORM_TABLE, TP_TOLERANCE_DB, UPLOAD_LIMITS_AS_OF, resolve as resolve_platform
@@ -254,7 +255,7 @@ def _key_fill(args, p: Dict, meta: Dict, output: str, cmd: List[str], vf: List[s
     pair = {k: [fv.get(k), kv.get(k)] for k in ("width", "height", "nb_frames", "r_frame_rate")}
     # the video streams' lengths: the fill's container also counts its sound, which may run longer
     # than the picture, and the key has none
-    pair["duration"] = [round(v.get("duration") or v.get("tagged_duration") or 0, 3) for v in (fv, kv)]
+    pair["duration"] = [round(own_length(v) or 0, 3) for v in (fv, kv)]
     same = all(a == b and a not in (None, 0) for a, b in pair.values())
     # the two written files against each other: no expected value, so no provenance (#403: it said
     # "output_measurement", which is not one of the contract's values)
@@ -442,6 +443,32 @@ SIZE_MIN_VIDEO_KBPS = 100   # below this the picture is not worth delivering; re
 SIZE_MAX_VIDEO_KBPS = 400_000  # 400 Mb/s: above any delivery line, and libx264 refuses far larger values
 
 
+def _platform_rate_args(preset: str, meta: Dict) -> List[str]:
+    """A platform preset that keeps the source's frame rate (the youtube family) conforms a source
+    faster than the platform's fps_max to the source rate divided by the smallest whole number that
+    brings it within the limit (120 -> 60, 119.88 -> 59.94, 100 -> 50), so every frame of the
+    output is one of the source's own. Through 3.8.8 a 120 fps source kept 120 fps and the
+    platform's own check FAILed the export (audit A115). [] when the preset has no limit or the
+    source is within it (cfr_args() then decides, as before)."""
+    platform = PLATFORM_OF.get(preset)
+    fps_max = (PLATFORMS.get(platform) or {}).get("fps_max") if platform else None
+    v = meta.get("video") or {}
+    src = v.get("fps")
+    if not fps_max or not src or src <= fps_max + 0.01:
+        return []
+    try:
+        exact = Fraction(v.get("avg_frame_rate") or "0")
+    except (ValueError, ZeroDivisionError):
+        exact = Fraction(0)
+    if not exact or abs(float(exact) - src) > 0.01:
+        exact = Fraction(src).limit_denominator(1001)
+    n = math.ceil(float(exact) / (fps_max + 0.01))
+    rate = exact / n
+    note(f"source is {src:g} fps, above {platform}'s limit of {fps_max:g}: exported at {float(rate):.6g} fps, "
+         f"one source frame in {n}")
+    return ["-fps_mode", "cfr", "-r", str(rate.numerator) if rate.denominator == 1 else f"{rate.numerator}/{rate.denominator}"]
+
+
 def size_video_args(args, video: List[str], p: Dict, meta: Dict, has_audio: bool) -> List[str]:
     """--max-mb: the preset's x264 line with its CRF replaced by the bitrate that fits the size,
     for a two-pass encode. Refused where that cannot be done honestly: another codec, --crf, --hw,
@@ -669,7 +696,7 @@ def main() -> int:
         # 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
         if "-r" not in video:
-            cmd += cfr_args(meta)
+            cmd += _platform_rate_args(args.preset, meta) or cfr_args(meta)
         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"):
@@ -741,7 +768,7 @@ def main() -> int:
         m = measure_loudness(output)
         written_audio = probe(output, role="output").get("audio") or {}
         if (m and not math.isfinite(m["lufs"]) and math.isfinite(m["tp"]) and m["tp"] > SILENT_PEAK_DBFS
-                and shorter_than_a_loudness_block(written_audio.get("duration") or written_audio.get("tagged_duration"))):
+                and shorter_than_a_loudness_block(own_length(written_audio))):
             # A257: too short for a gating block is not silent (it has a measured peak); a longer
             # track under the gate is not "too short" and takes the path it took before
             _loudness_unmeasured(extra, notes, platform, spec, tp=m["tp"])
@@ -767,7 +794,13 @@ def main() -> int:
                 # a private name: <stem>_loudnorm.<ext> is loudness.py's own default output, so a
                 # real file of that name next to the export was overwritten and renamed away (review 7)
                 tmp = str(Path(output).with_name(f".{Path(output).stem}.normalize-{os.getpid()}{Path(output).suffix}"))
-                proc = run_tool([str(HERE / "loudness.py"), output, "-I", f"{spec['lufs']:g}", "--tp", f"{spec['tp']:g}", "-o", tmp, "--json"] + child_args())
+                # under --max-mb the sound is re-encoded at the bitrate the size budget was built on
+                # (the preset's); loudness.py's own 192k, raised to 256k/320k on an overshoot, put
+                # the file over the limit it had been encoded to meet (through 3.8.8, audit A112)
+                pinned = (["--audio-bitrate", p["audio"][p["audio"].index("-b:a") + 1]]
+                          if args.max_mb is not None and "-b:a" in p["audio"] else [])
+                proc = run_tool([str(HERE / "loudness.py"), output, "-I", f"{spec['lufs']:g}", "--tp", f"{spec['tp']:g}", "-o", tmp, "--json"]
+                                + pinned + child_args())
                 try:
                     child = json.loads(proc.stdout)
                 except ValueError:

package/scripts/fit.py

@@ -34,14 +34,13 @@ Examples:
   python3 fit.py input.mp4 --flip h                              # mirror horizontally
 """
 import argparse
-import math
 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.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, parse_time, probe, run, run_keeping_subtitles, validate_color, x264_args, pad_filters, add_pad_fill_args, X264_PRESETS, time_arg, fmt_secs, frame_size, display_size, square_pixels, square_pixels_note, note
+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.emit import input_length
 BLUR_DARKEN = 0.15  # how much --fit blur dims the blurred background copy (eq brightness)
 
@@ -227,7 +226,9 @@ def main() -> int:
                 # after it (a B-frame HEVC source) and lose the frames before it, so the first
                 # picture would not be the one the start timecode below names
                 m = min(SEEK_MARGIN, round(start, 3))
-                pre_input += ["-ss", f"{start - m:.3f}"]
+                # a trim from the start seeks nowhere: no -ss, so the timeline stays where it is and
+                # a subtitle/data track is kept below (`-ss 0.000` dropped it, A158)
+                pre_input += ["-ss", f"{start - m:.3f}"] if round(start, 3) > 0 else []
                 # without sound the -t only counts frames (picture_output_t). Not from the centre:
                 # there the output's clock starts at the seek, between two frames, and the encoder
                 # rounds each frame to its own tick

package/scripts/freeze.py

@@ -20,7 +20,7 @@ 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, MissingFpsError, time_arg, fmt_secs, run
+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.emit import input_length
 
 

package/scripts/graphics.py

@@ -38,11 +38,11 @@ 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,
                      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, parse_time, probe, rgb_chain_to_bt709, run, run_keeping_subtitles, video_args,
+                     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,
                      LANGUAGE_NAMES, needs_shaping, detect_script, BIDI_SCRIPTS, font_family_of_file, font_family_for_script, has_emoji,
                      emoji_clusters, emoji_codepoint_name, char_script, emoji_filter_chain, emoji_asset_for, emoji_support, resolve_emoji_assets,
-                     EMOJI_ASSET_HINT, text_width_em, drawtext_shaping, wrap_text, WRAP_MODES,
+                     EMOJI_ASSET_HINT, text_width_em, wrap_text, WRAP_MODES,
                      SAFE_WIDTH_FRACTION, drawtext_draws_newline_glyph, is_multiline, _DRAWTEXT_PENDING)
 from _common.emit import note, warn
 from _common.alpha import (add_alpha_args, audio_line, check_alpha_args, decoder_args_for, default_ext, finish_chain,
@@ -429,7 +429,6 @@ def main(force_route: Optional[str] = None) -> int:
         el["text"] = text
         elements.append(el)
 
-    extra_inputs: List[str] = []
     fc: List[str] = []  # filter_complex chains (used by templates that need animated boxes)
     if 0 < min(W, H) < 64:  # 0x0 is a dry-run probe of an intermediate that does not exist yet
         die(f"the frame is {W}x{H}; the templates are sized from it and need at least 64 px on the short side")

package/scripts/insert.py

@@ -28,7 +28,7 @@ import math
 import sys
 
 from _common import still_input_args  # noqa: E402
-from _common import add_common, apply_common, default_output, die, emit, ffmpeg_base, info, parse_time, probe, run, video_args, X264_PRESETS, time_arg, fmt_secs
+from _common import add_common, apply_common, default_output, die, emit, ffmpeg_base, info, probe, run, video_args, X264_PRESETS, time_arg, fmt_secs
 from _common.emit import note
 from _common.probe import display_size, square_pixels, square_pixels_note
 

package/scripts/look.py

@@ -19,7 +19,7 @@ from typing import List, Optional
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, resolve as resolve_platform
 from _common import still_input_args  # noqa: E402
-from _common import STATE, require_tool, add_common, apply_common, default_font_file, die, emit, escape_drawtext, ffmpeg_base, info, parse_time, probe, run, run_analysis, time_arg
+from _common import STATE, require_tool, add_common, apply_common, default_font_file, die, emit, escape_drawtext, ffmpeg_base, info, probe, run, run_analysis, time_arg
 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
@@ -30,6 +30,8 @@ from _common.emit import input_length  # noqa: E402
 # --guides: broadcast safe areas as outlines, in fractions of the frame (a tile as much as a frame).
 # Action and title safe are SMPTE ST 2046-1's 93 % and 90 % of a 16:9 picture; the 4:3 centre cut
 # is the 4:3 window of a 16:9 frame with SD's own 90 % action / 80 % title safe inside it.
+# the extensions an -o is taken verbatim with (one picture); any other -o is a stem
+IMAGE_EXTS = (".png", ".jpg", ".jpeg", ".webp")
 GUIDES = {"action": 0.93, "title": 0.90}
 GUIDE_43 = {"action": 0.90, "title": 0.80}
 GUIDE_COLOURS = {"action": "yellow", "title": "cyan", "4:3": "white"}
@@ -319,7 +321,7 @@ def main() -> int:
         csq = (square_pixels(cmeta.get("video")) + ",") if square_pixels(cmeta.get("video")) else ""
         for idx, t in enumerate(args.at):
             sec = time_arg(t, "--at", meta["video"].get("fps") if meta.get("video") else None)
-            if args.output and len(args.at) == 1:
+            if args.output and len(args.at) == 1 and Path(args.output).suffix.lower() in IMAGE_EXTS:
                 out = args.output  # one frame, one named image file: the caller's -o is the contract
             else:
                 # several frames, or -o given as a stem/prefix: an occurrence index keeps every
@@ -352,7 +354,7 @@ def main() -> int:
             sec = time_arg(t, "--at", meta["video"].get("fps") if meta.get("video") else None)
             if dur and sec > dur:
                 die(f"--at {t} is beyond the duration ({dur:.2f}s)")
-            if args.output and len(args.at) == 1 and Path(args.output).suffix.lower() in (".png", ".jpg", ".jpeg", ".webp"):
+            if args.output and len(args.at) == 1 and Path(args.output).suffix.lower() in IMAGE_EXTS:
                 out = args.output  # one frame, one named image file: the caller's -o is the contract
             else:
                 # several frames, or -o given as a stem/prefix without an image extension
@@ -382,7 +384,10 @@ def main() -> int:
             info(f"only {frames_avail} frame(s) available; sheet reduced to {cols}x{rows}")
         step = dur / n
         tile_w = max(2, (args.width // cols) // 2 * 2)
-        out = args.output or os.path.join(outdir, f"{stem}_sheet.png")
+        # -o without an image extension is a stem here too (<stem>_sheet.png), as for --at and
+        # --compare: given verbatim, ffmpeg could not choose a muxer for it (kind ffmpeg, A159)
+        out = (args.output if args.output and Path(args.output).suffix.lower() in IMAGE_EXTS
+               else os.path.join(outdir, f"{(args.output and Path(args.output).stem) or stem}_sheet.png"))
         # sample at the middle of each slice so the first/last tiles are not black lead-in/out frames
         # with only a handful of frames a mid-slice seek skips past them all: start at 0 instead
         seek = 0.0 if frames_avail < 4 else step / 2

package/scripts/loop.py

@@ -32,11 +32,11 @@ 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, parse_time, 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, 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
-from _common.emit import input_length
+from _common.emit import input_length, own_length
 
 
 # The loop filter's size is capped at 32767 frames, so one boomerang cycle (2N-2 frames) must fit.
@@ -131,7 +131,7 @@ def _conformed_frames(v, rate: float, src_dur: float) -> int:
     its length are counted in these, or a repeat is a frame or more off the length planned."""
     # the video stream's length, else Matroska's tag, else the container's (main() refuses a source
     # without one): never the stored frame count, which is what fps= does not keep
-    d = v.get("duration") or v.get("tagged_duration") or src_dur
+    d = own_length(v) or src_dur
     return int(round(float(d) * rate))
 
 

package/scripts/loudness.py

@@ -24,8 +24,9 @@ from _platforms import TP_TOLERANCE_DB
 AUDIO_LENGTH_TOLERANCE = 0.03  # seconds: one AAC frame at 48 kHz is 0.021 s
 LUFS_TOLERANCE = 1.0  # LU: a normalised file within this of the requested -I is on target
 from _common.probe import PROBED_AUDIO, probed_maps, shorter_than_a_loudness_block
-from _common.emit import refuse
+from _common.emit import own_length, refuse
 from _common.runner import ffmpeg_failure_extra
+from _common.decision import LOSSLESS_AUDIO_EXT
 from _common import STATE, add_common, apply_common, emit, AUDIO_CODECS, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, run_keeping_subtitles, dry_run_input_pending
 
 
@@ -113,15 +114,15 @@ def loudnorm_mode(stats: dict, lufs: float, tp: float, lra: float) -> str:
 
 def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output: str) -> dict:
     """One normalised file at `lufs` / `tp_max`, measured after: the keys emit() takes for it."""
-    af = (
-        f"loudnorm=I={lufs}:TP={tp_max}:LRA={args.lra}"
-        f":measured_I={stats['input_i']}:measured_TP={stats['input_tp']}:measured_LRA={stats['input_lra']}"
-        f":measured_thresh={stats['input_thresh']}:offset={stats['target_offset']}:linear=true:print_format=summary"
-    )
     sr = args.sample_rate or meta["audio"].get("sample_rate") or 48000
     ext = os.path.splitext(output)[1].lower()
     bitrate_pinned = args.audio_bitrate is not None
-    bitrate = args.audio_bitrate or "192k"
+    # an AAC audio extension starts at its own rate (256k for .m4a/.aac), which is what it was
+    # written at: a pinned --audio-bitrate and the raised retries below never reached it, so the
+    # retries re-encoded at 256k and audio_bitrate_used said 192k, then 256k and 320k (A143)
+    codec = AUDIO_CODECS.get(ext, [])
+    own_rate = codec[codec.index("-b:a") + 1] if "aac" in codec and "-b:a" in codec else None
+    bitrate = args.audio_bitrate or own_rate or "192k"
 
     dropped_streams = False
     # loudnorm emits its last block whole, and through the AAC encoder that came out as 0.1 s more
@@ -142,7 +143,9 @@ def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output
             af += f",atrim=duration={float(in_audio):.6f}"
         cmd = ffmpeg_base() + ["-i", args.input, "-af", af, "-ar", str(sr)]
         if ext in AUDIO_CODECS or not meta.get("video"):
-            cmd += ["-map", f"0:{PROBED_AUDIO}", "-vn"] + audio_codec_for(output, bitrate)
+            # the rate reaches an audio extension's codec when it was pinned or is AAC's (an
+            # .mp3/.ogg/.opus left alone keeps its own setting, as it always has)
+            cmd += ["-map", f"0:{PROBED_AUDIO}", "-vn"] + audio_codec_for(output, bitrate if ext not in AUDIO_CODECS or bitrate_pinned or own_rate else None)
         else:
             cmd += probed_maps(meta) + ["-c:v", "copy", "-c:a", "aac", "-b:a", bitrate]
             if ext in (".mp4", ".mov", ".m4v"):
@@ -185,7 +188,8 @@ def _normalize(args, meta: dict, stats: dict, lufs: float, tp_max: float, output
         info(f"result:   {float(after['input_i']):.1f} LUFS, TP {float(after['input_tp']):.1f} dBTP (target {lufs} LUFS, TP <= {tp_max:g})")
     result = {k: after[k] for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset", "silent")}
     result["tp_ceiling_used"] = round(ceiling, 2)
-    if ext not in AUDIO_CODECS or "aac" in AUDIO_CODECS[ext]:
+    if ext not in AUDIO_CODECS or "aac" in AUDIO_CODECS[ext] or bitrate_pinned:
+        # a pinned rate reaches an .mp3/.ogg/.opus codec too (A143); unpinned, those keep their own
         result["audio_bitrate_used"] = bitrate
     result["encodes"] = rounds + 1
     # the mode of the last encode: its ceiling is the one the file was made with
@@ -277,7 +281,8 @@ def main() -> int:
     ap.add_argument("--tp", type=float, default=-1.0, help="true peak ceiling in dBTP (default -1)")
     ap.add_argument("--lra", type=float, default=11.0, help="loudness range target in LU (default 11)")
     ap.add_argument("--measure-only", action="store_true", help="print the measured stats as JSON and exit")
-    ap.add_argument("--audio-bitrate", default=None, help="AAC bitrate when the container is video (default 192k; raised to 256k/320k only when the encoder overshoots the true-peak ceiling and you did not pin it)")
+    ap.add_argument("--audio-bitrate", default=None, help="audio bitrate: AAC's in a video container (default 192k), and the codec's of a lossy audio output (.m4a/.aac default 256k, .mp3/.ogg/.opus their own setting); "
+                         "refused for .wav/.flac. Raised to 256k/320k for AAC only when the encoder overshoots the true-peak ceiling and you did not pin it")
     ap.add_argument("--versions", metavar="LIST",
                     help="write one normalised file per target from this master, each measured after: a comma list of "
                          + ", ".join(f"{n} ({i:g} LUFS / {t:g} dBTP)" for n, (i, t) in VERSION_TARGETS.items())
@@ -303,6 +308,10 @@ def main() -> int:
     meta = probe(args.input)
     if not meta.get("audio"):
         die("input has no audio stream")
+    out_ext = os.path.splitext(args.output or default_output(args.input, "loudnorm"))[1].lower()
+    if args.audio_bitrate is not None and not args.measure_only and out_ext in LOSSLESS_AUDIO_EXT:
+        # A143: the rate was dropped without a word; a lossless codec has none to set
+        die(f"--audio-bitrate has no effect on a lossless {out_ext} output; drop it, or write a lossy one (.m4a, .mp3, ...)")
     if plan is not None and not args.measure_only:
         # each version measures the master against its own target (loudnorm's offset depends on
         # it): a pass against -I/--tp first would be one more full decode whose result is unused
@@ -349,8 +358,7 @@ def audio_length(meta: dict) -> "Optional[float]":
     """The sound's own length: the stream's duration, else Matroska's DURATION tag. Never the
     container's, which is the picture's when the picture runs longer (and would fail a correct
     output against an expected length the sound never had)."""
-    audio = meta.get("audio") or {}
-    return audio.get("duration") or audio.get("tagged_duration")
+    return own_length(meta.get("audio"))
 
 
 def _kbps(value: str) -> int: