Usar Spleeter para separación y corregir flujo

app.py

@@ -3,36 +3,36 @@
 import os
 import gradio as gr
 from audio_pipeline import (
-    separar_audio_demucs,
+    separar_audio_spleeter,
     limpiar_stems,
     combinar_stems_sin_vocales,
     reducir_ruido
 )
 
 def procesar_wav(input_wav_path):
-    # 1) Separar con Demucs y obtener carpeta de stems
-    stems_dir = separar_audio_demucs(input_wav_path)
+    # 1) Separar con Spleeter
+    stems_dir = separar_audio_spleeter(input_wav_path)
 
     # 2) Limpiar stems (_cleaned.wav)
     limpiar_stems(stems_dir)
 
-    # 3) Combinar stems sin vocales en base_instrumental.wav
+    # 3) Combinar stems sin vocales => base_instrumental.wav
     combinar_stems_sin_vocales(stems_dir)
 
-    # 4) Reducir ruido sobre la base resultante
-    base_instru = os.path.join(stems_dir, "base_instrumental.wav")
-    clean_instru = os.path.join(stems_dir, "base_instrumental_clean.wav")
-    reducir_ruido(base_instru, clean_instru)
+    # 4) Reducir ruido en la base
+    base = os.path.join(stems_dir, "base_instrumental.wav")
+    clean = os.path.join(stems_dir, "base_instrumental_clean.wav")
+    reducir_ruido(base, clean)
 
-    # 5) Devolver la ruta del WAV limpio
-    return clean_instru
+    # 5) Devolver ruta al WAV final
+    return clean
 
 demo = gr.Interface(
     fn=procesar_wav,
     inputs=gr.Audio(label="Sube un archivo .wav", type="filepath"),
     outputs=gr.Audio(label="Base instrumental limpia", type="filepath"),
-    title="Procesador de WAV a Base Instrumental",
-    description="Sube tu WAV y obtén su base limpia sin vocales."
+    title="Procesador de WAV a Base Instrumental con Spleeter",
+    description="Sube tu WAV y obtén la base sin vocales usando Spleeter."
 )
 
 if __name__ == "__main__":

audio_pipeline.py

@@ -1,47 +1,33 @@
 # audio_pipeline.py
 
 import os
-import subprocess
-import sys
-import torch
 import librosa
 import numpy as np
 import soundfile as sf
 import noisereduce as nr
+from spleeter.separator import Separator
 
 # Directorio base donde guardaremos todos los stems
 BASE_STEMS_DIR = "data/stems"
 
-def highpass_filter(audio, sr, cutoff=80, order=4):
-    """Aplica un filtro Butterworth de paso alto al audio."""
-    sos = signal.butter(order, cutoff, btype='highpass', fs=sr, output='sos')
-    return signal.sosfilt(sos, audio)
-
-def separar_audio_demucs(input_file, model="htdemucs"):
+def separar_audio_spleeter(input_file, model="spleeter:4stems"):
     """
-    Separa stems usando Demucs, los deja en:
-      data/stems/<modelo>/<base_name>/
-    y devuelve la ruta al folder con los stems.
+    Separa stems usando Spleeter (4 stems: vocals, drums, bass, other),
+    los deja en data/stems/4stems/<nombre_base>/ y devuelve esa ruta.
     """
-    # 1) Crear directorio raíz para ese modelo
-    out_root = os.path.join(BASE_STEMS_DIR, model)
+    base = os.path.splitext(os.path.basename(input_file))[0]
+    model_name = model.split(":")[1]  # "4stems"
+    out_root = os.path.join(BASE_STEMS_DIR, model_name)
     os.makedirs(out_root, exist_ok=True)
 
-    # 2) Ejecutar Demucs (en GPU si está disponible)
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    cmd = [
-        sys.executable, "-m", "demucs",
-        input_file,
-        "--out", out_root,
-        "--device", device
-    ]
-    subprocess.run(cmd, check=True)
+    # Ejecuta la separación
+    sep = Separator(model)
+    sep.separate_to_file(input_file, out_root)
 
-    # 3) Detectar carpeta generada con los stems
-    base = os.path.splitext(os.path.basename(input_file))[0]
+    # La salida es out_root/<base>/*.wav
     stems_dir = os.path.join(out_root, base)
     if not os.path.isdir(stems_dir):
-        raise FileNotFoundError(f"No existe el folder de stems en {stems_dir}")
+        raise FileNotFoundError(f"No se encontró el folder de stems en {stems_dir}")
     return stems_dir
 
 def limpiar_stems(stems_dir):
@@ -55,18 +41,16 @@ def limpiar_stems(stems_dir):
 
 def combinar_stems_sin_vocales(stems_dir):
     """Mezcla todos los stems (limpios) excepto los de vocales."""
-    # Primero, buscar stems *_cleaned.wav que no contengan 'vocal'
+    # Busca "*_cleaned.wav" que no contengan "vocals"
     wavs = [
         f for f in os.listdir(stems_dir)
-        if f.endswith(".wav") and
-           "cleaned" in f.lower() and
-           "vocal" not in f.lower()
+        if f.endswith("_cleaned.wav") and "vocals" not in f.lower()
     ]
-    # Si no hay cleaned, fallback a stems originales sin 'vocal'
+    # Si no hay cleaned, fallback a originales sin "vocals"
     if not wavs:
         wavs = [
             f for f in os.listdir(stems_dir)
-            if f.endswith(".wav") and "vocal" not in f.lower()
+            if f.endswith(".wav") and "vocals" not in f.lower()
         ]
 
     signals = []