Upload 2 files

audio_tools.py

@@ -2,7 +2,7 @@
 # -----------------------------------------------------------------------------
 # Veureu — AUDIO utilities (orchestrator w/ remote ASR)
 #  - FFmpeg extraction (WAV)
-#  - Diarization (pyannote)              [local]
+#  - Diarization (pyannote or silence-based fallback) [local]
 #  - Voice embeddings (SpeechBrain ECAPA) [local]
 #  - Speaker identification (KMeans + ChromaDB optional) [local]
 #  - ASR: delegated to HF Space `veureu/asr` (faster-whisper-large-v3-ca-3catparla)
@@ -35,8 +35,13 @@ except Exception:
 
 import soundfile as sf
 
-# Pyannote for diarization (local)
-from pyannote.audio import Pipeline
+# Pyannote for diarization (local) - optional
+try:
+    from pyannote.audio import Pipeline
+    HAS_PYANNOTE = True
+except Exception:
+    Pipeline = None  # type: ignore
+    HAS_PYANNOTE = False
 
 # Speaker embeddings (local)
 from speechbrain.inference.speaker import SpeakerRecognition  # v1.0+
@@ -143,6 +148,93 @@ def transcribe_audio_remote(audio_path: str | Path, cfg: Dict[str, Any]) -> Dict
 
 # -------------------------------- Diarization --------------------------------
 
+def diarize_audio_silence_based(
+    wav_path: str,
+    base_dir: Path,
+    clips_folder: str = "clips",
+    min_segment_duration: float = 20.0,
+    max_segment_duration: float = 50.0,
+    silence_thresh: int = -40,
+    min_silence_len: int = 500,
+) -> Tuple[List[str], List[Dict[str, Any]], Dict[str, Any], List[Dict[str, Any]]]:
+    """Segmentation based on silence detection (alternative to pyannote).
+    Returns (clip_paths, segments, info, connection_logs) in same format as diarize_audio.
+    """
+    from pydub import AudioSegment
+    from pydub.silence import detect_nonsilent
+    
+    audio = AudioSegment.from_wav(wav_path)
+    duration = len(audio) / 1000.0
+    
+    # Detect non-silent chunks
+    nonsilent_ranges = detect_nonsilent(
+        audio,
+        min_silence_len=min_silence_len,
+        silence_thresh=silence_thresh
+    )
+    
+    clips_dir = (base_dir / clips_folder)
+    clips_dir.mkdir(parents=True, exist_ok=True)
+    clip_paths: List[str] = []
+    segments: List[Dict[str, Any]] = []
+    
+    for idx, (start_ms, end_ms) in enumerate(nonsilent_ranges):
+        start = start_ms / 1000.0
+        end = end_ms / 1000.0
+        seg_dur = end - start
+        
+        # Filter by minimum duration
+        if seg_dur < min_segment_duration:
+            continue
+        
+        # Split long segments
+        if seg_dur > max_segment_duration:
+            n = int(math.ceil(seg_dur / max_segment_duration))
+            sub_d = seg_dur / n
+            for j in range(n):
+                s = start + j * sub_d
+                e = min(end, start + (j + 1) * sub_d)
+                if e <= s:
+                    continue
+                clip = audio[int(s * 1000):int(e * 1000)]
+                cp = clips_dir / f"segment_{idx:03d}_{j:02d}.wav"
+                clip.export(cp, format="wav")
+                segments.append({"start": s, "end": e, "speaker": "UNKNOWN"})
+                clip_paths.append(str(cp))
+        else:
+            clip = audio[start_ms:end_ms]
+            cp = clips_dir / f"segment_{idx:03d}.wav"
+            clip.export(cp, format="wav")
+            segments.append({"start": start, "end": end, "speaker": "UNKNOWN"})
+            clip_paths.append(str(cp))
+    
+    # Fallback: if no segments, use full audio
+    if not segments:
+        cp = clips_dir / "segment_000.wav"
+        audio.export(cp, format="wav")
+        return (
+            [str(cp)],
+            [{"start": 0.0, "end": duration, "speaker": "UNKNOWN"}],
+            {"diarization_ok": False, "error": "no_segments_after_silence_filter", "token_source": "silence-based"},
+            [{"service": "silence-detection", "phase": "done", "message": "Segmentation by silence completed"}]
+        )
+    
+    diar_info = {
+        "diarization_ok": True,
+        "error": "",
+        "token_source": "silence-based",
+        "method": "silence-detection",
+        "num_segments": len(segments)
+    }
+    connection_logs = [{
+        "service": "silence-detection",
+        "phase": "done",
+        "message": f"Segmented audio into {len(segments)} clips based on silence"
+    }]
+    
+    return clip_paths, segments, diar_info, connection_logs
+
+
 def diarize_audio(
     wav_path: str,
     base_dir: Path,
@@ -150,10 +242,33 @@ def diarize_audio(
     min_segment_duration: float = 20.0,
     max_segment_duration: float = 50.0,
     hf_token_env: str | None = None,
+    use_silence_fallback: bool = True,
+    force_silence_only: bool = False,
+    silence_thresh: int = -40,
+    min_silence_len: int = 500,
 ) -> Tuple[List[str], List[Dict[str, Any]], Dict[str, Any], List[Dict[str, Any]]]:
-    """Diarization with pyannote and clip export with pydub.
+    """Diarization with pyannote (or silence-based fallback) and clip export with pydub.
+    
+    Args:
+        force_silence_only: If True, skip pyannote and use silence-based segmentation directly.
+        use_silence_fallback: If True and pyannote fails, use silence-based segmentation.
+        silence_thresh: dBFS threshold for silence detection (default -40).
+        min_silence_len: Minimum silence length in milliseconds (default 500).
+        
     Returns (clip_paths, segments, info) where info includes diarization_ok and optional error.
     """
+    # If forced to use silence-only or pyannote not available, use silence-based directly
+    if force_silence_only or not HAS_PYANNOTE:
+        if not HAS_PYANNOTE:
+            log.info("pyannote not available, using silence-based segmentation")
+        else:
+            log.info("Using silence-based segmentation (forced)")
+        return diarize_audio_silence_based(
+            wav_path, base_dir, clips_folder,
+            min_segment_duration, max_segment_duration,
+            silence_thresh, min_silence_len
+        )
+    
     from pydub import AudioSegment
     audio = AudioSegment.from_wav(wav_path)
     duration = len(audio) / 1000.0
@@ -177,9 +292,18 @@ def diarize_audio(
         dt = _t.time() - t0
         connection_logs.append({"service": "pyannote", "phase": "done", "message": f"Response from pyannote received in {dt:.2f} s"})
     except Exception as e:
-        log.warning(f"Diarization unavailable, using single full segment fallback: {e}")
+        log.warning(f"Diarization unavailable: {e}")
         diar_info.update({"diarization_ok": False, "error": str(e)})
         connection_logs.append({"service": "pyannote", "phase": "error", "message": f"pyannote error: {str(e)}"})
+        
+        # Try silence-based segmentation as fallback
+        if use_silence_fallback:
+            log.info("Attempting silence-based segmentation as fallback...")
+            return diarize_audio_silence_based(
+                wav_path, base_dir, clips_folder,
+                min_segment_duration, max_segment_duration,
+                silence_thresh, min_silence_len
+            )
 
     clips_dir = (base_dir / clips_folder)
     clips_dir.mkdir(parents=True, exist_ok=True)
@@ -449,9 +573,18 @@ def process_audio_for_video(
     log.info("Audio extraído")
 
     diar_cfg = audio_cfg.get("diarization", {})
-    min_dur = float(diar_cfg.get("min_segment_duration", 20.0))
-    max_dur = float(diar_cfg.get("max_segment_duration", 50.0))
-    clip_paths, diar_segs, diar_info, connection_logs = diarize_audio(wav_path, out_dir, "clips", min_dur, max_dur)
+    min_dur = float(diar_cfg.get("min_segment_duration", 0.5))
+    max_dur = float(diar_cfg.get("max_segment_duration", 10.0))
+    force_silence = bool(diar_cfg.get("force_silence_only", True))  # Default to silence-based
+    silence_thresh = int(diar_cfg.get("silence_thresh", -40))
+    min_silence_len = int(diar_cfg.get("min_silence_len", 500))
+    
+    clip_paths, diar_segs, diar_info, connection_logs = diarize_audio(
+        wav_path, out_dir, "clips", min_dur, max_dur, 
+        force_silence_only=force_silence,
+        silence_thresh=silence_thresh,
+        min_silence_len=min_silence_len
+    )
     log.info("Clips de audio generados.")
 
     full_transcription = ""

config.yaml

@@ -55,8 +55,11 @@ audio_processing:
 
   diarization:
     enabled: true
+    force_silence_only: true       # Use silence-based segmentation (no pyannote)
     min_segment_duration: 0.5      # en segundos (clips cortos)
     max_segment_duration: 10.0
+    silence_thresh: -40            # dBFS threshold for silence detection
+    min_silence_len: 500           # milliseconds
 
   enable_voice_embeddings: true     # SpeechBrain ECAPA
   speaker_embedding: