ffmpeg-skill 3.8.5 → 3.8.7

package/scripts/render.py

@@ -275,6 +275,15 @@ def template_project(name: str, args) -> Dict[str, Any]:
                        ("--brand", args.brand), ("--chapters", args.chapters), ("--image", args.image)):
         if path and not os.path.isfile(path):
             die(f"{flag}: file not found: {path}")
+    audiogram = tpl.get("audiogram")
+    if isinstance(audiogram, dict) and "$IMAGE" in audiogram.values() and not args.image and not args.write_project:
+        # A89: without --image the whole audiogram block was dropped as an unfilled placeholder,
+        # so the dry run planned a render with no picture and the real one failed at the export
+        # ("input has no video stream"). --write-project still writes the project to edit.
+        die(f"--template {name} draws the sound over a still picture and needs --image FILE "
+            "(a local file: nothing is fetched and no cover art is invented)",
+            hint='for a plain colour behind the waveform, write the project with --write-project and give it '
+                 '"audiogram": {"background": COLOUR}')
     proj, _ = fill_template(tpl, values)
     if args.fit:
         proj.setdefault("frame", {})["fit"] = args.fit
@@ -364,6 +373,8 @@ def render_pack(names: List[str], args) -> int:
                             ("--intermediate-preset", args.intermediate_preset)):
             if value:
                 argv += option_args(flag, value)
+        if STATE.audit_log:
+            argv += option_args("--audit-log", STATE.audit_log)  # every destination's records, in the one file asked for
         info(f"→ pack: {name}")
         proc = run_tool(argv + child_args() + ["--json"])
         try:
@@ -445,7 +456,7 @@ def check_keys(obj: Any, schema: str, label: str) -> None:
             else f" (valid keys: {', '.join(sorted(valid))})"))
 
 
-def check_overlay(ov: Any, label: str) -> None:
+def check_overlay(ov: Any, label: str, rendered: bool = True) -> None:
     """#326: a video layer is one kind of overlay, as overlay.py's --image/--text/--logo/--video
     are one mutually exclusive choice, and the chromakey* keys only act on it. A logo, image and
     text in one entry still draw the first of them, as before; only a combination with the new
@@ -461,6 +472,12 @@ def check_overlay(ov: Any, label: str) -> None:
         keyed = [k for k in ("chromakey", "chromakey_similarity", "chromakey_blend") if ov.get(k) is not None]
         if keyed:
             die(f"{label}: {keyed[0]} keys a colour out of a video layer and needs \"video\" (overlay.py --chromakey needs --video)")
+    if rendered and ov.get("video") and ov.get("fade"):
+        # A171: overlay.py --video has no fade; the layer was composited with a hard edge. Only a
+        # run that composites the layer refuses it: an export or a preview that stops before the
+        # overlays never read the entry, and completed
+        die(f"{label}: fade fades an image, logo or text layer; a video layer is shown from start to end "
+            "without one (drop \"fade\" from this entry)", kind="input")
     if ov.get("chromakey") is None:
         tuned = [k for k in ("chromakey_similarity", "chromakey_blend") if ov.get(k) is not None]
         if tuned:
@@ -598,7 +615,8 @@ def validate_project(proj: Dict[str, Any], timeline: bool = False, stop_after: O
         for i, item in enumerate(items if isinstance(items, list) else []):
             check_keys(item, f"{name}[]", f"{name}[{i}]")
             if name == "overlays":
-                check_overlay(item, f"overlays[{i}]")
+                check_overlay(item, f"overlays[{i}]",
+                              rendered=not timeline and _reaches(READ_AT["overlays"], stop_after))
             if name != "clips":
                 continue
             # every clip stage starts from rel(c["src"]): without one it was a KeyError traceback
@@ -616,7 +634,29 @@ def validate_project(proj: Dict[str, Any], timeline: bool = False, stop_after: O
                 # the render reads a clip's snap only on a clip it cuts (in/out), the export never
                 if not timeline and (item.get("in") is not None or item.get("out") is not None):
                     require_object(item["snap"], f"clips[{i}].snap")
+                    # A93: only the project's own snap.to was checked, so a clip's "beat" (or an
+                    # unsupported grid) was read as "not beats" and the cut rendered unsnapped
+                    check_snap_to(item["snap"], f"clips[{i}].snap")
                 check_keys(item["snap"], "snap", f"clips[{i}].snap")
+    if not timeline and "audiogram" in read and proj.get("audiogram") and isinstance(clips, list) and len(clips) > 1:
+        # A92: the audiogram stage draws the first clip's sound and the render carries on from
+        # that one file: every other clip was cut and then left out of the output without a word
+        die(f"audiogram: an audiogram is drawn from one audio source, and this project has {len(clips)} clips "
+            "(only the first would be in the output); join them first (join.py) and name the joined file as the one clip")
+    chapters = proj.get("chapters")
+    if chapters and not isinstance(chapters, (str, list)):
+        # A94: a number or an object was handed to metadata.py as a file name by the last stage,
+        # after the whole render ("chapters file not found: .../5"). false and 0 are "no chapters",
+        # as the stage's own `if ch:` reads them, and stay that
+        die(f'chapters: must be a chapters file path or a list of {{"at": TIME, "title": STR}}, got '
+            f"{type(chapters).__name__} {chapters!r:.60}")
+
+
+def check_snap_to(snap: Any, label: str) -> None:
+    """Refuse a snap grid other than beats, for the project's `snap` and for a clip's own."""
+    if isinstance(snap, dict) and str(snap.get("to") or "") not in ("", "none", "beats"):
+        die(f'{label}.to: only "beats" (or "none") is a beat grid this skill can measure, got '
+            f'{snap.get("to")!r}', kind="input")
 
 
 _LAST_DOC: Dict[str, Any] = {}   # the JSON document the most recent sh() child printed
@@ -1298,6 +1338,13 @@ def main() -> int:
         if len(names) > 1:
             if args.write_project:
                 die("--write-project writes one project; name a single template")
+            # A85: a pack runs one full render per destination and handed none of these to them,
+            # so --stop-after did not stop, --cache was not read and --work/--keep kept nothing
+            for flag, value in (("--stop-after", args.stop_after), ("--cache", args.cache), ("--from", args.from_stage),
+                                ("--work", args.work), ("--keep", args.keep), ("--export-timeline", args.export_timeline)):
+                if value:
+                    die(f"{flag} applies to one render, and --template {args.template} is a pack of {len(names)} "
+                        f"({', '.join(names)}), each a full render of its own: name a single template to use {flag}")
             return render_pack(names, args)
         proj: Dict[str, Any] = template_project(names[0], args)
         base = Path.cwd()
@@ -1444,9 +1491,7 @@ def main() -> int:
     # so a project that does not name "snap" builds the command line 1.16 built.
     snap_spec = proj.get("snap") or {}
     snap_reports: List[Dict[str, Any]] = []
-    if snap_spec and str(snap_spec.get("to") or "") not in ("", "none", "beats"):
-        die(f'snap.to: only "beats" (or "none") is a beat grid this skill can measure, got '
-            f'{snap_spec.get("to")!r}', kind="input")
+    check_snap_to(snap_spec, "snap")
 
     # ---- clips
     # 2.2.1: every clip source is checked before the first one is cut, and every problem is named

package/scripts/scenes.py

@@ -146,6 +146,20 @@ def main() -> int:
     add_common(ap)
     args = ap.parse_args()
     apply_common(args)
+    if args.highlights < 0:
+        die(f"--highlights must be 0 or more (the number of ranges to propose), got {args.highlights}")
+    if not args.highlights:
+        # A145: these shape or write the --highlights picks; without it they were accepted and
+        # nothing was written (--edl FILE completed with no file)
+        for flag, given in (("--edl", args.edl is not None), ("--target", args.target is not None),
+                            ("--max-scene", args.max_scene != ap.get_default("max_scene"))):
+            if given:
+                die(f"{flag} applies to the ranges --highlights proposes, and --highlights was not given; "
+                    "add --highlights N")
+    if args.target is not None and args.target <= 0:
+        die(f"--target must be more than 0 seconds, got {args.target:g}")
+    if args.max_scene <= 0:
+        die(f"--max-scene must be more than 0 seconds, got {args.max_scene:g}")
     if args.highlights:  # the EDL is written only with --highlights
         guard_sidecar(args.edl, args.input, siblings=(args.sheet,))
 

package/scripts/sequence.py

@@ -96,6 +96,10 @@ def main() -> int:
 
     if args.fps <= 0:
         die("--fps must be > 0")
+    for flag, value in (("--width", args.width), ("--height", args.height)):
+        # A109: 0 read as "not given" and a negative size reached ffmpeg (kind ffmpeg)
+        if value is not None and value < 1:
+            die(f"{flag} must be a positive number of pixels, got {value}")
     try:
         rate = exact_rate(args.fps)  # 29.97 is 30000/1001, as every other tool reads it
     except TimelineError as exc:

package/scripts/silence.py

@@ -627,6 +627,9 @@ def main() -> int:
     if not math.isfinite(args.margin) or args.margin < 0:
         # nan made inside_margin() drop every silence and re-encode the whole file unchanged
         die(f"--margin must be a finite number of seconds, 0 or more (got {args.margin:g})", kind="input")
+    if args.min_silence < 0:
+        # A52: a negative length reached silencedetect, which refused it (kind ffmpeg)
+        die(f"--min-silence must be 0 or more seconds, got {args.min_silence:g}", kind="input")
     for flag, value in (("--margin-lead", args.margin_lead), ("--margin-tail", args.margin_tail)):
         if value is not None and (not math.isfinite(value) or value < 0):
             die(f"{flag} must be a finite number of seconds, 0 or more (got {value:g})", kind="input")

package/scripts/sync.py

@@ -299,6 +299,12 @@ def main() -> int:
     add_common(ap)
     args = ap.parse_args()
     apply_common(args)
+    # A190: with a search range of 0 or below no lag is tried, and the run reported an offset
+    # (0.012 s at confidence 0) for a correlation it never made
+    if args.max_offset <= 0:
+        die(f"--max-offset must be more than 0 seconds (the largest offset searched), got {args.max_offset:g}")
+    if args.analyze_seconds <= 0:
+        die(f"--analyze-seconds must be more than 0 seconds, got {args.analyze_seconds:g}")
     if args.analyze_seconds > 900:
         die(f"--analyze-seconds {args.analyze_seconds:g}: the window is decoded into memory; 900 s is the ceiling")
     args.sources = [args.second] + list(args.more_sources)

package/scripts/verify.py

@@ -163,6 +163,10 @@ def main() -> int:
         STATE.dry_run = False
         info("--dry-run is ignored by verify.py: its steps run and write their outputs")
 
+    if args.seconds <= 0:
+        # A190: every step was handed a cut of no length and failed, which read as the tools'
+        # fault ("9 of 11 verification steps failed") rather than the flag's
+        die(f"--seconds must be more than 0 (the length of the test cut), got {args.seconds:g}")
     files = collect(args.paths)
     tmp = None
     if args.out:

package/scripts/waveform.py

@@ -10,9 +10,10 @@ generated fresh, there is no source picture involved.
 --style waveform draws the amplitude over time; --style spectrum draws a
 frequency-over-time heatmap instead, which reads more information out of
 dense mixes at the cost of being less immediately readable to a general
-audience. Both accept --width/--height and --color; waveform additionally
-takes --waveform-mode (how each sample is drawn) and --split-channels
-(stereo drawn as two separate lanes instead of summed to one).
+audience. Both accept --width/--height and --split-channels (stereo drawn as
+two separate lanes instead of summed to one); waveform additionally takes
+--color and --waveform-mode (how each sample is drawn). The spectrum is drawn
+in showspectrum's own colour map, so --color with --style spectrum is refused.
 
 Examples:
   python3 waveform.py podcast.wav -o waveform.mp4
@@ -54,7 +55,7 @@ def main() -> int:
     ap.add_argument("--width", type=int, default=1920, help="output width in px, must be even (default 1920)")
     ap.add_argument("--height", type=int, default=1080, help="output height in px, must be even (default 1080)")
     ap.add_argument("--fps", type=float, default=25.0, help="output frame rate (default 25)")
-    ap.add_argument("--color", default="lime", help="channel colour(s), pipe-separated per channel, e.g. 'lime' or 'cyan|magenta' (default lime)")
+    ap.add_argument("--color", default="lime", help="--style waveform only: channel colour(s), pipe-separated per channel, e.g. 'lime' or 'cyan|magenta' (default lime)")
     ap.add_argument("--background", default="black", help="background colour (default black)")
     ap.add_argument("--waveform-mode", choices=WAVEFORM_MODES, default="line", help="--style waveform only: how each sample is drawn (default line)")
     ap.add_argument("--split-channels", action="store_true", help="draw each channel in its own lane instead of summing to one")
@@ -97,6 +98,14 @@ def main() -> int:
         args.width, args.height = frame["w"], frame["h"]
         args.fps = float(PLATFORMS[args.platform].get("fps") or args.fps)
         info(f"--platform {args.platform}: {args.width}x{args.height} @ {args.fps:g}fps")
+    if args.style == "spectrum" and args.color != ap.get_default("color"):
+        # A144: showspectrum takes no colour, so the flag was accepted and the heatmap drawn in
+        # its own colour map (a brand's primary colour is a default and is not refused)
+        die(f"--color {args.color} colours the waveform's channels; --style spectrum is drawn in showspectrum's own "
+            "colour map and takes no colour", hint="drop --color, or use --style waveform")
+    if args.style == "spectrum" and args.waveform_mode != ap.get_default("waveform_mode"):
+        die(f"--waveform-mode {args.waveform_mode} is how --style waveform draws each sample; --style spectrum has no "
+            "such mode", hint="drop --waveform-mode, or use --style waveform")
     brand = load_brand(args.brand) if args.brand else None
     if brand:
         bc = brand.get("colors") or {}