Update denoiser.py

denoiser.py

@@ -1,159 +1,81 @@
 """
-Department 1 — Denoiser
-Uses DeepFilterNet3 for professional noise removal.
-Processing order:
-  convert format → read → stereo→mono → resample →
-  gentle pre-boost (max 3×) → AI denoise → EBU R128 normalize → save
+Department 1 - Denoiser
+Uses noisereduce for noise removal (no Rust/C++ required).
 """
 
 import os
 import time
 import subprocess
-import tempfile
 import numpy as np
 import soundfile as sf
 import logging
 
 logger = logging.getLogger(__name__)
 
-TARGET_SR     = 48_000   # DeepFilterNet3 native sample rate
-TARGET_LOUDNESS = -23.0  # EBU R128 target LUFS
-PRE_BOOST_MAX = 3.0      # max linear gain before denoise
+TARGET_SR = 16000
+TARGET_LOUDNESS = -23.0
 
 
 class Denoiser:
     def __init__(self):
-        print("[Denoiser] Initialising DeepFilterNet3…")
-        try:
-            from df.enhance import enhance, init_df, load_audio, save_audio
-            self._enhance   = enhance
-            self._init_df   = init_df
-            self._load_audio = load_audio
-            self._save_audio = save_audio
-
-            # Load model once
-            self.model, self.df_state, _ = init_df()
-            print("[Denoiser] ✅ DeepFilterNet3 loaded")
-        except Exception as e:
-            logger.warning(f"[Denoiser] DeepFilterNet3 not available: {e}")
-            self.model = None
+        print("[Denoiser] Ready (noisereduce)")
 
-    # ── Public ──────────────────────────────────────────────────────
     def process(self, audio_path: str, out_dir: str) -> str:
-        """
-        Full pipeline: convert → load → mono → resample →
-        pre-boost → denoise → normalise → save.
-        Returns path to denoised WAV.
-        """
         t0 = time.time()
 
-        # Step 1: Convert any format → WAV via ffmpeg
+        # Step 1: Convert to WAV
         wav_path = os.path.join(out_dir, "input.wav")
         self._convert_to_wav(audio_path, wav_path)
 
-        # Step 2: Read audio
-        audio, sr = sf.read(wav_path, always_2d=True)   # shape (samples, channels)
+        # Step 2: Read
+        audio, sr = sf.read(wav_path, always_2d=True)
 
-        # Step 3: Stereo → mono
-        if audio.ndim > 1 and audio.shape[1] > 1:
+        # Step 3: Stereo to mono
+        if audio.shape[1] > 1:
             audio = audio.mean(axis=1)
         else:
             audio = audio.squeeze()
 
-        # Step 4: Resample to 48 kHz
-        if sr != TARGET_SR:
-            audio = self._resample(audio, sr, TARGET_SR)
-            sr = TARGET_SR
-
-        # Step 5: Gentle pre-boost (max 3×)
-        peak = np.abs(audio).max()
-        if peak > 0 and peak < 1.0:
-            boost = min(PRE_BOOST_MAX, 1.0 / peak)
-            audio = audio * boost
+        audio = audio.astype(np.float32)
 
-        # Clip to [-1, 1] after boost
-        audio = np.clip(audio, -1.0, 1.0).astype(np.float32)
-
-        # Step 6: AI Denoise
-        if self.model is not None:
-            try:
-                # DeepFilterNet3 expects (1, samples) tensor
-                import torch
-                tensor = torch.from_numpy(audio).unsqueeze(0)
-                enhanced = self._enhance(self.model, self.df_state, tensor)
-                audio = enhanced.squeeze(0).numpy()
-            except Exception as e:
-                logger.warning(f"[Denoiser] DeepFilterNet3 enhance failed, using raw: {e}")
+        # Step 4: Denoise with noisereduce
+        try:
+            import noisereduce as nr
+            audio = nr.reduce_noise(y=audio, sr=sr).astype(np.float32)
+        except Exception as e:
+            logger.warning(f"[Denoiser] noisereduce failed: {e}, using raw audio")
 
-        # Step 7: EBU R128 loudness normalisation
-        audio = self._normalise_loudness(audio, sr)
+        # Step 5: Normalise loudness
+        audio = self._normalise(audio, sr)
 
-        # Step 8: Save
+        # Step 6: Save
         out_path = os.path.join(out_dir, "denoised.wav")
         sf.write(out_path, audio, sr, subtype="PCM_16")
 
-        logger.info(f"[Denoiser] Done in {time.time()-t0:.2f}s → {out_path}")
+        logger.info(f"[Denoiser] Done in {time.time()-t0:.2f}s")
         return out_path
 
-    # ── Private helpers ──────────────────────────────────────────────
     def _convert_to_wav(self, src: str, dst: str):
-        """Convert any audio format to 16-bit PCM WAV using ffmpeg."""
-        cmd = [
-            "ffmpeg", "-y", "-i", src,
-            "-acodec", "pcm_s16le",
-            "-ar", str(TARGET_SR),
-            "-ac", "1",
-            dst
-        ]
+        cmd = ["ffmpeg", "-y", "-i", src, "-acodec", "pcm_s16le",
+               "-ar", str(TARGET_SR), "-ac", "1", dst]
         result = subprocess.run(cmd, capture_output=True, text=True)
         if result.returncode != 0:
-            # ffmpeg failed — try soundfile direct read as fallback
-            logger.warning(f"[Denoiser] ffmpeg conversion failed, trying soundfile direct read")
             try:
-                data, sr_in = sf.read(src, always_2d=True)
-                sf.write(dst, data, sr_in, subtype="PCM_16")
-            except Exception as e2:
-                raise RuntimeError(
-                    f"Could not read audio file '{os.path.basename(src)}'. "
-                    f"ffmpeg error: {result.stderr[:200]}"
-                ) from e2
-
-    def _resample(self, audio: np.ndarray, src_sr: int, tgt_sr: int) -> np.ndarray:
-        try:
-            import resampy
-            return resampy.resample(audio, src_sr, tgt_sr)
-        except ImportError:
-            pass
-        try:
-            import librosa
-            return librosa.resample(audio, orig_sr=src_sr, target_sr=tgt_sr)
-        except ImportError:
-            pass
-        # Simple linear interpolation fallback
-        ratio     = tgt_sr / src_sr
-        n_samples = int(len(audio) * ratio)
-        indices   = np.linspace(0, len(audio) - 1, n_samples)
-        return np.interp(indices, np.arange(len(audio)), audio).astype(np.float32)
-
-    def _normalise_loudness(self, audio: np.ndarray, sr: int) -> np.ndarray:
-        """
-        EBU R128 normalisation.
-        Targets TARGET_LOUDNESS LUFS; falls back to RMS normalisation if
-        pyloudnorm is unavailable.
-        """
+                data, sr = sf.read(src, always_2d=True)
+                sf.write(dst, data, sr, subtype="PCM_16")
+            except Exception as e:
+                raise RuntimeError(f"Cannot read audio file: {e}")
+
+    def _normalise(self, audio: np.ndarray, sr: int) -> np.ndarray:
         try:
             import pyloudnorm as pyln
             meter    = pyln.Meter(sr)
             loudness = meter.integrated_loudness(audio)
             if np.isfinite(loudness) and loudness < 0:
                 audio = pyln.normalize.loudness(audio, loudness, TARGET_LOUDNESS)
-            return np.clip(audio, -1.0, 1.0).astype(np.float32)
         except Exception:
-            pass
-
-        # RMS fallback
-        rms = np.sqrt(np.mean(audio ** 2))
-        if rms > 1e-9:
-            target_rms = 10 ** (TARGET_LOUDNESS / 20.0)
-            audio = audio * (target_rms / rms)
-        return np.clip(audio, -1.0, 1.0).astype(np.float32)
+            rms = np.sqrt(np.mean(audio ** 2))
+            if rms > 1e-9:
+                target = 10 ** (TARGET_LOUDNESS / 20.0)
+                audio  = audio * (target / rms)
+        return np.clip(audio, -1.0, 1.0).astype(np.float32)