ffmpeg-skill 3.8.16 → 3.8.17

package/scripts/_common/wrap.py

@@ -282,16 +282,32 @@ def _slice_atom(atom: str, max_em: float) -> "List[str]":
     No dictionary, no hyphenation library: an existing hyphen is preferred as the cut (the same
     break R1 already allows), then whatever is left is cut again at exactly the widest prefix
     that still measures within `max_em`, one character at a time. The characters themselves are
-    never rewritten -- every piece concatenates back to the original atom exactly."""
-    if text_width_em(atom) <= max_em:
-        return [atom]
-    for i in range(len(atom) - 2, 0, -1):
-        # latest hyphen whose left side still fits -- keeps the left half as large as possible
-        if atom[i] in _HYPHENS and text_width_em(atom[:i + 1]) <= max_em:
-            return [atom[:i + 1]] + _slice_atom(atom[i + 1:], max_em)
+    never rewritten -- every piece concatenates back to the original atom exactly.
+
+    Iterative, and each piece measures only the prefixes up to the first that is too wide (a
+    prefix is never narrower than a shorter one): the recursive form measured every prefix of the
+    remaining atom for each piece it cut, so a 1 KB hyphenated cue took seconds and 4 KB minutes
+    (A11, #465), in caption.py's own process, which --timeout (a limit on each ffmpeg call) does
+    not bound. The pieces are the ones the recursive form cut."""
     pieces: "List[str]" = []
+    rest = atom
+    while True:
+        # latest hyphen whose left side still fits -- keeps the left half as large as possible;
+        # a rest whose every prefix fits, itself included, is the last piece
+        cut = 0
+        for end in range(1, len(rest) + 1):
+            if text_width_em(rest[:end]) > max_em:
+                break
+            if 1 <= end - 1 <= len(rest) - 2 and rest[end - 1] in _HYPHENS:
+                cut = end
+        else:
+            return pieces + [rest]
+        if not cut:
+            break
+        pieces.append(rest[:cut])
+        rest = rest[cut:]
     cur = ""
-    for ch in atom:
+    for ch in rest:
         candidate = cur + ch
         if cur and text_width_em(candidate) > max_em:
             pieces.append(cur)

package/scripts/_contract.py

@@ -436,6 +436,7 @@ ERROR_REASONS = {
     "output_is_directory": "the output path is a directory; details: {output}",
     "media_path_is_playlist": "an input is a playlist that ffmpeg would follow to the files or URLs it names: HLS .m3u8/.m3u or an ffconcat list (by name or by its first bytes), a DASH manifest or an IMF composition playlist (by name or by the content ffmpeg's own probe looks for, whatever the file is called); the skill takes media files only; details: {path}",
     "media_path_has_line_break": "a path written into a concat list (loop.py, join.py --copy, sequence.py, multi-part cuts) contains a line break, which the concat format cannot hold: each line is a directive, so the name would add entries to the list; details: {path}",
+    "still_unreadable": "an input read by an image demuxer (a .png, .jpg, ... name) has a picture stream with no frame size: the file is not an image ffmpeg can decode (a text file named .png); details: {path, format, codec}",
     "media_path_not_a_file": "an input exists but is not a regular file (a FIFO or a device), which ffmpeg would block on or read as a stream; details: {path}",
     "join_copy_mismatch": "join.py --copy: a clip's streams do not match the first clip's, it hides pre-roll frames with an edit list, or its picture and sound end more than 50 ms apart; details: {clips: [{index?, path, differs}]}",
     "output_path_taken": "two files one run writes (a side file and the output, or two side files) resolve to the same path, so the second would replace the first; details: {output, other}",
@@ -446,7 +447,7 @@ ERROR_REASONS = {
     "output_dir_not_writable": "the output's directory is not writable; details: {output, directory}",
     "output_container_codecs": "a .webm output whose command encodes video or sound WebM cannot hold (H.264/HEVC, AAC; WebM takes VP8/VP9/AV1 and Opus/Vorbis), refused before ffmpeg runs; details: {output, container, encoders}",
     "timemap_path_taken": "silence.py --timemap names the same file as -o, --edl or --plan; details: {timemap, flag, path}",
-    "output_locked": "another run holds the output's lock; details: {lock, output, pid, pid_alive, deadline, why}",
+    "output_locked": "another run holds the output's lock, or is taking a stale one over (why: takeover_in_progress), or a stale lock cannot be taken over safely because the filesystem gives no OS file lock (why: takeover_unavailable: delete it by hand); details: {lock, output, pid, pid_alive, deadline, why}",
     "plan_inputs_changed": "render.py PLAN: a fingerprinted input is missing or changed; details: {plan, plan_sha256, checked_at, "
                            "inputs: [{path, status: unchanged|changed|missing, expected: {size, sha256_head_tail}, actual: {size, "
                            "sha256_head_tail} | \"missing\"}], unbound_inputs, audit_log}",
@@ -1943,6 +1944,11 @@ MCP_PROMPTS: List[Dict[str, Any]] = [
                      "to keep HDR and only drop the Dolby Vision layer, when strip_dovi is asked for). A flat, washed-out "
                      "look after a re-encode usually means HDR metadata was lost upstream; `probe` shows `hdr: true` "
                      "only for a real PQ/HLG/Dolby Vision signal, and `bt2020_or_hdr: true` also for BT.2020 SDR."),
+        # A23 (#465): strip_dovi was taken and changed nothing; true now asks for the other recipe
+        "flags": {"strip_dovi": (
+            "Keep {input} HDR and drop only its Dolby Vision layer: `color.py {input} --strip-dovi`, a stream copy "
+            "(HEVC only) that removes the Dolby Vision RPU so players use the HLG/HDR10 base layer. A source with no "
+            "Dolby Vision metadata gets a `dovi_not_detected` warning.")},
     },
 ]
 
@@ -1968,7 +1974,17 @@ def mcp_prompt_get(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
     fields: Dict[str, str] = {a["name"]: str((arguments or {}).get(a["name"]) or a.get("default", "")) for a in prompt["arguments"]}
     for opt_name, clause in prompt["optional"].items():
         fields[opt_name] = clause.format(**fields) if fields.get(opt_name) else ""
-    text = prompt["template"].format(**fields)
+    template = prompt["template"]
+    for flag, flag_template in (prompt.get("flags") or {}).items():
+        # a yes/no argument picks the recipe; every prompt argument arrives as a string, so
+        # "false" is no, and a value that is neither is a caller mistake (ValueError, as above)
+        value = (arguments or {}).get(flag)
+        word = str(value).strip().lower() if value is not None else ""
+        if word in ("true", "1", "yes"):
+            template = flag_template
+        elif word not in ("", "false", "0", "no"):
+            raise ValueError(f"prompt {name!r}: {flag} must be true or false, got {value!r}")
+    text = template.format(**fields)
     return {"description": prompt["description"], "messages": [{"role": "user", "content": {"type": "text", "text": text}}]}
 
 

package/scripts/batch.py

@@ -699,10 +699,15 @@ def main() -> int:
     created = [d for d in (outdir, work) if not d.exists()]
     outdir.mkdir(parents=True, exist_ok=True)
     work.mkdir(parents=True, exist_ok=True)
-    if STATE.dry_run and created:
+    # a real run that is refused before any item starts (--jobs, an output collision, a final path
+    # that is an input) leaves nothing behind either (A187, #465: it left out/ and out/.work)
+    item_started = {"item": False}
+    if created:
         import atexit
 
         def _remove_empty_dirs() -> None:
+            if not STATE.dry_run and item_started["item"]:
+                return
             for d in sorted(created, key=lambda p: len(str(p)), reverse=True):
                 try:
                     if not any(d.iterdir()):
@@ -850,6 +855,7 @@ def main() -> int:
         def run_item(i: int, src: Path) -> Dict[str, Any]:
             """process() in the item's own work directory, which goes when it ends, however it ends."""
             import shutil
+            item_started["item"] = True
             iw = item_work(i, src)
             try:
                 return process(src, recipe, outdir, iw, deadline)

package/scripts/caption.py

@@ -55,7 +55,7 @@ from _common import asr as _asr
 from _common.asr import ENGINE_CHOICES
 from _common.emit import warn
 from _common.probe import display_size, square_pixels, square_pixels_note
-from _common.runner import carried_stream_maps, subtitle_codec_for, subtitle_container_holds
+from _common.runner import carried_stream_maps, refuse_output_is_input, same_file, subtitle_codec_for, subtitle_container_holds
 from _common.fonts import font_choice, record_font_choice
 from _common import (ASR_INSTALL_HINT, die_no_engine, parse_srt, transcribe, whisper_word_timings,
                      write_srt)
@@ -1586,9 +1586,12 @@ def main() -> int:
             up_front.append((args.write_ass or os.path.splitext(planned_out)[0] + ".ass", "ASS"))
         if args.ass and args.offset and os.path.exists(args.ass):
             up_front.append((os.path.splitext(planned_out)[0] + "_offset.ass", "offset ASS"))
-        # -o naming the input itself keeps its own, more specific refusal (_check_no_overwrite_input)
-        if os.path.realpath(planned_out) != os.path.realpath(args.input):
-            up_front.append((planned_out, "video"))
+        # -o naming the input (the same name, a hard link, another case on a case-insensitive
+        # volume) is refused here, before any sidecar or transcript is written: run()'s own guard
+        # came after the .srt was already beside it (review of #530)
+        if same_file(planned_out, args.input):
+            refuse_output_is_input(planned_out, args.input, why="the captioned video would replace the source")
+        up_front.append((planned_out, "video"))
     claim(up_front)
     if args.transcribe:
         # the sidecar goes next to the output like the --text one, not into the source folder

package/scripts/metadata.py

@@ -219,8 +219,11 @@ def main() -> int:
     args = ap.parse_args()
     apply_common(args)
     if args.auto_chapters:  # the only mode that writes them
-        guard_sidecar(args.chapters_out, args.input, siblings=(args.description_out, args.output))
-        guard_sidecar(args.description_out, args.input, siblings=(args.output,))
+        # against the video this run writes, the default name too (A6, #465: --chapters-out at
+        # input_meta.mp4 wrote the chapter text over the video it had just written)
+        video_out = args.output or default_output(args.input, "meta", Path(args.input).suffix.lstrip(".") or "mp4")
+        guard_sidecar(args.chapters_out, args.input, siblings=(args.description_out, video_out))
+        guard_sidecar(args.description_out, args.input, siblings=(video_out,))
 
     if args.chapters and args.clear_chapters:
         die("--chapters and --clear-chapters exclude each other")

package/scripts/render.py

@@ -76,7 +76,7 @@ from export import PRESETS, PLATFORM_OF
 from _platforms import PLATFORMS, caption_defaults, resolve as resolve_platform
 from _common import guard_sidecar, STATE, add_common, aspect_ratio, brand_caption_style, load_brand, apply_common, child_args, die, emit as _emit, info, option_args, probe, require_tool, run, run_tool, place_output, refuse_output_is_input, _check_existing_output, _check_output_path, fingerprint, PLAN_VERSION, ffmpeg_version, X264_PRESETS
 from _common.runner import HW_ENV, HW_FORCED_ENV, add_hw_orchestrator_args, child_exit_code, found_exe, kept_clause, kept_deliverables, mark_delivered, owned_identity, read_json, remember_written
-from _common.emit import absorb_stage, audit, record_fallback, record_skip, refuse, warn
+from _common.emit import absorb_stage, audit, is_output_shape_flag, record_fallback, record_skip, refuse, stderr_records, warn
 from _common.decision import rebase_project_paths
 import subprocess
 from _contract import CONTRACT_VERSION
@@ -405,9 +405,7 @@ def render_pack(names: List[str], args) -> int:
             doc = {}
         # the child ran with --json, so its planned commands come back in the document: the pack
         # is the one path that writes seven files, and --dry-run has to show all of them
-        for line in proc.stderr.splitlines():
-            if line.startswith("$ ") or line.startswith("[dry-run]"):
-                STATE.commands.append(line[2:] if line.startswith("$ ") else line)
+        STATE.commands.extend(text for is_command, text in stderr_records(proc.stderr) if is_command)
         STATE.commands.extend(str(c) for c in (doc.get("commands") or []))
         absorb_stage(name, doc)
         out = doc.get("output") or dest_out
@@ -806,9 +804,9 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
     cmd = [str(HERE / script)] + [str(a) for a in argv] + (extra or []) + own + child_args() + ["--json"]
     info("→ " + " ".join(os.path.basename(c) if i < 1 else c for i, c in enumerate(cmd[:-1])))
     proc = run_tool(cmd)
-    for line in proc.stderr.splitlines():
-        if line.startswith("$ ") or line.startswith("[dry-run]"):
-            STATE.commands.append(line[2:] if line.startswith("$ ") else line)
+    for is_command, line in stderr_records(proc.stderr):
+        if is_command:
+            STATE.commands.append(line)
         elif line.strip():
             info("    " + line)
     try:
@@ -1212,7 +1210,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
         os.chdir(plan["cwd"])
     if not isinstance(plan.get("argv"), list):
         _reject_plan(path, digest, "plan_argv_invalid", f"{path}: argv must be a list", argv_type=type(plan.get("argv")).__name__)
-    argv = [str(a) for a in plan["argv"]]
+    # a plan an earlier version recorded with --json-brief (A181): the tool is run for its full
+    # document, as every plan written now asks for
+    argv = [str(a) for a in plan["argv"] if not is_output_shape_flag(str(a))]
     if STATE.dry_run:
         for c in plan.get("commands") or []:
             STATE.commands.append(c)
@@ -1226,9 +1226,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
         return 0
     info(f"executing plan {path}: {tool} " + " ".join(argv))
     proc = run_tool([str(script)] + argv + child_args() + ["--json"])
-    for line in proc.stderr.splitlines():
-        if line.startswith("$ "):
-            STATE.commands.append(line[2:])
+    for is_command, line in stderr_records(proc.stderr):
+        if is_command and not line.startswith("[dry-run]"):
+            STATE.commands.append(line)
         elif line.strip():
             info("    " + line)
     try:

package/scripts/silence.py

@@ -29,7 +29,7 @@ from _common import (filler_spans, FILLER_WORDS, FILLER_AMBIGUOUS, FILLER_DISCOU
 from _common import asr as _asr
 from _common.emit import warn
 from _common.asr import _dicts
-from _common.runner import parse_json, replace_checked
+from _common.runner import parse_json, replace_checked, same_file
 from _common import guard_sidecar, refuse_existing_outputs, refuse_output_is_input, _check_output_path
 from _common.emit import refuse
 from _common import detect_silences as detect, STATE, add_common, apply_common, default_output, die, emit, info, is_audio_output, print_json, probe, X264_PRESETS, measured_level_dbfs, fmt_secs
@@ -672,7 +672,7 @@ def main() -> int:
         # --overwrite allows replacing an old map, never the source, the cut or the EDL
         refuse_output_is_input(args.timemap, *[p for p in (args.input, args.words, args.filler_words) if p])
         for flag, other in (("-o", args.output), ("--edl", args.edl), ("--plan", getattr(args, "plan", None))):
-            if other and os.path.realpath(other) == os.path.realpath(args.timemap):
+            if other and same_file(other, args.timemap):
                 refuse("input", "timemap_path_taken",
                        f"--timemap {args.timemap} is the same file as {flag}; give the map its own path",
                        timemap=args.timemap, flag=flag, path=other)

package/scripts/verify.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from _common import STATE, add_common, apply_common, die, emit, guard_sidecar, info, probe, refuse_output_is_input, MEDIA_EXT as _MEDIA_EXT
+from _common.runner import _stop_child, _unwatch, _watch
 
 HERE = Path(__file__).resolve().parent
 # _common's one list less the stills, as batch.py walks a folder: verify kept a list of its own,
@@ -140,13 +141,24 @@ def step(name: str, argv: List[str], timeout: float) -> Dict:
         if not ok:
             r.update(kind="verification", reason="hdr_lost", message=r["error"])
         return r
+    child = subprocess.Popen([sys.executable, str(HERE / argv[0])] + argv[1:] + _forwarded(argv) + ["--json"], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace")
+    # watched like run_tool()'s child (review of #530): a SIGTERM or Ctrl-C to verify.py stops the
+    # step through stop_children() -- its own handler removes its partial output and lock --
+    # instead of leaving it running and writing after verify.py has exited
+    _watch(child, [])
     try:
-        proc = subprocess.run([sys.executable, str(HERE / argv[0])] + argv[1:] + _forwarded(argv) + ["--json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                              text=True, encoding="utf-8", errors="replace", timeout=timeout or None)
+        out, err = child.communicate(timeout=timeout or None)
+        proc = subprocess.CompletedProcess(child.args, child.returncode, out, err)
     except subprocess.TimeoutExpired:
+        # stopped as run_tool() stops a sibling script past its ceiling (#465 A183's sweep): the
+        # SIGKILL subprocess.run() sent left the step's partial output and output lock in --out
+        _stop_child(child)
         msg = f"timeout after {timeout:.0f}s"
         return {"step": name, "ok": False, "seconds": round(time.time() - t0, 1), "error": msg,
                 "kind": "timeout", "reason": "step_timeout", "message": msg}
+    finally:
+        _unwatch(child)
     try:
         doc = json.loads(proc.stdout)
     except ValueError:
@@ -198,10 +210,27 @@ def main() -> int:
     files = collect(args.paths)
     FORWARD.update(overwrite=STATE.overwrite, fast=STATE.fast)
     tmp = None
+    started = {"step": False}
     if args.out:
         # made first, so a --report inside a new --out folder passes the guard below (#413 review)
         outdir = Path(args.out)
+        made = [d for d in (outdir, *outdir.parents) if not d.exists()]
         outdir.mkdir(parents=True, exist_ok=True)
+        if made:
+            import atexit
+
+            def _remove_unused_dirs() -> None:
+                # a run refused before its first step (a --report guard) leaves no empty --out
+                # folder behind, as batch.py leaves no out/ (#465 A187's sibling); once a step has
+                # run the folder is the caller's, empty or not
+                if started["step"]:
+                    return
+                for d in made:  # deepest first
+                    try:
+                        d.rmdir()
+                    except OSError:
+                        pass
+            atexit.register(_remove_unused_dirs)
     if args.report:
         # a file this run writes itself (#408): not one of the media it verifies (a folder's
         # files included), nor an existing file without --overwrite
@@ -301,6 +330,7 @@ def main() -> int:
             refuse_output_is_input(out, *every_input, why=f"it is where verify writes the {name!r} step's output for {str(f)!r}")
 
     results = []
+    started["step"] = True
     for f, entry, plan, cues in jobs:
         info(f"=== {f}")
         if cues: