schnippo 0.11.0__py3-none-any.whl

schnippo/__init__.py

@@ -0,0 +1,3 @@
+"""schnippo: AI rough-cut MCP server for DaVinci Resolve Studio."""
+
+__version__ = "0.11.0"

schnippo/acoustic.py

@@ -0,0 +1,166 @@
+"""Acoustic analysis of the 16 kHz mono WAV (numpy, no Torch).
+
+* RMS envelope (25 ms window, 10 ms hop) in dBFS.
+* Noise floor = low percentile of the envelope; activity threshold = floor + delta.
+  This replaces the Phase-1 rule max(-35 dB, mean-18 dB), which on a quiet recording with a very low
+  room noise put the threshold *above* half of the speech frames.
+* Voicing per frame = peak of the normalised autocorrelation in the 75–400 Hz lag range (40 ms window).
+  Voiced sounds ("äh", "hm", vowels) have a clear periodicity, breaths/clicks do not.
+
+Regions of activity are classified as ``voiced`` (filler candidate), ``breath`` (unvoiced, breath-like
+duration) or ``click`` (very short transient).
+"""
+
+from __future__ import annotations
+
+import wave
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import numpy as np
+
+SR = 16000
+HOP = 160  # 10 ms
+WIN = 400  # 25 ms
+VWIN = 640  # 40 ms voicing window
+LAG_MIN, LAG_MAX = SR // 400, SR // 75  # 40 .. 213 samples
+
+
+@dataclass
+class AcousticParams:
+    floor_percentile: float = 10.0
+    delta_db: float = 25.0  # activity threshold above the noise floor
+    min_threshold_db: float = -60.0  # never below this (digital silence / heavy denoise)
+    max_threshold_db: float = -30.0
+    min_region_s: float = 0.06
+    merge_gap_s: float = 0.08
+    voiced_corr: float = 0.6  # frame is voiced if autocorrelation peak >= this
+    voiced_min_s: float = 0.15  # region needs at least this much voiced material (calibrated on real take)
+    voiced_ratio: float = 0.6  # ... and this share of its active frames voiced
+    click_max_s: float = 0.08
+
+    def key(self) -> list:
+        return [self.floor_percentile, self.delta_db, self.min_threshold_db, self.max_threshold_db, self.min_region_s,
+                self.merge_gap_s, self.voiced_corr, self.voiced_min_s, self.voiced_ratio, self.click_max_s, 2]
+
+
+@dataclass
+class Acoustic:
+    env_db: np.ndarray  # per 10 ms frame
+    voicing: np.ndarray  # per 10 ms frame, 0..1
+    floor_db: float
+    threshold_db: float
+    duration_s: float
+    params: AcousticParams = field(default_factory=AcousticParams)
+
+    # ---- frame helpers ----
+    def _sl(self, t0: float, t1: float) -> slice:
+        return slice(max(0, int(round(t0 * 100))), max(0, int(round(t1 * 100))))
+
+    def active(self, t0: float, t1: float) -> np.ndarray:
+        return self.env_db[self._sl(t0, t1)] > self.threshold_db
+
+    def regions(self, t0: float, t1: float) -> list[tuple[float, float]]:
+        """Active (non-silent) sub-intervals of [t0, t1]."""
+        act = self.active(t0, t1)
+        base = int(round(t0 * 100))
+        out: list[list[float]] = []
+        i = 0
+        while i < len(act):
+            if act[i]:
+                j = i
+                while j < len(act) and act[j]:
+                    j += 1
+                a, b = (base + i) / 100, (base + j) / 100
+                if out and a - out[-1][1] <= self.params.merge_gap_s:
+                    out[-1][1] = b
+                else:
+                    out.append([a, b])
+                i = j
+            else:
+                i += 1
+        return [(max(a, t0), min(b, t1)) for a, b in out if b - a >= self.params.min_region_s]
+
+    def classify(self, t0: float, t1: float) -> dict:
+        sl = self._sl(t0, t1)
+        env, voi = self.env_db[sl], self.voicing[sl]
+        act = env > self.threshold_db
+        voiced = (voi >= self.params.voiced_corr) & act
+        vs = float(voiced.sum()) / 100
+        ratio = float(voiced.sum()) / max(1, int(act.sum()))
+        dur = t1 - t0
+        if vs >= self.params.voiced_min_s and ratio >= self.params.voiced_ratio:
+            cls = "voiced"
+        elif dur <= self.params.click_max_s:
+            cls = "click"
+        else:
+            cls = "breath"
+        return {"class": cls, "peak_db": round(float(env.max()) if len(env) else -120.0, 1),
+                "voiced_s": round(vs, 2), "voiced_ratio": round(ratio, 2)}
+
+    def silent_runs(self, t0: float, t1: float, min_s: float) -> list[tuple[float, float]]:
+        act = self.active(t0, t1)
+        base = int(round(t0 * 100))
+        out, i = [], 0
+        while i < len(act):
+            if not act[i]:
+                j = i
+                while j < len(act) and not act[j]:
+                    j += 1
+                if (j - i) / 100 >= min_s:
+                    out.append(((base + i) / 100, (base + j) / 100))
+                i = j
+            else:
+                i += 1
+        return out
+
+    # ---- persistence ----
+    def save(self, path: Path) -> None:
+        np.savez_compressed(path, env=self.env_db.astype(np.float32), voi=self.voicing.astype(np.float16),
+                            meta=np.array([self.floor_db, self.threshold_db, self.duration_s]),
+                            key=np.array(self.params.key(), dtype=float))
+
+    @classmethod
+    def load(cls, path: Path, params: AcousticParams) -> "Acoustic | None":
+        if not path.exists():
+            return None
+        d = np.load(path)
+        if list(d["key"]) != [float(x) for x in params.key()]:
+            return None
+        floor, thr, dur = (float(x) for x in d["meta"])
+        return cls(d["env"].astype(np.float64), d["voi"].astype(np.float64), floor, thr, dur, params)
+
+
+def read_wav(path: Path) -> np.ndarray:
+    with wave.open(str(path)) as w:
+        if w.getframerate() != SR or w.getnchannels() != 1 or w.getsampwidth() != 2:
+            raise ValueError("expected 16 kHz mono 16-bit WAV")
+        return np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16).astype(np.float64) / 32768.0
+
+
+def _frames(xp: np.ndarray, win: int, i0: int, i1: int) -> np.ndarray:
+    """Frames i0..i1 (hop 10 ms) of the padded signal xp (padded by win//2 in front)."""
+    idx = np.arange(win)[None, :] + (np.arange(i0, i1) * HOP)[:, None]
+    return xp[idx]
+
+
+def analyze_wav(path: Path, params: AcousticParams | None = None) -> Acoustic:
+    params = params or AcousticParams()
+    x = read_wav(path)
+    n = 1 + max(0, (len(x) - 1) // HOP)
+    xp_e = np.pad(x, (WIN // 2, WIN))
+    xp_v = np.pad(x, (VWIN // 2, VWIN))
+    env = np.empty(n)
+    voi = np.empty(n)
+    nfft, hann = 1024, np.hanning(VWIN)[None, :]
+    for i0 in range(0, n, 4096):  # chunked: bounded memory for hour-long material
+        i1 = min(n, i0 + 4096)
+        fe = _frames(xp_e, WIN, i0, i1)
+        env[i0:i1] = 10 * np.log10(np.mean(fe * fe, axis=1) + 1e-12)
+        fv = _frames(xp_v, VWIN, i0, i1)
+        fv = (fv - fv.mean(axis=1, keepdims=True)) * hann
+        ac = np.fft.irfft(np.abs(np.fft.rfft(fv, nfft)) ** 2, nfft)[:, :LAG_MAX + 1]
+        voi[i0:i1] = np.clip(ac[:, LAG_MIN:LAG_MAX + 1].max(axis=1) / (ac[:, 0] + 1e-12), 0, 1)
+    floor = float(np.percentile(env, params.floor_percentile))
+    thr = float(np.clip(floor + params.delta_db, params.min_threshold_db, params.max_threshold_db))
+    return Acoustic(env, voi, floor, thr, len(x) / SR, params)

schnippo/analysis.py

@@ -0,0 +1,183 @@
+"""Deterministic base analysis: fillers, pauses, gap fallback, repetitions, restart candidates.
+
+Output is flags + findings only. Nothing here decides what gets cut.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+from .acoustic import Acoustic
+from .config import Config
+from .models import AnalyzedTranscript, Finding, RawTranscript, Word
+
+_PUNCT = re.compile(r"[^\wäöüß']+", re.UNICODE)
+
+
+def norm(text: str) -> str:
+    t = unicodedata.normalize("NFC", text).lower().strip()
+    return _PUNCT.sub("", t)
+
+
+def _gap_id(prefix: str, prev_num: int, k: int) -> str:
+    return f"{prefix}{prev_num:04d}" + (f".{k}" if k > 1 else "")
+
+
+def analyze(clip_id: str, raw: RawTranscript, cfg: Config, acoustic: Acoustic | None = None,
+            clip_duration_s: float | None = None) -> AnalyzedTranscript:
+    from .config import EN_HARD_FILLERS
+    hard = {norm(f) for f in cfg.hard_fillers} | ({norm(f) for f in EN_HARD_FILLERS}
+                                                   if (raw.language or "").lower().startswith("en") else set())
+    soft = {norm(f) for f in cfg.soft_fillers}
+
+    tokens: list[Word] = []
+    for t in raw.tokens:
+        w = t.model_copy(deep=True)
+        n = norm(w.text)
+        if n in hard or re.fullmatch(r"(ä+h+m*|ö+h+m*|e+h+m+|h+m+|m+h+m+)", n or "-"):
+            w.kind = "filler"
+        elif n in soft:
+            w.flags.append("soft_filler")
+        tokens.append(w)
+
+    # --- word edges stretched over silence (Gladia sometimes adds a pause to a word, see NOTES) ---
+    if acoustic is not None:
+        for w in tokens:
+            runs = acoustic.silent_runs(w.start_s, w.end_s, cfg.clamp_silence_s)
+            if not runs:
+                continue
+            # silence followed by at most a short onset of the next word -> the word really ended before it
+            if w.end_s - runs[-1][1] <= 0.3:
+                w.flags.append(f"end_clamped:{w.end_s:.2f}")
+                w.end_s = round(runs[-1][0], 3)
+            elif runs[0][0] - w.start_s <= 0.3:
+                w.flags.append(f"start_clamped:{w.start_s:.2f}")
+                w.start_s = round(runs[0][1], 3)
+
+    # --- gaps: pauses and speech without a recognised word (filler fallback) ---
+    entries: list[Word] = []
+    findings: list[Finding] = []
+    n_inferred = 0
+    bounds = [(0.0, None)] + [(t.end_s, t) for t in tokens]
+    for i, (gap_start, prev) in enumerate(bounds):
+        nxt = tokens[i] if i < len(tokens) else None
+        gap_end = nxt.start_s if nxt else (clip_duration_s if clip_duration_s is not None else gap_start)
+        prev_num = int(prev.id[1:]) if prev else 0
+        if prev:
+            entries.append(prev)
+        if gap_end - gap_start <= 1e-3:
+            continue
+        pieces: list[tuple[str, float, float, dict]] = []  # (kind, t0, t1, info)
+        cur = gap_start
+        for a, b in (acoustic.regions(gap_start, gap_end) if acoustic is not None else []):
+            # activity that merely continues a neighbouring word (ASR edges are tight) is not an event
+            tp, tn = bool(prev) and a - gap_start <= 0.04, bool(nxt) and gap_end - b <= 0.04
+            if tp and tn and b - a < cfg.bridge_min_s:  # voice runs through the whole gap: coarticulation
+                continue
+            if (tp or tn) and b - a < cfg.hug_max_s:
+                continue
+            info = acoustic.classify(a, b)
+            if info["class"] == "click":
+                continue
+            if info["class"] == "voiced" and b - a < cfg.gap_speech_min_s:
+                continue
+            if a - cur > 0:
+                pieces.append(("pause", cur, a, {}))
+            pieces.append((info["class"], a, b, info))
+            cur = b
+        if gap_end - cur > 0:
+            pieces.append(("pause", cur, gap_end, {}))
+        kp = ku = kb = 0
+        for kind, a, b, info in pieces:
+            if kind == "pause":
+                if b - a < cfg.pause_threshold_s:
+                    continue
+                kp += 1
+                flags = ["long_pause"] if b - a >= cfg.long_pause_s else []
+                if prev is None:
+                    flags.append("leading")
+                if nxt is None:
+                    flags.append("trailing")
+                entries.append(Word(id=_gap_id("p", prev_num, kp), text=f"{b - a:.1f}s", start_s=round(a, 3),
+                                    end_s=round(b, 3), kind="pause", flags=flags))
+            elif kind == "breath":
+                kb += 1
+                entries.append(Word(id=_gap_id("b", prev_num, kb), text="breath", start_s=round(a, 3), end_s=round(b, 3),
+                                    kind="breath", flags=["inferred"]))
+            else:
+                ku += 1
+                n_inferred += 1
+                uid = _gap_id("u", prev_num, ku)
+                entries.append(Word(id=uid, text="?", start_s=round(a, 3), end_s=round(b, 3), kind="filler",
+                                    flags=["inferred", "filler?"]))
+                findings.append(Finding(type="unrecognized_speech", first=(uid, uid),
+                                        note=f"stimmhaft ohne Wort {a:.2f}-{b:.2f}s, {info['peak_db']} dB (Füllwort/Dehnung?)"))
+
+    # --- repetitions / restarts over content tokens (fillers + gap entries ignored) ---
+    content = [t for t in tokens if t.kind == "word"]
+    keys = [norm(t.text) for t in content]
+    flagged_until = -1
+    for i in range(len(content)):
+        if i <= flagged_until:
+            continue
+        best = None
+        for n in range(6, 0, -1):
+            if i + n > len(keys):
+                continue
+            gram = keys[i:i + n]
+            if not all(gram):
+                continue
+            # the repeat must start soon after the first occurrence ends (restart = "Neuanfang")
+            window = 3 if n == 1 else n + 8
+            for j in range(i + n, min(i + n + window, len(keys) - n + 1)):
+                if keys[j:j + n] == gram:
+                    if content[j].start_s - content[i + n - 1].end_s > 12.0:
+                        break
+                    best = (n, j)
+                    break
+            if best:
+                break
+        if not best:
+            continue
+        n, j = best
+        first = (content[i].id, content[i + n - 1].id)
+        second = (content[j].id, content[j + n - 1].id)
+        between = j - (i + n)
+        if n == 1 and between == 0:
+            ftype, flag = "repeat", "repeat"
+            note = f"„{content[i].text} {content[j].text}“"
+        elif n == 1:
+            continue  # single word recurring a few words later: too common in normal speech
+        else:
+            ftype, flag = "restart_candidate", "restart_candidate"
+            note = f"„{' '.join(t.text for t in content[i:i + n])}“ wiederholt" + (
+                f" nach {between} Wort/Wörtern" if between else "")
+        for t in content[i:j] if ftype == "restart_candidate" else content[i:i + n]:
+            if flag not in t.flags:
+                t.flags.append(flag)
+        findings.append(Finding(type=ftype, first=first, second=second, note=note))
+        flagged_until = i + n - 1
+
+    for e in entries:
+        if "long_pause" in e.flags:
+            findings.append(Finding(type="long_pause", first=(e.id, e.id), note=e.text))
+
+    stats = {
+        "words": sum(1 for t in tokens if t.kind == "word"),
+        "fillers_asr": sum(1 for t in tokens if t.kind == "filler"),
+        "fillers_inferred": n_inferred,
+        "soft_fillers": sum(1 for t in tokens if "soft_filler" in t.flags),
+        "breaths": sum(1 for e in entries if e.kind == "breath"),
+        "pauses": sum(1 for e in entries if e.kind == "pause"),
+        "repeats": sum(1 for f in findings if f.type == "repeat"),
+        "restart_candidates": sum(1 for f in findings if f.type == "restart_candidate"),
+    }
+    findings.sort(key=lambda f: _sort_key(f.first[0]))
+    return AnalyzedTranscript(clip_id=clip_id, provider=raw.provider, language=raw.language,
+                              entries=entries, findings=findings, stats=stats)
+
+
+def _sort_key(entry_id: str) -> tuple[int, int]:
+    m = re.match(r"[wpub](\d+)(?:\.(\d+))?", entry_id)
+    return (int(m.group(1)), 0 if entry_id[0] == "w" else int(m.group(2) or 1)) if m else (0, 0)

schnippo/audio.py

@@ -0,0 +1,267 @@
+"""Deterministic audio measurement: loudness (EBU R128 via ffmpeg ebur128), true peak, noise floor and a speech
+spectral profile compared to a neutral long-term speech spectrum. Recommendations only – Resolve applies them.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+import numpy as np
+
+from .media import _bin
+
+SR = 48000
+# Long-term average speech spectrum, 1/3-octave levels in dB (approximation of Byrne et al. 1994, male/female average).
+LTASS = {50: 32, 63: 38, 80: 43, 100: 47, 125: 53, 160: 57, 200: 58, 250: 59, 315: 59, 400: 58, 500: 57, 630: 55,
+         800: 53, 1000: 51, 1250: 49, 1600: 48, 2000: 47, 2500: 45, 3150: 44, 4000: 43, 5000: 42, 6300: 41, 8000: 39,
+         10000: 37}
+BANDS = {"rumble": (50, 63), "boxy": (200, 250, 315, 400, 500), "sibilance": (5000, 6300, 8000)}
+REF_NORM = (500, 630, 800, 1000, 1250, 1600, 2000)  # both spectra are aligned on this range
+
+
+def ebur128(input_args: list[str], filter_complex: str | None = None) -> dict:
+    """Integrated loudness (LUFS), loudness range (LU) and true peak (dBTP) of an ffmpeg input."""
+    cmd = [_bin("ffmpeg"), "-nostdin", "-hide_banner", "-v", "info", *input_args]
+    if filter_complex:
+        cmd += ["-filter_complex", filter_complex + ",ebur128=peak=true[out]", "-map", "[out]"]
+    else:
+        cmd += ["-map", "0:a:0", "-af", "ebur128=peak=true"]
+    err = subprocess.run(cmd + ["-f", "null", "-"], capture_output=True, text=True, encoding="utf-8", errors="replace").stderr
+    summ = err[err.rfind("Summary:"):]
+    get = lambda pat: float(m.group(1)) if (m := re.search(pat, summ, re.S)) else None
+    return {"lufs": get(r"I:\s+(-?[\d.]+) LUFS"), "lra": get(r"LRA:\s+(-?[\d.]+) LU"), "true_peak": get(r"Peak:\s+(-?[\d.inf]+) dBFS")}
+
+
+def program_filter(pieces: list[tuple[float, float]]) -> str:
+    """ffmpeg filter that concatenates source time ranges of input 0 (the planned cut, without Resolve)."""
+    parts = [f"[0:a:0]atrim=start={a:.5f}:end={b:.5f},asetpts=PTS-STARTPTS[p{k}]" for k, (a, b) in enumerate(pieces)]
+    return ";".join(parts) + ";" + "".join(f"[p{k}]" for k in range(len(pieces))) + f"concat=n={len(pieces)}:v=0:a=1"
+
+
+def read_pcm(path: Path) -> np.ndarray:
+    raw = subprocess.run([_bin("ffmpeg"), "-nostdin", "-v", "error", "-i", str(path), "-map", "0:a:0", "-ac", "1", "-ar", str(SR),
+                          "-f", "s16le", "-"], capture_output=True, check=True).stdout
+    return np.frombuffer(raw, np.int16).astype(np.float64) / 32768.0
+
+
+def third_octave_levels(x: np.ndarray, active: list[tuple[float, float]]) -> dict[int, float]:
+    """Mean power per 1/3-octave band over the active (speech) intervals, in dB."""
+    nfft = 4096
+    win = np.hanning(nfft)
+    acc, n = np.zeros(nfft // 2 + 1), 0
+    for a, b in active:
+        seg = x[int(a * SR):int(b * SR)]
+        for s in range(0, len(seg) - nfft, nfft // 2):
+            acc += np.abs(np.fft.rfft(seg[s:s + nfft] * win)) ** 2
+            n += 1
+    if n == 0:
+        return {}
+    psd = acc / n
+    freqs = np.fft.rfftfreq(nfft, 1 / SR)
+    out = {}
+    for fc in LTASS:
+        lo, hi = fc / 2 ** (1 / 6), fc * 2 ** (1 / 6)
+        sel = (freqs >= lo) & (freqs < hi)
+        out[fc] = float(10 * np.log10(psd[sel].sum() + 1e-20)) if sel.any() else -200.0
+    return out
+
+
+def spectral_profile(levels: dict[int, float]) -> dict:
+    """Band deviations (dB) of measured vs LTASS after aligning both on 500–2000 Hz."""
+    if not levels:
+        return {}
+    off = np.mean([levels[f] for f in REF_NORM]) - np.mean([LTASS[f] for f in REF_NORM])
+    dev = {f: levels[f] - off - LTASS[f] for f in LTASS}
+    band = lambda fs: 10 * np.log10(np.mean([10 ** (dev[f] / 10) for f in fs]))
+    return {"rumble_db": round(float(band(BANDS["rumble"])), 1), "boxy_db": round(float(band(BANDS["boxy"])), 1),
+            "sibilance_db": round(float(band(BANDS["sibilance"])), 1), "per_band": {f: round(float(v), 1) for f, v in dev.items()}}
+
+
+def recommendations(m: dict, target_lufs: float = -14.0, tp_max: float = -1.0) -> list[str]:
+    rec = []
+    if m.get("lufs") is not None:
+        rec.append(f"Normalisieren: {m['lufs']:.1f} → {target_lufs:.1f} LUFS ({target_lufs - m['lufs']:+.1f} dB)")
+        if m.get("true_peak") is not None and m["true_peak"] + (target_lufs - m["lufs"]) > tp_max:
+            rec.append(f"Limiter nötig: True Peak nach Verstärkung ≈ {m['true_peak'] + target_lufs - m['lufs']:+.1f} dBTP > {tp_max} dBTP "
+                       "(Server: Limiter → Multiband Compressor, True Peak ≈ −2,8 dBTP)")
+    sp = m.get("spectrum") or {}
+    if sp:
+        if sp["rumble_db"] > 3:  # 04_polish: every EQ measure needs a reason from the measurement
+            rec.append(f"Hochpass ~80 Hz: Rumpeln {sp['rumble_db']:+.1f} dB über Referenz")
+        else:
+            rec.append(f"Kein Hochpass nötig: Rumpeln unauffällig ({sp['rumble_db']:+.1f} dB)")
+        if sp["boxy_db"] > 3:
+            rec.append(f"Leichte Absenkung 200–500 Hz (−2 bis −3 dB): dumpf/boxy {sp['boxy_db']:+.1f} dB über Referenz")
+        if sp["sibilance_db"] > 4:
+            rec.append(f"De-Esser: Zischlaute 5–8 kHz {sp['sibilance_db']:+.1f} dB über Referenz")
+    return rec
+
+
+def identical_audio_streams(path: str, seconds: float = 30.0) -> bool | None:
+    """True if the file has ≥ 2 audio streams and stream 2 equals stream 1 (difference < −80 dB over the first seconds).
+    Phones/apps often record the same mic twice; Resolve then puts both on A1/A2 and the programme is doubled."""
+    import json as _json
+
+    info = _json.loads(subprocess.run([_bin("ffprobe"), "-v", "error", "-select_streams", "a", "-show_entries", "stream=index",
+                                       "-of", "json", path], capture_output=True, text=True).stdout or "{}")
+    if len(info.get("streams", [])) < 2:
+        return None
+    err = subprocess.run([_bin("ffmpeg"), "-nostdin", "-v", "info", "-t", str(seconds), "-i", path, "-filter_complex",
+                          "[0:a:0][0:a:1]amerge=inputs=2,pan=mono|c0=c0-c1,volumedetect", "-f", "null", "-"],
+                         capture_output=True, text=True, encoding="utf-8", errors="replace").stderr
+    m = re.search(r"max_volume: (-?[\d.inf]+) dB", err)
+    return bool(m) and (m.group(1) == "-inf" or float(m.group(1)) < -80.0)
+
+
+# ---------- phase 6: source channels ----------
+CH_SR = 16000
+SAFETY_SNR_DB = 1.5  # SNR closer than this on two correlated channels → same mic, different gain
+CLIP_SAMPLES = 10  # more full-scale samples than this in the analysed span → channel counts as clipped
+
+
+def source_channels(path: str) -> list[tuple[int, int]]:
+    """(audio stream ordinal, channel in stream) in Resolve's numbering order: channel k+1 = k-th entry
+    (embedded_audio_channels counts across streams, measured on 21.1.2 with 2 mono AAC streams)."""
+    import json as _json
+
+    info = _json.loads(subprocess.run([_bin("ffprobe"), "-v", "error", "-select_streams", "a", "-show_entries",
+                                       "stream=index,channels", "-of", "json", path], capture_output=True, text=True).stdout or "{}")
+    return [(s, c) for s, st in enumerate(info.get("streams", [])) for c in range(int(st.get("channels") or 1))]
+
+
+def _channel_pcm(path: str, stream: int, ch: int, seconds: float) -> np.ndarray:
+    raw = subprocess.run([_bin("ffmpeg"), "-nostdin", "-v", "error", "-t", str(seconds), "-i", path, "-map", f"0:a:{stream}",
+                          "-af", f"pan=mono|c0=c{ch}", "-ar", str(CH_SR), "-f", "s16le", "-"], capture_output=True).stdout
+    return np.frombuffer(raw, np.int16).astype(np.float64) / 32768.0
+
+
+def _max_corr(a: np.ndarray, b: np.ndarray, max_lag: int) -> float:
+    """Highest Pearson correlation over lags ±max_lag samples (spaced stereo mics are up to ~1–2 ms apart)."""
+    m = min(len(a), len(b), 60 * CH_SR)
+    a, b = a[:m] - a[:m].mean(), b[:m] - b[:m].mean()
+    if m < 2 * max_lag + 2 or a.std() == 0 or b.std() == 0:
+        return 0.0
+    best = 0.0
+    for lag in range(-max_lag, max_lag + 1):
+        x, y = (a[lag:], b[:m - lag]) if lag >= 0 else (a[:m + lag], b[-lag:])
+        c = float(np.dot(x, y) / (np.linalg.norm(x) * np.linalg.norm(y) + 1e-12))
+        best = max(best, c)
+    return best
+
+
+def channel_analysis(path: str, seconds: float = 180.0, unbalanced_db: float = 3.0) -> dict:
+    """Per source channel: level (RMS, LUFS), speech level (p90 of 50-ms RMS), noise floor (p10), speech/noise ratio;
+    correlation between channels (best over ±2 ms lag); class identisch | unausgewogen | verschieden | stereo | mono; best channel.
+
+    Classes: corr ≥ 0.999 and < 0.1 dB apart → identisch; level or noise floor > unbalanced_db apart (corr ≥ 0.5)
+    → unausgewogen; corr < 0.5 → verschieden (two mics, e.g. lavalier + camera); otherwise → stereo (kept).
+    Best = highest speech/noise ratio, ties → higher speech level."""
+    chans = source_channels(path)
+    if not chans:
+        return {"channels": [], "class": "none", "best": None, "reason": "keine Tonspur"}
+    win = CH_SR // 20
+    stats, pcms = [], []
+    for k, (s, c) in enumerate(chans, 1):
+        x = _channel_pcm(path, s, c, seconds)
+        pcms.append(x)
+        n = len(x) // win
+        rms = np.sqrt(np.mean(x[:n * win].reshape(n, win) ** 2, axis=1) + 1e-12) if n else np.array([1e-6])
+        db = 20 * np.log10(rms)
+        speech, floor = float(np.percentile(db, 90)), float(np.percentile(db, 10))
+        loud = ebur128(["-t", str(seconds), "-i", path], f"[0:a:{s}]pan=mono|c0=c{c}")
+        stats.append({"channel": k, "stream": s, "in_stream": c, "rms_db": round(float(20 * np.log10(np.sqrt(np.mean(x ** 2)) + 1e-12)), 1),
+                      "lufs": loud.get("lufs"), "speech_db": round(speech, 1), "noise_db": round(floor, 1),
+                      "snr_db": round(speech - floor, 1),
+                      "clipped": int(np.sum(np.abs(x) >= 0.97)) if len(x) else 0})  # 16-kHz resample rounds the plateaus
+    out = {"channels": stats, "correlation": None}
+    if len(stats) == 1:
+        out.update({"class": "mono", "best": 1, "reason": "nur ein Kanal"})
+        return out
+    corr = _max_corr(pcms[0], pcms[1], max_lag=int(0.002 * CH_SR))
+    out["correlation"] = round(corr, 4)
+    s1, s2 = stats[0], stats[1]
+    level_gap, noise_gap = abs(s1["speech_db"] - s2["speech_db"]), abs(s1["noise_db"] - s2["noise_db"])
+    best = max(stats[:2], key=lambda s: (s["snr_db"], s["speech_db"]))
+    safety = None
+    loud_ch = s1 if s1["speech_db"] >= s2["speech_db"] else s2
+    if corr >= 0.5 and level_gap > unbalanced_db and (abs(s1["snr_db"] - s2["snr_db"]) < SAFETY_SNR_DB
+                                                      or loud_ch.get("clipped", 0) > CLIP_SAMPLES):
+        # same mic, one channel recorded quieter (safety track, typically −6 dB): the SNR is equal, so take the louder
+        # main channel – unless it clips (that is what the safety track is for). Phase 8: the choice flipped per clip.
+        main, quiet = (s1, s2) if s1["speech_db"] >= s2["speech_db"] else (s2, s1)
+        best = quiet if main.get("clipped", 0) > CLIP_SAMPLES else main
+        safety = (f"Sicherheitsspur: Kanal {quiet['channel']} ist {level_gap:.1f} dB leiser bei gleichem Rauschabstand → "
+                  + (f"Kanal {main['channel']} übersteuert ({main['clipped']} Samples), deshalb die leise Spur"
+                     if best is quiet else f"lauter Hauptkanal {main['channel']}"))
+    if corr >= 0.999 and level_gap < 0.1 and noise_gap < 0.1:
+        cls, reason = "identisch", f"Kanäle identisch (Korrelation {corr:.4f}) → Kanal {best['channel']} mittig, Kopie weg"
+    elif corr >= 0.5 and (level_gap > unbalanced_db or noise_gap > unbalanced_db):
+        cls = "unausgewogen"
+        reason = safety or (f"Kanal {best['channel']}: Sprache {best['speech_db']} dB, Rauschen {best['noise_db']} dB "
+                  f"(Abstand {best['snr_db']} dB) – Pegelunterschied {level_gap:.1f} dB, Rauschunterschied {noise_gap:.1f} dB")
+    elif corr < 0.5:
+        cls = "verschieden"
+        other = s2 if best is s1 else s1
+        reason = (f"zwei verschiedene Mikrofone (Korrelation {corr:.2f}); Kanal {best['channel']} hat das bessere "
+                  f"Sprach/Rausch-Verhältnis ({best['snr_db']} dB gegenüber {other['snr_db']} dB)")
+    else:
+        cls, best, reason = "stereo", None, f"echtes Stereo (Korrelation {corr:.2f}, Pegel ausgeglichen) → bleibt Stereo"
+    out.update({"class": cls, "best": best["channel"] if best else None, "reason": reason})
+    return out
+
+
+def speaker_channels(path: str, spans: dict, min_gap_db: float = 6.0, max_s: float = 90.0) -> dict:
+    """Interview with one mic per person: which source channel carries which speaker. spans = {speaker: [(t0, t1), …]}
+    (word times from the diarized transcript). Per speaker the speech level (RMS over its words, up to max_s) per channel;
+    a speaker gets its own channel if that channel is ≥ min_gap_db louder for it. Returns {"by_speaker": {spk: channel},
+    "levels": {spk: [dB per channel]}, "split": bool}."""
+    chans = source_channels(path)
+    if len(chans) < 2 or len(spans) < 2:
+        return {"by_speaker": {}, "levels": {}, "split": False}
+    pcm = [_channel_pcm(path, s, c, 1e6) for s, c in chans[:2]]
+    levels, best = {}, {}
+    for spk, sp in spans.items():
+        acc, used = [[], []], 0.0
+        for t0, t1 in sp:
+            if used >= max_s:
+                break
+            a, b = int(t0 * CH_SR), int(t1 * CH_SR)
+            for k in (0, 1):
+                acc[k].append(pcm[k][a:b])
+            used += t1 - t0
+        if used < 1.0:
+            continue
+        db = [round(float(20 * np.log10(np.sqrt(np.mean(np.concatenate(x) ** 2)) + 1e-12)), 1) for x in acc]
+        levels[spk] = db
+        if abs(db[0] - db[1]) >= min_gap_db:
+            best[spk] = 1 if db[0] > db[1] else 2
+    split = len(set(best.values())) >= 2
+    return {"by_speaker": best if split else {}, "levels": levels, "split": split}
+
+
+def louder_channels(path: str, spans: list[tuple[float, float]], min_gap_db: float = 6.0) -> list[int | None]:
+    """Per time span the clearly louder of the first two source channels (1 or 2), None if they are within min_gap_db.
+    The signal decides, not the diarization: it took two interviewer questions for the guest (Phase 8)."""
+    chans = source_channels(path)
+    if len(chans) < 2:
+        return [None] * len(spans)
+    pcm = [_channel_pcm(path, s, c, 1e6) for s, c in chans[:2]]
+    out: list[int | None] = []
+    for t0, t1 in spans:
+        db = []
+        for x in pcm:
+            seg = x[int(t0 * CH_SR):int(t1 * CH_SR)]
+            db.append(float(20 * np.log10(np.sqrt(np.mean(seg ** 2)) + 1e-12)) if len(seg) else -120.0)
+        out.append(None if abs(db[0] - db[1]) < min_gap_db else (1 if db[0] > db[1] else 2))
+    return out
+
+
+def channel_balance(path: Path) -> dict:
+    """RMS per output channel of a render (dB) → verification that both speakers play equally loud."""
+    err = subprocess.run([_bin("ffmpeg"), "-nostdin", "-nostats", "-v", "info", "-i", str(path), "-map", "0:a:0", "-af",
+                          "astats=measure_perchannel=RMS_level:measure_overall=none", "-f", "null", "-"],
+                         capture_output=True, text=True, encoding="utf-8", errors="replace").stderr
+    vals = [float(v) for v in re.findall(r"RMS level dB: (-?[\d.inf]+)", err) if v not in ("-inf", "inf")]
+    return {"rms_db": [round(v, 2) for v in vals], "diff_db": round(abs(vals[0] - vals[1]), 2) if len(vals) >= 2 else None}

schnippo/branding.py

@@ -0,0 +1,26 @@
+"""Names, links and brand files in ONE place: the bundle build, server, cards, setup texts and the update check read them."""
+
+from pathlib import Path
+
+DISPLAY_NAME = "Schnippo"
+SLUG = "schnippo"  # technical id: bundle name, cache folder, MCP server name; change only with a migration
+TAGLINE = "KI-Rohschnitt für DaVinci Resolve"
+TRADEMARK = "DaVinci Resolve ist eine Marke von Blackmagic Design. Schnippo ist ein unabhängiges Projekt und nicht mit Blackmagic Design verbunden."
+AUTHOR = "Seitz Dominik Visuals"
+AUTHOR_URL = "https://sdv.design"
+HOMEPAGE = "https://schnippo.com"
+REPOSITORY = "https://github.com/Seitzdominik/schnippo"
+REPO_SLUG = "Seitzdominik/schnippo"
+SUPPORT_URL = REPOSITORY + "/issues"  # later schnippo.com: change here only
+DOCS_URL = REPOSITORY + "#readme"
+RELEASES_URL = REPOSITORY + "/releases/latest"
+PRIVACY_URL = HOMEPAGE + "/privacy"
+
+LEGACY_SLUG = "resolve-cut"  # the working title: old folders stay readable
+LEGACY_EXPORT = "resolve-cut-export"
+
+
+def brand_file(name: str, placeholder: Path | None = None) -> Path | None:
+    """assets/brand/<name>, or the placeholder as long as the real file is not there."""
+    f = Path(__file__).resolve().parents[2] / "assets" / "brand" / name
+    return f if f.is_file() else placeholder