ffmpeg-skill 3.8.8 → 3.8.9

package/scripts/probe.py

@@ -73,6 +73,14 @@ def main() -> int:
         for r in results:
             if r.get("video"):
                 r["levels"] = analyze_levels(r["file"])
+                transfer = r["video"].get("color_transfer")
+                if r["video"].get("hdr") and "error" not in r["levels"]:
+                    # the guess is "flat and desaturated, yet tagged SDR": a PQ/HLG stream is not
+                    # tagged SDR, and its code values were read as if they were (#403)
+                    r["levels"]["looks_like_log"] = None
+                    r["levels"]["reason"] = "not_measured: the stream is tagged HDR (%s), and the Log guess is made for an SDR-tagged picture" % (transfer or r["video"].get("hdr_format") or "HDR")
+                    r["levels"]["note"] = ("the stream is tagged HDR (%s): these are its code values on an 8-bit scale, not display-referred SDR levels, "
+                                           "and whether it looks like Log was not judged" % (transfer or r["video"].get("hdr_format") or "HDR"))
 
     if args.field:
         for r in results:

package/scripts/render.py

@@ -1090,6 +1090,18 @@ def _from_plan_cwd(output: Any) -> Any:
     return os.path.abspath(str(output)) if isinstance(output, str) and output else output
 
 
+def check_not_run(check_result: Optional[Dict[str, Any]]) -> Optional[str]:
+    """Why check.py graded nothing, or None when it did: a document with no FAIL count that is
+    failed or carries an error is a check that could not run (an unparsed document, check.py's own
+    refusal), not a check the delivery failed (#403: both were reported as "check failed")."""
+    if not check_result or check_result.get("failed"):
+        return None
+    err = check_result.get("error")
+    if not err and check_result.get("status") != "failed":
+        return None
+    return str((err.get("message") if isinstance(err, dict) else err) or "check.py reported status failed with no rows")
+
+
 def execute_plan(plan: Dict[str, Any], path: str) -> int:
     """Run a plan written by `<tool> --plan FILE`: refuse if any fingerprinted input changed since
     the plan was made (the plan's commands would then describe a different edit), run the tool
@@ -1189,7 +1201,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
     # same command run by hand)
     if exit_code:
         failed_rows = [r["check"] for r in (check_result or {}).get("checks", []) if r.get("status") == "FAIL"]
-        info(f"plan done: {output}, but the {check_result.get('platform') or 'content'} check failed" + (f": {', '.join(failed_rows)}" if failed_rows else ""))
+        unrun = check_not_run(check_result)
+        info(f"plan done: {output}, but the {check_result.get('platform') or 'content'} check "
+             + (f"could not run, so nothing was checked: {unrun}" if unrun else "failed" + (f": {', '.join(failed_rows)}" if failed_rows else "")))
     else:
         advised = guidance_warns(check_result)
         info(f"plan done: {output}" + (" — upload-limit guidance, the uploader checks the current limit: "
@@ -1197,7 +1211,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
     # the tool's own steps (export's loudness, ...) come in through absorb_stage() above, tagged
     # with `stage`, so `verified` is theirs and the check's together
     emit(output, plan=path, plan_sha256=digest, unbound_inputs=unbound, tool=tool, stages=[tool] + (["check"] if check_result else []), check=check_result, tool_result=doc,
-         verification=([{"step": "check", "ok": not exit_code, "platform": check_result.get("platform")}] if check_result else []))
+         verification=([dict({"step": "check", "ok": not exit_code, "platform": check_result.get("platform")},
+                             **({"reason": "not_measured: " + check_not_run(check_result)} if check_not_run(check_result) else {}))]
+                       if check_result else []))
     return 0
 
 
@@ -2084,7 +2100,9 @@ def main() -> int:
         # The deliverable is written and verified, but it does not meet the requested platform
         # spec (or the check itself could not run): a failed delivery, reported as one.
         failed_rows = [r["check"] for r in (check_result or {}).get("checks", []) if r.get("status") == "FAIL"]
-        die(f"rendered {output} but the {check_label} check failed" + (f": {', '.join(failed_rows)}" if failed_rows else ""),
+        unrun = check_not_run(check_result)
+        die(f"rendered {output} but the {check_label} check "
+            + (f"could not run, so nothing was checked: {unrun}" if unrun else "failed" + (f": {', '.join(failed_rows)}" if failed_rows else "")),
             kind="verification", output=output, dry_run=STATE.dry_run, stages=stages_done, check=check_result,
             probe=probe(output, role="output"))
     info(f"rendered {output} via {' → '.join(stages_done)}")

package/scripts/silence.py

@@ -121,7 +121,7 @@ def sentence_words(args) -> "Tuple[list, str]":
             raw = parse_json(read_text_or_die(args.words, "--words"))
         except ValueError as exc:
             die(f"--words {args.words}: not readable JSON ({exc})", kind="input")
-        words, _had_segments, _untimed = _words_from_transcript(raw)
+        words, _had_segments, _untimed = _words_from_words_file(args.words, raw)
         if not words:
             die(f"no word timings in {args.words}: the sentence flags need "
                 '{"words": [{"word": ..., "start": ..., "end": ...}]} (or the same inside "segments").',
@@ -356,7 +356,15 @@ def resolve_filler(args, meta):
         except ValueError as exc:
             die(f"--words {args.words}: not readable JSON ({exc})", kind="input")
         source = f"whisper-json:{args.words}"
-        words, had_segments, untimed = _words_from_transcript(raw)
+        words, had_segments, untimed = _words_from_words_file(args.words, raw)
+        length = float(meta.get("duration") or 0.0)
+        late = [w for w in words if w["start"] >= length] if length > 0 else []
+        if late:
+            # nothing said it: the cuts were planned on times the input does not have (#404)
+            warn(f"--words {args.words}: {len(late)} of {len(words)} word timings start at or after the end of the input "
+                 f"({length:.3f}s; the last at {max(w['start'] for w in late):g}s) -- a transcript of another file, or "
+                 "times in milliseconds (a whisper JSON's start/end are seconds); no word is cut there",
+                 "words_outside_input", count=len(late), words=len(words), duration=round(length, 3))
         if not words:
             if had_segments:
                 die(f"the transcript in {args.words} has segment timings but no word timings; "
@@ -423,7 +431,11 @@ def resolve_filler(args, meta):
             if primary in names:
                 return names[primary]
             return primary[:2] if len(primary) > 3 else primary
-        spoken = _code((raw or {}).get("language")) if isinstance(raw, dict) else ""
+        # openai-whisper's top-level `language`, or whisper.cpp's `result.language` (its
+        # --output-json-full document is read for its words too: _words_from_words_file())
+        result = raw.get("result") if isinstance(raw, dict) else None
+        spoken = _code(raw.get("language") or (result.get("language") if isinstance(result, dict) else None)) \
+            if isinstance(raw, dict) else ""
         spoken = spoken or _code(transcription.get("language") or transcription.get("detected_language"))
         if spoken and spoken not in FILLER_WORDS and not args.filler_words:
             die(f"the transcript is in {spoken}, which has no built-in filler list. The languages with one are "
@@ -482,6 +494,18 @@ def resolve_filler(args, meta):
     return block, [(s["start"], s["end"]) for s in spans]
 
 
+def _words_from_words_file(path, data):
+    """_words_from_transcript() for a --words file, plus whisper.cpp's own shape: its
+    --output-json-full document (transcription[].tokens[], offsets in milliseconds) is what the
+    refusals here tell a caller to make, and it was then refused for having no word timings (#404).
+    Read as --transcribe reads the same file."""
+    words, had_segments, untimed = _words_from_transcript(data)
+    if not words and isinstance(data, dict) and isinstance(data.get("transcription"), list):
+        words = _asr._words_from_whisper_cpp_json(path)
+        had_segments = had_segments or bool(data["transcription"])
+    return words, had_segments, untimed
+
+
 def _words_from_transcript(data):
     """([{word,start,end}], whether the document had segments at all, [{word}] of the words
     that carried no usable timing) from a whisper JSON. The third list lets --filler count a

package/scripts/stabilize.py

@@ -28,7 +28,7 @@ import tempfile
 from pathlib import Path
 
 from _common.probe import PROBED_VIDEO
-from _common.runner import default_selection_maps
+from _common.runner import ffmpeg_failure_extra, default_selection_maps, require_filter
 from _common import STATE, add_common, apply_common, aac_args, cfr_args, default_output, die, emit, escape_filter_path, ffmpeg_base, info, probe, require_tool, run, video_args, X264_PRESETS, run_analysis, dry_run_input_pending, fmt_secs, record_fallback, EVEN_SCALE
 
 
@@ -57,6 +57,10 @@ def main() -> int:
     meta = probe(args.input)
     if not meta.get("video"):
         die("input has no video stream")
+    # pass 1 is a measurement that runs under --dry-run too: refused here, with the reason a run
+    # that met "No such filter" gets, instead of as an unclassified pass-1 failure (#402)
+    for name in ("vidstabdetect", "vidstabtransform"):
+        require_filter(name, "stabilizing (vid.stab)")
     has_audio = bool(meta.get("audio"))
     output = args.output or default_output(args.input, "stab")
 
@@ -89,7 +93,7 @@ def main() -> int:
         if not dry_run_input_pending(args.input):
             proc = run_analysis(detect_cmd, check=False, record=True)
             if proc.returncode != 0:
-                die(f"stabilization analysis (pass 1) failed:\n{proc.stderr.strip()[-1500:]}", kind="ffmpeg")
+                die(f"stabilization analysis (pass 1) failed:\n{proc.stderr.strip()[-1500:]}", kind="ffmpeg", **ffmpeg_failure_extra(proc.stderr))
 
         crop_mode = {"keep": 0, "black": 1}[args.crop]
         transform_vf = f"{even}vidstabtransform=input={trf_arg}:smoothing={args.smoothing}:crop={crop_mode}:zoom={args.zoom:g}:optzoom=1"

package/scripts/sync.py

@@ -33,7 +33,7 @@ import sys
 from typing import Dict, List
 
 from _common.runner import fail_if_classified
-from _common import video_args, add_common, apply_common, emit, aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, x264_args, decode_pcm_mono, rms_envelope
+from _common import STATE, video_args, add_common, apply_common, emit, aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, x264_args, decode_pcm_mono, rms_envelope
 from _common.emit import record_skip, warn
 from _common.decision import SEEK_MARGIN, frame_rate, grid_at_or_after, length_output_t, silence_filter, stream_starts
 from _common.timeline import output_timecode_args
@@ -259,8 +259,13 @@ def measure_one(reference: str, path: str, args) -> Dict:
                 offset = offset + (drift_ratio - 1.0) * head_mid
                 drift_info = {"residual_at_end_seconds": round(residual, 4), "measured_over_seconds": round(elapsed, 2),
                               "drift_ppm": round((drift_ratio - 1) * 1e6, 1),
-                              "meaning": "second file runs %.1f ppm %s (%.3fs over %.0fs); it will be resampled to match" % (
-                                  abs(drift_ratio - 1) * 1e6, "long/slow" if drift_ratio > 1 else "short/fast", abs(residual), elapsed),
+                              # a measure-only run writes nothing (#403: it said "will be resampled")
+                              "meaning": "second file runs %.1f ppm %s (%.3fs over %.0fs); %s" % (
+                                  abs(drift_ratio - 1) * 1e6, "long/slow" if drift_ratio > 1 else "short/fast", abs(residual), elapsed,
+                                  ("it would be resampled to match in the file this run plans (--dry-run writes nothing)" if STATE.dry_run
+                                   else "it is resampled to match in the file this run writes")
+                                  if args.replace_audio or args.trim_second else
+                                  "nothing is resampled in this measure-only run (--replace-audio or --trim-second writes the corrected file)"),
                               "confidence": round(end_score, 3)}
             else:
                 skipped_reason = "low_confidence"

package/scripts/waveform.py

@@ -36,7 +36,7 @@ import os
 import sys
 
 from _platforms import PLATFORMS, PLATFORM_CHOICES, resolve as resolve_platform
-from _common.probe import SILENT_PEAK_DBFS, square_pixels, square_pixels_note
+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,
                      info, load_brand, pad_filters, probe, rgb_chain_to_bt709, run, STATE, validate_color, video_args, X264_PRESETS,
@@ -119,10 +119,13 @@ def main() -> int:
                 "the image locally and pass its path", kind="input")
         if not os.path.exists(args.image):
             die(f"--image file not found: {args.image}", kind="input")
-        if not STATE.dry_run:
-            plate = probe(args.image, role="input")
-            if not (plate.get("video") or {}).get("width"):
-                die(f"--image is not an image ffmpeg can decode: {args.image}", kind="input")
+        # read under --dry-run too (the file exists, checked above): a plate the real run refuses
+        # is refused by the plan (#404: a dry run completed on a video given as --image)
+        plate = probe(args.image, role="input")
+        if not (plate.get("video") or {}).get("width"):
+            die(f"--image is not an image ffmpeg can decode: {args.image}", kind="input")
+        refuse_not_a_still(args.image, plate, "--image",
+                           "`look.py FILE --at T` writes one frame of a video as a PNG")
         if args.background != "black":
             die("--image and a non-default --background exclude each other: the plate is either "
                 "the picture or the colour", kind="input")
@@ -375,8 +378,12 @@ def _child(script_name: str, argv: "list") -> None:
         extra = {"hint": err["hint"]} if err.get("hint") else {}
         if doc.get("encoder"):
             extra["encoder"] = doc["encoder"]
+        # the stage's own reason and details ride along (#402: a caller keyed on error.reason saw
+        # filter_missing from caption.py and graphics.py run by hand, and nothing from here)
+        why = {k: err[k] for k in ("reason", "details") if err.get(k) is not None}
         die(f"{script_name} failed: {err.get('message') or (proc.stderr.strip().splitlines() or ['?'])[-1][:300]}",
-            code=int(doc.get("exit_code") or 1), kind=err.get("kind") or "input", stage=script_name, **extra)
+            code=int(doc.get("exit_code") or 1), kind=err.get("kind") or "input", stage=script_name,
+            error_extra=why or None, **extra)
 
 if __name__ == "__main__":
     sys.exit(main())