perf: numpy silence (drop 2nd ffmpeg pass) + phase timings

music_detector.py

@@ -16,9 +16,9 @@ are top-level so they can be unit-tested without a model.
 from __future__ import annotations
 
 import importlib
-import re
 import subprocess
 import threading
+import time
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -43,13 +43,14 @@ MUSIC_CLASSES = {
     "Jingle (music)",
 }
 
-_SILENCE_START_RE = re.compile(r"silence_start:\s*([0-9]+(?:\.[0-9]+)?)")
-_SILENCE_END_RE = re.compile(r"silence_end:\s*([0-9]+(?:\.[0-9]+)?)")
-
 _AST_LOCK = threading.Lock()
 # (feature_extractor, model, music_indices)
 _AST_RUNTIME: tuple[Any, Any, list[int]] | None = None
 
+# Per-call phase timings (seconds), overwritten on every judge_chunk_files_batched call.
+# Read by app.py to surface decode / fbank / inference breakdown in the log.
+_LAST_TIMINGS: dict[str, float] = {}
+
 
 # ---------------------------------------------------------------------------
 # Result type
@@ -157,60 +158,34 @@ def _top_labels_from_probs(
     return [id2label[int(i)] for i in top_idx if int(i) in id2label]
 
 
-def _probe_duration(path: str | Path) -> float | None:
-    """Return audio duration in seconds via ffprobe, or None on error."""
-    try:
-        cmd = [
-            "ffprobe", "-v", "error",
-            "-show_entries", "format=duration",
-            "-of", "default=noprint_wrappers=1:nokey=1",
-            str(path),
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
-        return float(result.stdout.strip())
-    except Exception:
-        return None
-
-
-def _compute_max_silence(path: str | Path) -> float | None:
-    """Return longest silence gap in seconds via ffmpeg silencedetect, or None on error.
-
-    Handles trailing silence (file ends while still silent) by using the file
-    duration as the implicit silence_end.
+def _max_silence_from_samples(
+    samples: np.ndarray,
+    *,
+    noise_db: float = -35.0,
+    frame_sec: float = 0.02,
+) -> float | None:
+    """Longest contiguous silence (seconds) computed from decoded samples.
+
+    Replaces a second ffmpeg `silencedetect` pass: we already have the mono16k
+    signal, so frame it (20 ms), threshold per-frame RMS at noise_db, and return
+    the longest run of silent frames. Matches ffmpeg's noise=-35dB intent.
     """
-    try:
-        # Note: do NOT use -v quiet here — it suppresses silencedetect filter messages.
-        # Use -hide_banner + -nostats to keep stderr clean while preserving filter output.
-        cmd = [
-            "ffmpeg", "-hide_banner", "-nostats",
-            "-i", str(path),
-            "-af", "silencedetect=noise=-35dB:d=0.5",
-            "-f", "null", "-",
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-        gaps: list[float] = []
-        pending: float | None = None
-        for line in result.stderr.splitlines():
-            m = _SILENCE_START_RE.search(line)
-            if m:
-                pending = float(m.group(1))
-                continue
-            m = _SILENCE_END_RE.search(line)
-            if m and pending is not None:
-                gap = float(m.group(1)) - pending
-                if gap > 0:
-                    gaps.append(gap)
-                pending = None
-
-        # Trailing silence: file ended before silence_end was emitted
-        if pending is not None:
-            duration = _probe_duration(path)
-            if duration is not None and duration > pending:
-                gaps.append(duration - pending)
-
-        return float(max(gaps)) if gaps else None
-    except Exception:
+    if len(samples) == 0:
+        return None
+    win = max(int(frame_sec * SAMPLE_RATE), 1)
+    n_frames = len(samples) // win
+    if n_frames == 0:
+        return None
+    frames = samples[: n_frames * win].reshape(n_frames, win)
+    rms = np.sqrt(np.mean(frames.astype(np.float32) ** 2, axis=1))
+    db = 20.0 * np.log10(np.maximum(rms, 1e-9))
+    silent = db < noise_db
+    if not silent.any():
         return None
+    # Run-length of True: diff of zero-padded int mask gives run boundaries.
+    edges = np.flatnonzero(np.diff(np.concatenate(([0], silent.view(np.int8), [0]))))
+    max_run = int((edges[1::2] - edges[0::2]).max())
+    return float(max_run * win / SAMPLE_RATE)
 
 
 def _signal_checks(
@@ -238,7 +213,7 @@ def _signal_checks(
         if rms_db < loudness_threshold_db:
             flags.append("low_loudness")
 
-    max_silence_sec = _compute_max_silence(path)
+    max_silence_sec = _max_silence_from_samples(samples)
     if max_silence_sec is not None and max_silence_sec > silence_threshold_sec:
         flags.append("long_silence")
 
@@ -283,8 +258,10 @@ def judge_chunk_files_batched(
         return samples, clipping, rms_db, max_silence, flags
 
     workers = min(n, n_decode_workers)
+    t_decode = time.time()
     with ThreadPoolExecutor(max_workers=workers) as ex:
         file_results = list(ex.map(_process_one, audio_paths))
+    decode_sec = time.time() - t_decode
 
     # Step 2: build flat window list for batched AST inference
     # windows[i] → chunk index window_owners[i]
@@ -303,19 +280,29 @@ def judge_chunk_files_batched(
     # Step 3: batched AST inference
     win_music_scores: list[float] = []
     win_top_labels: list[list[str]] = []
+    fbank_sec = 0.0
+    infer_sec = 0.0
 
     for i in range(0, len(windows), batch_size):
         batch_wins = [w for w in windows[i:i + batch_size]]
+        t_fb = time.time()
         inputs = fe(batch_wins, sampling_rate=SAMPLE_RATE, return_tensors="pt", padding=True)
         inputs = {k: v.to(model.device) for k, v in inputs.items()}
+        fbank_sec += time.time() - t_fb
+
+        t_inf = time.time()
         with torch.no_grad():
             logits = model(**inputs).logits
         probs_batch = torch.sigmoid(logits).cpu().numpy()  # (B, 527)
+        infer_sec += time.time() - t_inf
 
         for row_probs in probs_batch:
             win_music_scores.append(_music_score_from_probs(row_probs, music_indices))
             win_top_labels.append(_top_labels_from_probs(row_probs, id2label))
 
+    _LAST_TIMINGS.clear()
+    _LAST_TIMINGS.update(decode=decode_sec, fbank=fbank_sec, infer=infer_sec)
+
     # Step 4: max-pool windows → per-chunk score
     chunk_music_scores = [0.0] * n
     chunk_top_labels: list[list[str]] = [[] for _ in range(n)]