ffmpeg-skill 0.4.1 → 0.6.0

package/scripts/report.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Build a single-file HTML delivery report: what went in, what came out,
+before/after contact sheets, loudness, compliance and the exact commands.
+The agent hands this to the user instead of a wall of text.
+
+Examples:
+  python3 report.py --before raw.mov --after final.mp4 -o report.html
+  python3 report.py --after final.mp4 --platform reels --title "Episode 12 — Reels cut" -o report.html
+  python3 report.py --before raw.mov --after final.mp4 --commands commands.txt --notes notes.md
+"""
+import argparse
+import base64
+import html
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from _common import add_common, apply_common, die, emit, info, probe
+
+HERE = Path(__file__).resolve().parent
+
+
+def sheet_b64(path: str, tiles: str = "4x2", width: int = 1200) -> Optional[str]:
+    with tempfile.TemporaryDirectory(prefix="ffskill_report_") as tmp:
+        png = os.path.join(tmp, "sheet.png")
+        proc = subprocess.run([sys.executable, str(HERE / "look.py"), path, "--tiles", tiles, "--width", str(width), "-o", png],
+                              stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if proc.returncode != 0 or not os.path.exists(png):
+            return None
+        return base64.b64encode(Path(png).read_bytes()).decode("ascii")
+
+
+def loudness(path: str) -> Dict[str, Any]:
+    proc = subprocess.run([sys.executable, str(HERE / "loudness.py"), path, "--measure-only"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    try:
+        d = json.loads(proc.stdout)
+        return {"lufs": round(float(d["input_i"]), 1), "tp": round(float(d["input_tp"]), 1), "lra": round(float(d["input_lra"]), 1)}
+    except (ValueError, KeyError):
+        return {}
+
+
+def check(path: str, platform: str) -> Optional[Dict[str, Any]]:
+    proc = subprocess.run([sys.executable, str(HERE / "check.py"), path, "--platform", platform, "--json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    try:
+        return json.loads(proc.stdout)
+    except ValueError:
+        return None
+
+
+def fmt_dur(sec: Optional[float]) -> str:
+    if not sec:
+        return "?"
+    m, s = divmod(sec, 60)
+    h, m = divmod(int(m), 60)
+    return f"{h}:{m:02d}:{s:05.2f}" if h else f"{m}:{s:05.2f}"
+
+
+def media_rows(meta: Dict[str, Any], ld: Dict[str, Any]) -> List[List[str]]:
+    v, a = meta.get("video") or {}, meta.get("audio") or {}
+    rows = [
+        ["Duration", fmt_dur(meta.get("duration"))],
+        ["Size", f"{(meta.get('size_bytes') or 0) / 1024 / 1024:.1f} MB"],
+        ["Video", f"{v.get('codec')} {v.get('width')}×{v.get('height')} @ {v.get('fps')} fps, {v.get('pix_fmt')}" if v else "none"],
+        ["Colour", (f"{v.get('color_primaries')}/{v.get('color_transfer')}" + (f" — {v.get('hdr_format')}" if v.get("hdr") else " (SDR)")) if v else "—"],
+        ["Frame rate", ("variable (suspected)" if v.get("variable_frame_rate_suspected") else "constant") if v else "—"],
+        ["Audio", f"{a.get('codec')} {a.get('channels')} ch {a.get('sample_rate')} Hz" if a else "none"],
+    ]
+    if ld:
+        rows.append(["Loudness", f"{ld['lufs']} LUFS, TP {ld['tp']} dBTP, LRA {ld['lra']} LU"])
+    return rows
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--after", required=True, help="the deliverable")
+    ap.add_argument("--before", help="the source (optional)")
+    ap.add_argument("-o", "--output", help="report path (default: <after>_report.html)")
+    ap.add_argument("--title", help="report title")
+    ap.add_argument("--platform", help="run check.py for this platform and include the table")
+    ap.add_argument("--commands", help="text file with the commands that were run (one per line)")
+    ap.add_argument("--notes", help="text/markdown file with notes to include verbatim")
+    ap.add_argument("--no-sheets", action="store_true", help="skip contact sheets (faster, smaller)")
+    add_common(ap)
+    args = ap.parse_args()
+    apply_common(args)
+
+    after = probe(args.after)
+    before = probe(args.before) if args.before else None
+    ld_after = loudness(args.after) if after.get("audio") else {}
+    ld_before = loudness(args.before) if before and before.get("audio") else {}
+    chk = check(args.after, args.platform) if args.platform else None
+    sheets = {}
+    if not args.no_sheets:
+        if before and before.get("video"):
+            sheets["before"] = sheet_b64(args.before)
+        if after.get("video"):
+            sheets["after"] = sheet_b64(args.after)
+    commands = Path(args.commands).read_text(encoding="utf-8").splitlines() if args.commands else []
+    notes = Path(args.notes).read_text(encoding="utf-8") if args.notes else ""
+    title = args.title or f"Delivery report — {Path(args.after).name}"
+    output = args.output or str(Path(args.after).with_name(Path(args.after).stem + "_report.html"))
+
+    def table(rows: List[List[str]]) -> str:
+        return "<table>" + "".join(f"<tr><th>{html.escape(k)}</th><td>{html.escape(str(v))}</td></tr>" for k, v in rows) + "</table>"
+
+    parts: List[str] = []
+    parts.append(f"<h1>{html.escape(title)}</h1>")
+    parts.append(f"<p class='meta'>{html.escape(os.path.abspath(args.after))}</p>")
+    cols = []
+    if before:
+        cols.append(f"<div class='col'><h2>Before</h2><p class='file'>{html.escape(Path(args.before).name)}</p>{table(media_rows(before, ld_before))}"
+                    + (f"<img src='data:image/png;base64,{sheets['before']}' alt='before contact sheet'>" if sheets.get("before") else "") + "</div>")
+    cols.append(f"<div class='col'><h2>After</h2><p class='file'>{html.escape(Path(args.after).name)}</p>{table(media_rows(after, ld_after))}"
+                + (f"<img src='data:image/png;base64,{sheets['after']}' alt='after contact sheet'>" if sheets.get("after") else "") + "</div>")
+    parts.append("<div class='cols'>" + "".join(cols) + "</div>")
+    if chk:
+        rows = "".join(
+            f"<tr class='{r['status'].lower()}'><td class='st'>{r['status']}</td><td>{html.escape(r['check'])}</td><td>{html.escape(str(r['value']))}</td><td>{html.escape(str(r['expected']))}</td><td>{html.escape(r.get('fix') or '') if r['status'] != 'PASS' else ''}</td></tr>"
+            for r in chk["checks"])
+        verdict = "READY" if chk.get("ok") else f"{chk.get('failed')} FAIL"
+        parts.append(f"<h2>Compliance — {html.escape(args.platform)} <span class='verdict {'ok' if chk.get('ok') else 'bad'}'>{verdict}</span></h2>"
+                     f"<table class='checks'><tr><th></th><th>check</th><th>value</th><th>expected</th><th>fix</th></tr>{rows}</table>")
+    if notes:
+        parts.append("<h2>Notes</h2><pre class='notes'>" + html.escape(notes) + "</pre>")
+    if commands:
+        parts.append("<h2>Commands</h2><pre class='cmd'>" + html.escape("\n".join(commands)) + "</pre>")
+    parts.append("<p class='foot'>Generated by ffmpeg-skill · local FFmpeg, no cloud.</p>")
+
+    css = """
+    :root{--bg:#F4F6F8;--paper:#fff;--ink:#161B21;--ink2:#4B5661;--line:#D8DEE4;--ok:#2C8A5B;--warn:#C48519;--bad:#B4362F;--accent:#1E6F8E}
+    @media (prefers-color-scheme:dark){:root{--bg:#111518;--paper:#191E23;--ink:#E8ECEF;--ink2:#AEB6BE;--line:#2A3138;--ok:#5CC38C;--warn:#E3A63C;--bad:#F07A73;--accent:#5FB2D4}}
+    body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.6 system-ui,-apple-system,"Segoe UI",Roboto,"Noto Sans JP",sans-serif}
+    .wrap{max-width:1100px;margin:0 auto;padding:32px 20px 60px}
+    h1{font-size:26px;margin:0 0 4px}h2{font-size:18px;margin:28px 0 10px}
+    .meta{color:var(--ink2);font-size:13px;margin:0 0 20px;word-break:break-all}
+    .cols{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:16px}
+    .col{background:var(--paper);border:1px solid var(--line);border-radius:6px;padding:14px 16px}
+    .col h2{margin-top:0}.file{color:var(--ink2);font-size:13px;margin:0 0 8px}
+    table{border-collapse:collapse;width:100%;font-size:14px}th,td{text-align:left;padding:6px 8px;border-bottom:1px solid var(--line);vertical-align:top}
+    th{color:var(--ink2);font-weight:500;width:34%}
+    img{max-width:100%;border-radius:4px;margin-top:12px;border:1px solid var(--line)}
+    .checks{background:var(--paper);border:1px solid var(--line);border-radius:6px;overflow:hidden}.checks th{width:auto}
+    .st{font-weight:700;font-family:ui-monospace,Menlo,monospace}tr.pass .st{color:var(--ok)}tr.warn .st{color:var(--warn)}tr.fail .st{color:var(--bad)}
+    .verdict{font-size:13px;padding:2px 8px;border-radius:3px;margin-left:8px;vertical-align:middle}.verdict.ok{background:var(--ok);color:#fff}.verdict.bad{background:var(--bad);color:#fff}
+    pre{background:var(--paper);border:1px solid var(--line);border-radius:6px;padding:12px 14px;overflow-x:auto;font-size:12.5px;line-height:1.5}
+    .foot{color:var(--ink2);font-size:12px;margin-top:36px;border-top:1px solid var(--line);padding-top:10px}
+    """
+    doc = f"<!doctype html><html><head><meta charset='utf-8'><meta name='viewport' content='width=device-width,initial-scale=1'><title>{html.escape(title)}</title><style>{css}</style></head><body><div class='wrap'>{''.join(parts)}</div></body></html>"
+    Path(output).write_text(doc, encoding="utf-8")
+    info(f"wrote {output} ({os.path.getsize(output) / 1024:.0f} KB)")
+    emit(None, report=output, check=chk)
+    if not args.json:
+        print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/scenes.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Find scene changes and loud moments, and propose highlight candidates so the
+agent can plan an edit or a digest without watching the whole file.
+
+Scene cuts come from ffmpeg's scdet; energy peaks from a 0.5 s RMS envelope
+of the audio. Highlight candidates are the scenes ranked by audio energy
+(and, optionally, by motion).
+
+Examples:
+  python3 scenes.py talk.mp4                                # scenes + peaks, JSON
+  python3 scenes.py event.mp4 --highlights 5 --target 60   # 5 candidate ranges summing to ~60 s
+  python3 scenes.py event.mp4 --highlights 4 --edl picks.txt   # cut.py --segments compatible list
+  python3 scenes.py event.mp4 --sheet scenes.png             # one thumbnail per scene
+"""
+import argparse
+import math
+import os
+import re
+import struct
+import subprocess
+import sys
+from typing import Dict, List, Tuple
+
+from _common import add_common, apply_common, die, emit, ffmpeg_base, info, print_json, probe, require_tool, run
+
+SCENE_RE = re.compile(r"lavfi\.scd\.time=([0-9.]+)")
+
+
+def detect_scenes(path: str, threshold: float, min_len: float, duration: float) -> List[float]:
+    ffmpeg = require_tool("ffmpeg")
+    proc = subprocess.run([ffmpeg, "-hide_banner", "-nostdin", "-i", path, "-an", "-vf",
+                           f"scale=320:-2,scdet=threshold={threshold}:sc_pass=1,metadata=print:file=-", "-f", "null", "-"],
+                          stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    times = [float(t) for t in SCENE_RE.findall(proc.stdout)]
+    cuts = [0.0]
+    for t in times:
+        if t - cuts[-1] >= min_len:
+            cuts.append(t)
+    if duration - cuts[-1] < min_len and len(cuts) > 1:
+        cuts.pop()
+    return cuts
+
+
+def audio_envelope(path: str, step_s: float) -> List[float]:
+    ffmpeg = require_tool("ffmpeg")
+    proc = subprocess.run([ffmpeg, "-hide_banner", "-loglevel", "error", "-nostdin", "-i", path, "-vn", "-ac", "1", "-ar", "8000", "-f", "s16le", "-"],
+                          stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    n = len(proc.stdout) // 2
+    if n == 0:
+        return []
+    samples = struct.unpack(f"<{n}h", proc.stdout[: n * 2])
+    step = max(1, int(8000 * step_s))
+    env = []
+    for i in range(0, n, step):
+        block = samples[i:i + step]
+        env.append(math.sqrt(sum(x * x for x in block) / len(block)) / 32768.0)
+    return env
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("input")
+    ap.add_argument("--threshold", type=float, default=10.0, help="scdet threshold 0-100 (default 10; lower = more cuts)")
+    ap.add_argument("--min-scene", type=float, default=1.0, help="ignore cuts closer than this in seconds (default 1)")
+    ap.add_argument("--highlights", type=int, default=0, help="number of highlight ranges to propose")
+    ap.add_argument("--target", type=float, help="with --highlights: total seconds the picks should add up to (trims long scenes)")
+    ap.add_argument("--max-scene", type=float, default=15.0, help="cap a highlight range at this many seconds (default 15)")
+    ap.add_argument("--edl", help="write highlight ranges as START-END lines (cut.py --segments format)")
+    ap.add_argument("--sheet", help="write a contact sheet PNG with the first frame of every scene")
+    add_common(ap)
+    args = ap.parse_args()
+    apply_common(args)
+
+    meta = probe(args.input)
+    if not meta.get("video"):
+        die("input has no video stream")
+    dur = meta.get("duration") or 0.0
+    cuts = detect_scenes(args.input, args.threshold, args.min_scene, dur)
+    bounds = cuts + [dur]
+    step_s = 0.5
+    env = audio_envelope(args.input, step_s) if meta.get("audio") else []
+
+    scenes = []
+    for i in range(len(bounds) - 1):
+        s, e = bounds[i], bounds[i + 1]
+        if e - s <= 0.05:
+            continue
+        seg = env[int(s / step_s): max(int(s / step_s) + 1, int(e / step_s))] if env else []
+        energy = (sum(seg) / len(seg)) if seg else 0.0
+        peak = max(seg) if seg else 0.0
+        scenes.append({"index": len(scenes), "start": round(s, 3), "end": round(e, 3), "duration": round(e - s, 3),
+                       "audio_rms": round(energy, 4), "audio_peak": round(peak, 4)})
+    peaks = []
+    if env:
+        thr = sorted(env)[int(len(env) * 0.9)] if len(env) > 10 else max(env)
+        for i, val in enumerate(env):
+            if val >= thr and val > 0.02 and (i == 0 or env[i - 1] < val) and (i == len(env) - 1 or env[i + 1] <= val):
+                peaks.append({"time": round(i * step_s, 2), "rms": round(val, 4)})
+        peaks = sorted(peaks, key=lambda p: -p["rms"])[:20]
+        peaks.sort(key=lambda p: p["time"])
+
+    result: Dict = {"file": args.input, "duration": round(dur, 3), "scene_count": len(scenes), "scenes": scenes, "audio_peaks": peaks}
+    info(f"{len(scenes)} scenes, {len(peaks)} audio peaks over {dur:.1f}s")
+
+    if args.highlights:
+        ranked = sorted(scenes, key=lambda sc: (-sc["audio_rms"], sc["start"]))[: args.highlights]
+        picks: List[Tuple[float, float]] = []
+        budget = args.target if args.target else None
+        per = (budget / max(1, len(ranked))) if budget else args.max_scene
+        for sc in ranked:
+            length = min(sc["duration"], per, args.max_scene)
+            # take the loudest window inside the scene
+            best_s = sc["start"]
+            if env and length < sc["duration"]:
+                best, best_s = -1.0, sc["start"]
+                win = max(1, int(length / step_s))
+                lo, hi = int(sc["start"] / step_s), max(int(sc["start"] / step_s) + 1, int(sc["end"] / step_s) - win)
+                for i in range(lo, hi + 1):
+                    val = sum(env[i:i + win])
+                    if val > best:
+                        best, best_s = val, i * step_s
+            picks.append((round(best_s, 2), round(min(sc["end"], best_s + length), 2)))
+        picks.sort()
+        result["highlights"] = [{"start": s, "end": e, "duration": round(e - s, 2)} for s, e in picks]
+        result["highlights_total"] = round(sum(e - s for s, e in picks), 2)
+        info(f"proposed {len(picks)} highlight ranges totalling {result['highlights_total']:.1f}s")
+        if args.edl:
+            with open(args.edl, "w", encoding="utf-8") as fh:
+                for s, e in picks:
+                    fh.write(f"{s:.2f}-{e:.2f}\n")
+            info(f"wrote {args.edl}")
+
+    if args.sheet:
+        n = len(scenes)
+        cols = min(4, max(1, n))
+        rows = max(1, math.ceil(n / cols))
+        tile_w = 1280 // cols // 2 * 2
+        # exactly one frame per scene: the frame index at the scene start
+        fps = meta["video"].get("fps") or 30.0
+        expr = "+".join(f"eq(n\\,{int(round(sc['start'] * fps))})" for sc in scenes)
+        vf = (f"select='{expr}',scale={tile_w}:-2,drawtext=text='%{{pts\\:hms}}':fontcolor=white:fontsize=h/14:box=1:boxcolor=black@0.55:boxborderw=4:x=6:y=6,"
+              f"tile={cols}x{rows}:padding=2:margin=2:color=0x202020")
+        run(ffmpeg_base() + ["-i", args.input, "-vf", vf, "-frames:v", "1", "-fps_mode", "vfr", args.sheet])
+        info(f"wrote {args.sheet}")
+        result["sheet"] = args.sheet
+
+    if args.json:
+        emit(None, **result)
+    else:
+        print_json(result)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())