ffmpeg-skill 3.1.1 → 3.1.3

package/scripts/caption.py

@@ -44,7 +44,7 @@ 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
-from _common import 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, load_brand, 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
+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, load_brand, 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
 # 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
@@ -78,10 +78,27 @@ TIME_RE = re.compile(
 )
 
 
+# an SRT timing line: the times alone, the cue text on the lines after it
+DROP_FRAME_RE = re.compile(r"^\s*\d+:\d{2}:\d{2};\d+")
+SRT_TIMING_RE = re.compile(r"^\s*\d+:\d{2}:\d{2}[,.]\d+\s*-->\s*\d+:\d{2}:\d{2}[,.]\d+\s*$")
+
+
 def parse_text_cues(path: str, auto_seconds: float, gap: float, fps: Optional[float] = None) -> List[Tuple[float, float, str]]:
     cues: List[Tuple[float, float, str]] = []
     cursor = 0.0
-    for raw in read_text_or_die(path, "--text").lstrip("\ufeff").splitlines(True):
+    lines = read_text_or_die(path, "--text").lstrip("\ufeff").splitlines(True)
+    for n, raw in enumerate(lines, 1):
+        if SRT_TIMING_RE.match(raw.rstrip("\r\n")):
+            # a cue file puts the text on the line with its times; this line has the times alone, so
+            # the file is an SRT. Read as a cue file, its numbers and timing lines would be burned in
+            # as captions, auto-timed 3 s apart (#396)
+            die(f"--text: {path} is an SRT file (line {n} is a timing line with no text: "
+                f"'{raw.strip()}'); pass it as --srt (render.py: --srt, not --cues)", kind="input")
+        if DROP_FRAME_RE.match(raw):
+            # TIME_RE has no ';', so the line would be burned as caption text, auto-timed
+            die(f"--text: line {n} has a drop-frame timecode (';'), which is not read: write it as "
+                "hh:mm:ss:ff@29.97 or in seconds", kind="input")
+    for raw in lines:
         line = raw.rstrip("\n")
         if not line.strip():
             continue
@@ -200,7 +217,7 @@ def plan_emoji(cues, args, play_w, play_h, brand=None):
         return cues, None
     assets = resolve_emoji_assets(getattr(args, "emoji_assets", None), None, brand)
     want = getattr(args, "emoji", "auto")
-    support = emoji_support(assets, probe=True)
+    support = emoji_support(assets, probe=True, fonts_dir=getattr(args, "fonts_dir", None))
     mode = support["mode"] if want == "auto" else want
     if want == "color" and not support["libass_color"]:
         die("--emoji color: this ffmpeg renders emoji monochrome through libass "
@@ -208,6 +225,13 @@ def plan_emoji(cues, args, play_w, play_h, brand=None):
             kind="input")
     if want == "png" and not assets:
         die("--emoji png: no emoji assets directory resolved -- " + EMOJI_ASSET_HINT, kind="input")
+    # --emoji mono asks for the font's glyph, and there is none: empty boxes (tofu) are a failed job
+    # (#395). An auto run takes mode "none" instead, as on a machine with no emoji face at all,
+    # and says why below; --emoji mono never uses assets, so they do not save it
+    if want == "mono" and support.get("libass_glyph") is False:
+        die(f"--emoji mono: this ffmpeg draws no emoji glyph through libass ({support['detail']}), so "
+            f"{len(clusters_all)} emoji would come out as empty boxes -- pass --emoji-assets DIR for colour, "
+            "or --emoji none to leave them out of the drawn text", kind="input")
     plan = {"mode": mode, "count": len(clusters_all),
             "clusters": sorted({emoji_codepoint_name(cl) for cl in clusters_all}),
             "assets": assets, "missing": [], "overlays": []}
@@ -217,7 +241,14 @@ def plan_emoji(cues, args, play_w, play_h, brand=None):
             for cl in {cl for _i, cl in emoji_clusters(text)}:
                 text = text.replace(cl, "")
             out.append((start, end, re.sub(r"[ \t]{2,}", " ", text).strip()))
-        info("emoji: stripped from the drawn text (--emoji none)")
+        if want == "auto":
+            why = ("libass draws no emoji glyph on this build (an empty box at best)"
+                   if support.get("libass_glyph") is False else "no face here draws them")
+            msg = (f"emoji: {len(clusters_all)} left out of the drawn text: {why} -- pass --emoji-assets DIR "
+                   "to draw them as PNGs")
+            warn(msg, "emoji_not_drawn", count=len(clusters_all), reason=support.get("detail"))
+        else:
+            info("emoji: stripped from the drawn text (--emoji none)")
         return out, plan
     if mode in ("color", "mono"):
         if mode == "mono":
@@ -1097,6 +1128,10 @@ def main() -> int:
             die(f"--audio-stream {args.audio_stream}: input has {len(audio_streams)} audio stream(s), 0..{len(audio_streams) - 1}")
         if args.audio_stream and not audio_streams:
             die("--audio-stream needs an input with audio streams")
+        if args.mode != "mux":
+            # before any transcription or sidecar: a build without libass fails these at parse time
+            # with a message that names no filter (#393), so ask the build first, dry run included
+            require_filter("ass" if (args.ass or args.animate != "none" or args.karaoke) else "subtitles", "burning captions")
     fps_for_tc = args.fps
     if fps_for_tc is None and meta is not None:
         fps_for_tc = meta.get("video", {}).get("fps")
@@ -1586,8 +1621,11 @@ def main() -> int:
             side_notes.append(msg)
         caption_stats["cues_burned"] = burned
         caption_stats["cues_outside"] = outside
+    require_filter("ass" if args.ass else "subtitles", "burning captions")
+    # the path as a named option: with a positional first value a build without the filter fails at
+    # parse time ("No option name near ...") instead of saying "No such filter" (#393)
     if args.ass:
-        vf = f"ass={escape_filter_path(args.ass)}"
+        vf = f"ass=filename={escape_filter_path(args.ass)}"
         if args.fonts_dir:
             vf += f":fontsdir={escape_filter_path(args.fonts_dir)}"
     else:
@@ -1608,7 +1646,7 @@ def main() -> int:
             f"MarginV={args.margin}",
         ]
         force = ",".join(style).replace("\\", "\\\\").replace("'", "\\'")
-        vf = f"subtitles={escape_filter_path(srt_path)}:force_style='{force}'"
+        vf = f"subtitles=filename={escape_filter_path(srt_path)}:force_style='{force}'"
         if args.fonts_dir:
             vf += f":fontsdir={escape_filter_path(args.fonts_dir)}"
     if generated_ass or not args.ass:

package/scripts/cut.py

@@ -61,7 +61,7 @@ from typing import List, Tuple
 from _common import (beat_grid, snap_points, decode_pcm_mono, rms_envelope, BEAT_MIN_CONFIDENCE)
 from _common import require_tool
 from _common.probe import TS_EXTS, signatures_match, stream_signature
-from _common import 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, 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
 
 # outputs whose re-encode dropped a subtitle/data stream (reported as dropped_non_av_streams)
 DROPPED_STREAMS: List[str] = []
@@ -1706,9 +1706,20 @@ def main() -> int:
     # selection writes one of each, so that is the count; the source's own picture/sound gap is
     # the reference for the lengths check
     expect_streams = {"video": int(bool(meta.get("video")) and not is_audio_output(output)), "audio": int(bool(meta.get("audio")))}
+    # cut writes one audio track (ffmpeg's default selection, on a stream copy as on a re-encode):
+    # a source with more must say which ones did not come along (#397), as export.py's non_av_streams does
+    src_audio = meta.get("audio_streams") or []
+    out_audio = (result.get("audio_streams") or []) if not STATE.dry_run else src_audio[:1]
+    dropped_audio = len(src_audio) - len(out_audio) if src_audio else 0
+    if dropped_audio > 0:
+        kept = len(out_audio)
+        msg = (f"the source has {len(src_audio)} audio tracks; this cut kept {kept} and left {dropped_audio} out "
+               f"(cut writes one audio track, on a stream copy as on a re-encode)")
+        warn(msg, "audio_tracks_dropped", source=len(src_audio), kept=kept, dropped=dropped_audio)
+        notes.append(msg)
     emit(output, expected_duration=round(expected, 6), duration_error_ms=error_ms, precision=precision, reencoded=reencoded,
          expect_streams=expect_streams, stream_reference=[meta], stream_windows=[(s, e) for s, e in requested],
-         dropped_non_av_streams=bool(DROPPED_STREAMS),
+         dropped_non_av_streams=bool(DROPPED_STREAMS), dropped_audio_streams=max(dropped_audio, 0),
          requested_start=round(requested[0][0], 6) if len(requested) == 1 else None,
          requested_end=round(requested[0][1], 6) if len(requested) == 1 else None,
          requested_segments=[[round(s, 6), round(e, 6)] for s, e in requested] if len(requested) > 1 else None,

package/scripts/graphics.py

@@ -32,7 +32,7 @@ import sys
 from typing import List, Optional, Tuple
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, safe_margins_px, resolve as resolve_platform
-from _common import (aac_args, add_common, brand_caption_style, script_font_for_text, apply_common, cfr_args,
+from _common import (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, label_chain, load_brand, parse_time, probe, rgb_chain_to_bt709, run, run_keeping_subtitles, video_args,
                      drawtext_boxborderw, drawtext_center_align, X264_PRESETS, time_arg, fmt_secs, STATE, drawtext_text_opts,
@@ -237,13 +237,18 @@ def main(force_route: Optional[str] = None) -> int:
     emoji_mode = None
     emoji_overlays: List[dict] = []
     if has_emoji(all_text):
-        support = emoji_support(emoji_assets, probe=True)
+        _ff = args.font_file or brand.get("font_file")
+        support = emoji_support(emoji_assets, probe=True, fonts_dir=os.path.dirname(os.path.abspath(_ff)) if _ff else None)
         emoji_mode = support["mode"] if args.emoji == "auto" else args.emoji
         if args.emoji == "color" and not support["libass_color"]:
             die("--emoji color: this ffmpeg renders emoji monochrome through libass "
                 f"({support['detail']}) -- pass --emoji-assets DIR for colour, or --emoji mono", kind="input")
         if args.emoji == "png" and not emoji_assets:
             die("--emoji png: no emoji assets directory resolved -- " + EMOJI_ASSET_HINT, kind="input")
+        if args.emoji == "mono" and support.get("libass_glyph") is False:
+            die("--emoji mono: this ffmpeg draws no emoji glyph through libass "
+                f"({support['detail']}), so they would come out as empty boxes -- pass --emoji-assets DIR "
+                "for colour, or --emoji none", kind="input")
     if args.text_render == "drawtext" and shaping:
         die(f"{LANGUAGE_NAMES.get(_script, _script)} text cannot be shaped by drawtext on any ffmpeg "
             "build (the marks are reordered by harfbuzz, which drawtext does not use): drop "
@@ -642,6 +647,7 @@ def main(force_route: Optional[str] = None) -> int:
                             "assets": emoji_assets, "missing": missing,
                             "overlays": len(emoji_overlays)}
         ass_path = args.write_ass or os.path.splitext(output)[0] + "_gfx.ass"
+        require_filter("ass", "drawing this text through libass")  # before the sidecar is written
         if STATE.dry_run:
             info(f"[dry-run] would write {ass_path} ({len(elements)} text elements)")
         else:
@@ -682,7 +688,7 @@ def main(force_route: Optional[str] = None) -> int:
         chains = list(fc) if fc else [f"[0:v]{text or 'null'}[vout]"]
         last = "vout"
         if route == "ass":
-            vf = f"ass={escape_filter_path(ass_path)}"
+            vf = f"ass=filename={escape_filter_path(ass_path)}"
             fdir = ass_fonts_dir()
             if fdir:
                 vf += f":fontsdir={escape_filter_path(fdir)}"

package/scripts/grid.py

@@ -29,6 +29,8 @@ from _common import add_common, apply_common, aac_args, cfr_args, default_output
     draws_chroma, drawn_chain, escape_drawtext, ffmpeg_base, info, label_chain, matrix_chain, probe, run, validate_color, video_args
 from _common.fonts import font_choice, record_font_choice
 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
 
 LABEL_MARGIN = 10
 
@@ -56,6 +58,13 @@ def main() -> int:
     add_common(ap)
     args = ap.parse_args()
     apply_common(args)
+    if args.label == "auto" and ffmpeg_filters() and "drawtext" not in ffmpeg_filters():
+        # the labels are the only drawtext in the grid: without the filter (Homebrew's plain
+        # ffmpeg) draw the grid unlabelled and say so, as look.py does for its stamps (#394)
+        args.label = "none"
+        record_fallback("this ffmpeg build has no drawtext filter, so the cells are not labelled "
+                        "(the same as --label none)", "grid_no_drawtext")
+        note("no cell labels: this ffmpeg build has no drawtext filter (" + filter_missing_hint("drawtext") + ")")
 
     n = args.cols * args.rows
     if args.cols <= 0 or args.rows <= 0:

package/scripts/look.py

@@ -19,6 +19,8 @@ from typing import List, Optional
 from _platforms import PLATFORMS, PLATFORM_CHOICES, resolve as resolve_platform
 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 drawtext_fontfile  # noqa: E402
+from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
+from _common.emit import note, record_fallback  # noqa: E402
 
 FONT = "fontcolor=white:fontsize=h/18:box=1:boxcolor=black@0.55:boxborderw=6:x=8:y=8"
 
@@ -162,6 +164,14 @@ def main() -> int:
     # a resolvable font file, given as fontfile=, is the only form confirmed not to crash drawtext's
     # own fontconfig resolution on some real Windows ffmpeg builds (#100); font= is the fallback when
     # nothing can be resolved, unchanged from before this existed.
+    if not args.no_timecode and ffmpeg_filters() and "drawtext" not in ffmpeg_filters():
+        # a build without drawtext (Homebrew's plain ffmpeg) cannot stamp the timecodes, but the
+        # sheet itself only needs tile: draw it without them and say so, rather than failing the
+        # step every picture change ends with (#394)
+        args.no_timecode = True
+        record_fallback("this ffmpeg build has no drawtext filter, so the sheet has no timecode stamps "
+                        "(the same as --no-timecode)", "look_no_drawtext")
+        note("no timecode stamps: this ffmpeg build has no drawtext filter (" + filter_missing_hint("drawtext") + ")")
     if args.no_timecode:
         font_prefix, tc = "", ""   # nothing is drawn, so no font is resolved or copied
     else:

package/scripts/scenes.py

@@ -27,6 +27,8 @@ from _common import (guard_sidecar, detect_scenes, STATE, add_common, apply_comm
                      ffmpeg_base, info, print_json, probe, run, decode_pcm_mono,
                      rms_envelope, BEAT_MIN_CONFIDENCE, decode_gray_frames, frame_flow, label_shot_flow)
 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
 
 SHOT_FPS = 4.0          # frames/second sampled for --shots' flow estimate
 SHOT_W, SHOT_H = 48, 27  # decode size for --shots (16:9-ish; enough blocks, still a few KB/shot)
@@ -287,6 +289,13 @@ def main() -> int:
         fps = meta["video"].get("fps") or 30.0
         expr = "+".join(f"eq(n\\,{int(round(sc['start'] * fps))})" for sc in scenes)
         stamp = ""
+        if not args.no_timecode and ffmpeg_filters() and "drawtext" not in ffmpeg_filters():
+            # as look.py (#394): the sheet needs drawtext only for its stamps
+            args.no_timecode = True
+            record_fallback("this ffmpeg build has no drawtext filter, so the --sheet has no timecode stamps "
+                            "(the same as --no-timecode)", "scenes_sheet_no_drawtext")
+            note("--sheet without timecode stamps: this ffmpeg build has no drawtext filter ("
+                 + filter_missing_hint("drawtext") + ")")
         if not args.no_timecode:
             default_font = default_font_file("DejaVu Sans")
             font_prefix = f"{drawtext_fontfile(default_font)}:" if default_font else ""
@@ -297,7 +306,7 @@ def main() -> int:
         info(f"wrote {args.sheet}")
         result["sheet"] = args.sheet
 
-    if args.json:
+    if STATE.json:  # --json-brief too: emit() is what adds the diagnostics (scenes_sheet_no_drawtext)
         emit(None, **result)
     else:
         print_json(result)