ffmpeg-skill 3.8.19 → 3.8.21

package/scripts/render.py

@@ -75,9 +75,9 @@ from typing import Any, Dict, List, Optional, Sequence
 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.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, refuse_missing_components_first, remember_written, with_flags, kept_output, unwatch_destination, watch_destination
 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
+from _common.decision import brand_asset_files, rebase_project_paths
 import subprocess
 from _contract import CONTRACT_VERSION
 from batch import file_key
@@ -803,6 +803,14 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
         info(f"    {os.path.basename(str(dest))} is an earlier render's own stage file in {_OWN_STAGES['dir']}, unchanged since: replaced")
     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])))
+    # a stage that writes outside the work directory (the export writes the delivery itself): what
+    # is there now, so a stop while it runs reports a file the stage wrote as kept, not "nothing
+    # was written", and never claims the caller's own file (#510)
+    # the delivery itself is watched wherever --work is (a --work that holds the output's folder
+    # made the export look like an intermediate, #510 review)
+    outside = bool(dest) and (not _in_work(dest) or _is_delivery(dest))
+    if outside:
+        watch_destination(dest)
     proc = run_tool(cmd)
     for is_command, line in stderr_records(proc.stderr):
         if is_command:
@@ -825,7 +833,7 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
             # a stage after the delivery (chapters, check): the stage's own "nothing was written"
             # is about its own file, while the delivery is on disk (#415)
             why = why.replace("; nothing was written", "") + f" ({kept_clause()})"
-            extra_fields.setdefault("output", kept_deliverables()[-1])
+            extra_fields.setdefault("output", kept_output())
         elif err.get("kind") in ("timeout", "interrupted") and doc.get("output") and os.path.isfile(str(doc["output"])):
             # the stage was stopped after writing its own deliverable and kept it (export.py's
             # --normalize pass): its message says so, and the file is this run's output too
@@ -843,11 +851,64 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
         # otherwise refuse as an existing file without --overwrite (#415).
         remember_written(out_path, dest)
         _record_own_stage_file(dest)
+    if outside:
+        unwatch_destination(dest)
     if key:
         cache_store(stage, key, out_path or (dest or ""), time.time() - started, doc)
     return out_path
 
 
+WORK_DIR: Dict[str, Optional[str]] = {"path": None}
+DELIVERY: Dict[str, Optional[str]] = {"path": None}  # the render's output path, set in main()
+
+
+def _is_delivery(path: str) -> bool:
+    return bool(DELIVERY["path"]) and os.path.realpath(path) == os.path.realpath(str(DELIVERY["path"]))
+
+
+def _in_work(path: str) -> bool:
+    """Whether `path` is inside this render's work directory."""
+    work = WORK_DIR["path"]
+    if not work:
+        return False
+    return os.path.realpath(path).startswith(os.path.realpath(work) + os.sep)
+
+
+SRT_TRIM_TOLERANCE = 0.25  # seconds the delivery may be shorter than the captioned stage before its SRT is called off-timeline
+
+
+def deliver_caption_srt(target: Optional[str], made: Optional[Dict[str, Any]], output: str) -> Optional[str]:
+    """Put the captions stage's generated SRT at `target` (<output>.srt, guarded before the first
+    stage) and return the path, or None with a skip record when it is not delivered: the stage was
+    served from the cache (the cache keeps the video only), or a later stage changed the timeline
+    (the export trimmed the delivery to a platform's maximum), where the SRT's times are no longer
+    the delivery's (#510). Under --dry-run the planned path."""
+    if not target or not made:
+        return None
+    if STATE.dry_run:
+        info(f"[dry-run] would deliver the captions' SRT as {target}")
+        return target
+    if made.get("cached") or not os.path.isfile(made["srt"]):
+        record_skip(f"the captions stage's SRT is not delivered: the stage was served from --cache, which keeps its video only",
+                    "caption_srt_not_delivered", reason="cached", path=target)
+        return None
+    trimmed = _LAST_DOC.get("trimmed") if _LAST_DOC.get("trimmed") else None
+    if not trimmed:
+        before = (probe(made["video"], role="output").get("duration") if os.path.isfile(made["video"]) else None) or 0.0
+        after = probe(output, role="output").get("duration") or 0.0
+        if before and after and before - after > SRT_TRIM_TOLERANCE:
+            trimmed = {"from": round(before, 3), "to": round(after, 3)}
+    if trimmed:
+        record_skip(f"the captions stage's SRT is not delivered: a later stage changed the timeline (the delivery was trimmed: "
+                    f"{trimmed}), so its cue times are not the delivery's", "caption_srt_not_delivered",
+                    reason="timeline_changed", path=target, trimmed=trimmed)
+        return None
+    place_output(made["srt"], target)
+    mark_delivered(target, side=True)  # kept after a stop, but not the run's `output` (#510 review)
+    info(f"delivered the captions' SRT as {target}")
+    return target
+
+
 def _stage_failure_hw(doc: Any) -> Dict[str, Any]:
     """A failed stage's `encoder` -- the command that failed -- for render's own failure document
     (absorb_stage() has already joined the stage's `hw` to the earlier stages'; a fallback before
@@ -974,9 +1035,26 @@ def cache_key(stage: str, script: str, argv: "Sequence[Any]", inputs: "Sequence[
         "hw": [os.environ.get(HW_ENV, "").strip().lower() in ("1", "true", "yes", "on"), os.environ.get(HW_FORCED_ENV) == "1"],
         "ffmpeg": CACHE.get("ffmpeg"), "skill": SKILL_VERSION, "contract": CONTRACT_VERSION,
     }
+    named = _brand_files_key(argv)
+    if named:
+        payload["brand_files"] = named  # only with --brand: every other stage's key is unchanged
     return hashlib.sha1(json.dumps(payload, sort_keys=True, ensure_ascii=False).encode(), usedforsecurity=False).hexdigest()
 
 
+def _brand_files_key(argv: "Sequence[Any]") -> List[Any]:
+    """The files a stage's --brand file names (its logo and font_file, resolved as load_brand()
+    resolves them): the key hashes the brand file's own bytes, so a font or a logo replaced under
+    the same name was served from the cache with the old one drawn (#510's sweep)."""
+    out: List[Any] = []
+    args = [str(a) for a in argv]
+    for i, a in enumerate(args[:-1]):
+        if a != "--brand" or not os.path.isfile(args[i + 1]):
+            continue
+        for key, path in brand_asset_files(args[i + 1]):
+            out.append([key, _content_hash(path) if os.path.isfile(path) else None])
+    return out
+
+
 def _cache_miss(stage: str, reason: str, **facts: Any) -> bool:
     """Record why `stage` was not served from the cache (`cache.miss_reasons`); a damaged entry
     (unreadable sidecar, artifact of the wrong size) is also a warning and an audit line in the
@@ -1225,7 +1303,7 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
              unbound_inputs=unbound)
         return 0
     info(f"executing plan {path}: {tool} " + " ".join(argv))
-    proc = run_tool([str(script)] + argv + child_args() + ["--json"])
+    proc = run_tool([str(script)] + with_flags(argv, child_args() + ["--json"]))  # before a `--` in the plan's argv
     for is_command, line in stderr_records(proc.stderr):
         if is_command and not line.startswith("[dry-run]"):
             STATE.commands.append(line)
@@ -1545,6 +1623,8 @@ def main() -> int:
     args = ap.parse_args()
     apply_common(args)
     PROJECT_SOURCE.update(src=None, timecode=[])
+    WORK_DIR["path"] = None
+    DELIVERY["path"] = None
     STATE.audit_log = os.path.abspath(args.audit_log) if args.audit_log else None
 
     if args.list_templates:
@@ -1675,6 +1755,9 @@ def main() -> int:
         passthrough = c0 is not None and c0.get("in") is None and c0.get("out") is None
         if not passthrough:
             refuse_copied_container(mid, output)
+    # #510: a filter or an encoder this build lacks is found by the stage that needs it; the dry run
+    # finds it before anything is encoded, so a real render runs its own dry run first
+    refuse_missing_components_first(str(HERE / "render.py"), "stage's filters and encoders")
     # A77: the default work directory is new for every run (mkdtemp), not named by the PID alone and
     # reused with exist_ok -- a later run that got the same PID deleted an earlier run's kept preview.
     # An explicit --work is the caller's: created when missing, never emptied.
@@ -1703,6 +1786,19 @@ def main() -> int:
         # a --work directory it created too, --keep or not (A99: a plan leaves nothing behind)
         import atexit
         atexit.register(lambda: shutil.rmtree(work, ignore_errors=True))
+        STATE.temp_dirs.append(str(work))  # removed at exit: a stop does not call its files kept (#510)
+    WORK_DIR["path"] = str(work)
+    DELIVERY["path"] = output
+    # #510: the captions stage's generated SRT is delivered beside the output, so its guards are
+    # the output's, once the output's folder exists (created above, as for the output) and
+    # before the first stage: an existing one, an input, the output itself
+    caption_srt = None
+    cap_cfg = proj.get("captions")
+    if (isinstance(cap_cfg, dict) and cap_cfg.get("text") and _reaches("captions", args.stop_after)
+            and (not args.stop_after or args.stop_after == "export")):
+        caption_srt = os.path.splitext(output)[0] + ".srt"
+        guard_sidecar(caption_srt, *([os.path.abspath(args.project)] if args.project else []), *project_input_files(proj, rel),
+                      siblings=(output,))
     frame = dict(proj.get("frame") or {})
     trans = proj.get("transition") or {}
     frame_from_preset(frame, proj.get("export") or {})
@@ -1720,6 +1816,7 @@ def main() -> int:
             and args.stop_after in (None, "export") and args.intermediate_preset != "medium" and not STATE.fast):
         INTERMEDIATE["preset"] = args.intermediate_preset
     stages_done: List[str] = []
+    captioned_srt: Optional[Dict[str, Any]] = None
     # what the caption stage reported (wrapped/split counts and the fit-size keys), so a caller
     # reading render.py's JSON can see whether the type was shrunk to fit or a cue was split.
     caption_report: Optional[Dict[str, Any]] = None
@@ -1948,6 +2045,9 @@ def main() -> int:
             if cap.get(k):
                 argv.append(flag)
         sh("caption.py", *(argv + brand_args + platform_args), stage="captions")
+        # the SRT caption.py generated from the cue file, beside its intermediate (#510); a cache hit
+        # places the video only, so there is none then
+        captioned_srt = {"srt": os.path.splitext(nxt)[0] + ".srt", "video": nxt, "cached": bool(_LAST_DOC.get("cached"))}
         if isinstance(_LAST_DOC.get("caption"), dict):
             caption_report = dict(_LAST_DOC["caption"])
         current = nxt
@@ -2093,13 +2193,14 @@ def main() -> int:
     current = output
     if not STATE.dry_run:
         mark_delivered(output)  # the chapters and check stages run on it: a stop from here keeps it, and says so (#415)
+    caption_srt = deliver_caption_srt(caption_srt, captioned_srt, output)
     if args.stop_after == "export":
         # A87: the chapters and check stages ran after "--stop-after export", and a "check" this
         # run never reads (validate_project() skips it) was then read with .get(): a traceback
         if not args.keep and not args.work:
             shutil.rmtree(work, ignore_errors=True)
         emit(output, stages=stages_done, check=None, cache=cache_report(args.cache),
-             intermediate_preset=_intermediate_used())
+             intermediate_preset=_intermediate_used(), caption_srt=caption_srt)
         return 0
 
     # ---- chapters (metadata.py on the delivered file: streams copied, markers written)
@@ -2191,7 +2292,7 @@ def main() -> int:
         snap_report = dict(snap_reports[0])
         snap_report["clips"] = snap_reports
     emit(output, stages=stages_done, check=check_result, snap=snap_report, cache=cache_report(args.cache),
-         caption=caption_report, intermediate_preset=_intermediate_used(),
+         caption=caption_report, intermediate_preset=_intermediate_used(), caption_srt=caption_srt,
          verification=[{"step": "check", "ok": True, "platform": ck.get("platform")}] if check_result else [])
     return 0
 

package/scripts/waveform.py

@@ -38,10 +38,11 @@ import sys
 from _platforms import PLATFORMS, PLATFORM_CHOICES, resolve as resolve_platform
 from _common.probe import SILENT_PEAK_DBFS, refuse_not_a_still, square_pixels, square_pixels_note
 from _common import still_input_args  # noqa: E402
-from _common import (add_common, apply_common, aac_args, default_output, die, draws_chroma, emit, ffmpeg_base,
+from _common import (add_common, apply_common, aac_args, color_hex, default_output, die, draws_chroma, emit, ffmpeg_base,
                      info, load_brand, pad_filters, probe, rgb_chain_to_bt709, run, STATE, validate_color, video_args, X264_PRESETS,
                      fmt_secs, child_args, run_tool, measured_level_dbfs, sibling_temp)
 from _common.emit import absorb_stage_hw, note, warn
+from _common.runner import refuse_missing_components_first
 from _common.decision import length_output_t
 from _common.probe import AUDIO_MEDIA_EXT
 
@@ -110,10 +111,12 @@ def main() -> int:
     brand = load_brand(args.brand) if args.brand else None
     if brand:
         bc = brand.get("colors") or {}
+        # read as caption.py, graphics.py and overlay.py read a brand colour (#535): a brand file
+        # writes six hex digits with or without # or 0x
         if args.color == "lime" and bc.get("primary"):
-            args.color = bc["primary"]
+            args.color = color_hex(bc["primary"])
         if args.background == "black" and bc.get("background"):
-            args.background = bc["background"]
+            args.background = color_hex(bc["background"])
     if args.image:
         if "://" in args.image:
             die("--image must be a readable local file; this skill has no network access, so save "
@@ -259,6 +262,10 @@ def main() -> int:
         drawn_track = audio_streams[args.audio_stream] if audio_streams else meta["audio"]
         cmd += ["-t", length_output_t(float(meta["duration"]), drawn_track.get("sample_rate"))]
     cmd += ["-shortest", render]
+    if args.title or args.srt or args.text:
+        # #510: the title and captions are later stages; one that needs a filter this build lacks
+        # (drawtext, subtitles) is refused before the visualisation is encoded, as the dry run is
+        refuse_missing_components_first(os.path.abspath(__file__), "stage's filters and encoders")
     titled_tmp = sibling_temp(output, "titled")
     intermediates = [p for p in (render, titled_tmp) if p != output]
     try: