Añadir pipeline de audio y interfaz Gradio

app.py

@@ -0,0 +1,34 @@
+import gradio as gr
+from audio_pipeline import (
+    descargar_audio,
+    separar_audio_demucs,
+    limpiar_stems,
+    combinar_stems_sin_vocales,
+    reducir_ruido
+)
+
+def generar_base(url: str):
+    # 1) Descarga el audio
+    descargar_audio(url, output_filename="audio")
+    # 2) Separa stems
+    separar_audio_demucs("audio.wav", output_dir="separated")
+    stems_dir = "separated/audio"
+    # 3) Limpia stems
+    limpiar_stems(stems_dir)
+    # 4) Genera base instrumental
+    combinar_stems_sin_vocales(stems_dir)
+    # 5) Reduce ruido
+    resultado = f"{stems_dir}/base_instrumental_clean.wav"
+    reducir_ruido(f"{stems_dir}/base_instrumental.wav", resultado)
+    return resultado
+
+demo = gr.Interface(
+    fn=generar_base,
+    inputs=gr.Text(label="URL de YouTube"),
+    outputs=gr.Audio(label="Base instrumental limpia"),
+    title="Generador de Base Instrumental",
+    description="Pega la URL de un vídeo de YouTube y espera la creación de la instrumental."
+)
+
+if __name__ == "__main__":
+    demo.launch()

audio_pipeline.py

@@ -0,0 +1,124 @@
+import yt_dlp
+import subprocess
+import sys
+import os
+import librosa
+import numpy as np
+import soundfile as sf
+import noisereduce as nr
+import scipy.signal as signal
+
+# ###########################################
+# Funciones de Filtros y Efectos
+# ###########################################
+
+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')
+    filtered = signal.sosfilt(sos, audio)
+    return filtered
+
+# ###########################################
+# Etapa 1: Descarga y Separación con Demucs
+# ###########################################
+
+def descargar_audio(url, output_filename='audio'):
+    """Descarga el audio de YouTube y lo convierte a WAV."""
+    opciones = {
+        'format': 'bestaudio/best',
+        'outtmpl': f'{output_filename}.%(ext)s',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'wav',
+        }],
+    }
+    with yt_dlp.YoutubeDL(opciones) as ydl:
+        ydl.download([url])
+
+
+def separar_audio_demucs(input_file, output_dir="separated"):
+    """Separa stems usando Demucs."""
+    comando = [
+        sys.executable, '-m', 'demucs',
+        input_file,
+        '--out', output_dir
+    ]
+    try:
+        subprocess.run(comando, check=True)
+        print("Separación con Demucs completada.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error durante la separación con Demucs: {e}")
+        sys.exit(1)
+
+# ###########################################
+# Función para limpiar cada stem (reducción de ruido, etc.)
+# ###########################################
+
+def limpiar_stems(stems_dir):
+    """Aplica reducción de ruido a cada stem en stems_dir."""
+    for archivo in os.listdir(stems_dir):
+        if archivo.endswith('.wav'):
+            file_path = os.path.join(stems_dir, archivo)
+            y, sr = librosa.load(file_path, sr=None)
+            reduced = nr.reduce_noise(y=y, sr=sr)
+            sf.write(file_path.replace('.wav', '_cleaned.wav'), reduced, sr)
+
+# ###########################################
+# Combina stems excluyendo la parte vocal
+# ###########################################
+
+def combinar_stems_sin_vocales(stems_dir):
+    """Mezcla todos los stems excepto los que contienen vocales."""
+    archivos = [f for f in os.listdir(stems_dir) if f.endswith('.wav')]
+    archivos_clean = [f for f in archivos if 'cleaned' in f.lower() and 'vocal' not in f.lower()]
+    if archivos_clean:
+        lista_archivos = archivos_clean
+    else:
+        lista_archivos = [f for f in archivos if 'vocal' not in f.lower()]
+    signals = []
+    for archivo in lista_archivos:
+        file_path = os.path.join(stems_dir, archivo)
+        print(f"Incluyendo: {archivo}")
+        y, sr = librosa.load(file_path, sr=None)
+        signals.append(y)
+    if not signals:
+        print("No se encontraron stems para combinar (excluyendo vocales).")
+        return
+    max_len = max(len(s) for s in signals)
+    mezclado = sum(np.pad(s, (0, max_len - len(s))) for s in signals) / len(signals)
+    sf.write(os.path.join(stems_dir, 'base_instrumental.wav'), mezclado, sr)
+
+# ###########################################
+# Reducción de ruido en archivo de audio
+# ###########################################
+
+def reducir_ruido(input_file, output_file, noise_duration=0.5):
+    """Aplica reducción de ruido basada en los primeros segundos de audio."""
+    y, sr = librosa.load(input_file, sr=None)
+    noise = y[:int(noise_duration * sr)]
+    reduced = nr.reduce_noise(y=y, sr=sr, y_noise=noise)
+    sf.write(output_file, reduced, sr)
+
+# ###########################################
+# Función principal
+# ###########################################
+
+def main():
+    url = input("Introduce la URL de YouTube: ")
+    output_name = input("Nombre base para archivos (sin extensión): ")
+    descargar_audio(url, output_filename=output_name)
+    audio_file = f"{output_name}.wav"
+    separar_audio_demucs(audio_file, output_dir="separated")
+    stems_dir = os.path.join("separated", output_name)
+    limpiar_stems(stems_dir)
+
+    output_base = os.path.join(stems_dir, 'base_instrumental.wav')
+    print("Combinando stems 'cleaned' para generar la base instrumental...")
+    combinar_stems_sin_vocales(stems_dir)
+
+    output_clean = os.path.join(stems_dir, 'base_instrumental_clean.wav')
+    print("Aplicando reducción de ruido...")
+    reducir_ruido(output_base, output_clean, noise_duration=0.5)
+
+    # Se omite la etapa de mastering para mantener la calidad original de la mezcla
+    print("Proceso completado. Revisa el archivo 'base_instrumental_clean.wav' para escuchar el resultado final.")