Update app.py

app.py

@@ -1,241 +1,413 @@
+pip install audio-separator[cpu] rvc-python pydub
+
+"""RVC Voice Conversion – HuggingFace Space
+
+Simple, fast, GPU/CPU auto-detected.
+"""
+from __future__ import annotations
+
+import os
+
 import gradio as gr
-import subprocess
+
+from lib.config import (
+    BUILTIN_MODELS,
+    CSS,
+    DEVICE_LABEL,
+    MAX_INPUT_DURATION,
+    logger,
+)
+from lib.jobs import (
+    get_jobs_table,
+    get_queue_info,
+    poll_job,
+    submit_job,
+)
+from lib.models import list_models, startup_downloads
+from lib.ui import refresh_models, toggle_autotune, upload_model
+
 import os
-from pathlib import Path
-import logging
-import uuid
-import time
-import threading
-import zipfile
-from typing import Optional, Dict, Any, List
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-initial_models = ["modelo_default.pth"]
-initial_value = initial_models[0] if initial_models else None
-jobs = {}
-queue_info = "Nenhum job na fila"
-
-def get_queue_info():
-    global queue_info
-    return queue_info
-
-def jobs_table_fn():
-    global jobs
-    data = []
-    for job_id, info in jobs.items():
-        status = info.get("status", "Desconhecido")
-        time_str = info.get("time", "N/A")
-        files_html = ""
-        files = info.get("files", [])
-        if files:
-            files_html = "<br>".join([f'<a href="{f}" download>📁 {Path(f).name}</a>' for f in files])
-        data.append([job_id, status, time_str, files_html])
-    return data
-
-def extract_audio_from_video(video_path: str) -> str:
-    audio_path = video_path.rsplit('.', 1)[0] + '.wav'
-    cmd = ["ffmpeg", "-y", "-i", video_path, "-vn", "-acodec", "pcm_s16le", "-ar", "44100", "-ac", "1", audio_path]
-    subprocess.run(cmd, check=True, capture_output=True)
-    return audio_path
-
-def upload_model(zip_file, model_name):
-    if not zip_file:
-        return "Nenhum arquivo selecionado", initial_models, [[m] for m in initial_models]
-    
-    try:
-        with zipfile.ZipFile(zip_file.name, 'r') as zf:
-            zf.extractall("models/")
-        
-        global initial_models
-        initial_models = [f for f in os.listdir("models/") if f.endswith('.pth')]
-        model_display = model_name or Path(zip_file.name).stem
-        return f"✅ Modelo '{model_display}' carregado!", initial_models, [[m] for m in initial_models]
-    except Exception as e:
-        return f"❌ Erro: {e}", initial_models, [[m] for m in initial_models]
-
-def refresh_models():
-    global initial_models
-    try:
-        initial_models = [f for f in os.listdir("models/") if f.endswith('.pth')]
-    except:
-        initial_models = []
-    return [[m] for m in initial_models], initial_models[0] if initial_models else None
-
-def process_audio(input_audio: str, model_pth: Path, work_dir: Path):
-    stem = Path(input_audio).stem
-    
-    try:
-        subprocess.run(["demucs", "--two-stems=vocals", input_audio, "-o", str(work_dir)], check=True)
-    except subprocess.CalledProcessError as e:
-        raise RuntimeError(f"Demucs falhou: {e}")
-
-    candidates = [work_dir / "separated", work_dir / "demucs", work_dir / "demucs_out"]
-    vocal_path = None
-    inst_path = None
-    
-    for cand in candidates:
-        if not cand.exists():
-            continue
-        for p in cand.rglob(f"*{stem}*"):
-            name = p.name.lower()
-            if any(x in name for x in ["vocals", "vocal", "acapella"]):
-                vocal_path = p
-            if any(x in name for x in ["no_vocals", "instrumental", "accompaniment"]):
-                inst_path = p
-
-    if not vocal_path:
-        for p in work_dir.rglob("*"):
-            if p.is_file() and "vocals" in p.name.lower():
-                vocal_path = p
-                break
-
-    if not vocal_path:
-        raise RuntimeError("Não foi possível localizar o arquivo vocal")
-
-    tmp_vocal = work_dir / f"{stem}_vocal_extracted.wav"
-    cmd = ["ffmpeg", "-y", "-i", str(vocal_path), "-ar", "44100", "-ac", "1", str(tmp_vocal)]
-    subprocess.run(cmd, check=True)
-    
-    rvc_out = work_dir / f"{stem}_rvc_converted.wav"
-    
-    try:
-        from rvc import RVCInference
-        infer = RVCInference(device="cuda:0")
-        infer.set_model(str(model_pth))
-        infer.infer(str(tmp_vocal), str(rvc_out))
-    except Exception as e:
-        raise RuntimeError(f"Falha RVC: {e}")
-
-    return {
-        "vocal_extracted": str(tmp_vocal),
-        "instrumental": str(inst_path) if inst_path else "",
-        "rvc_output": str(rvc_out),
-    }
-
-def submit_job(mic, file_input, model_name, pitch, f0_method, index_rate, protect, vol_env, clean, clean_strength, split_audio, autotune, autotune_strength, filter_radius, fmt, reverb, reverb_room, reverb_damp, reverb_wet):
-    global jobs, queue_info
-    
-    job_id = str(uuid.uuid4())[:8]
-    start_time = time.strftime("%H:%M:%S")
-    
-    jobs[job_id] = {"status": "🔄 Processando...", "time": start_time, "files": []}
-    queue_info = f"{len(jobs)} jobs na fila"
-    
-    def worker():
-        try:
-            work_dir = Path("jobs") / job_id
-            work_dir.mkdir(parents=True, exist_ok=True)
-            
-            audio_input = None
-            if mic and os.path.isfile(mic):
-                audio_input = mic
-            elif file_input and os.path.isfile(file_input):
-                audio_input = file_input
-            
-            if not audio_input:
-                jobs[job_id]["status"] = "❌ Nenhum áudio válido"
-                return
-            
-            model_pth = Path("models") / model_name
-            if not model_pth.exists():
-                jobs[job_id]["status"] = f"❌ Modelo {model_name} não encontrado"
-                return
-            
-            jobs[job_id]["status"] = "🎵 Separando vocais..."
-            result = process_audio(audio_input, model_pth, work_dir)
-            
-            jobs[job_id]["status"] = "✅ Finalizado"
-            jobs[job_id]["files"] = [f for f in [result["rvc_output"], result["vocal_extracted"]] if f]
-            
-        except Exception as e:
-            jobs[job_id]["status"] = f"❌ Erro: {str(e)[:80]}"
-            logger.error(f"Job {job_id} falhou: {e}")
-    
-    threading.Thread(target=worker, daemon=True).start()
-    return f"✅ Job {job_id} submetido! Veja em 'Jobs'.", job_id
-
-def _submit_and_extract_id(mic, file_input, video, model_name, pitch, f0_method, index_rate, protect, vol_env, clean, clean_strength, split_audio, autotune, autotune_strength, filter_radius, fmt, reverb, reverb_room, reverb_damp, reverb_wet):
-    audio_input = None
-    if mic and os.path.isfile(mic):
-        audio_input = mic
-    elif file_input and os.path.isfile(file_input):
-        audio_input = file_input
-    elif video and hasattr(video, "name") and os.path.isfile(video.name):
-        try:
-            audio_input = extract_audio_from_video(video.name)
-        except Exception as err:
-            return f"⚠️ Erro vídeo: {err}", ""
-    else:
-        return "⚠️ Envie áudio ou vídeo válido.", ""
+from audio_separator.separator import Separator
+from rvc_python.infer import RVCInference
+from pydub import AudioSegment
+
+def processar_audio_rvc(caminho_entrada, caminho_modelo_pth):
+    # 1. Configuração de nomes de arquivos
+    entrada = caminho_entrada # O arquivo original
+    instrumental = "instrumental.wav"
+    entrada_vocais = "vocais_extraidos.wav"
+    saida_rvc_vocal = "saida_rvc_vocal.wav"
+    saida_rvc_final = "saida_rvc_completa.wav"
+
+    print("--- Iniciando Separação (UVR5) ---")
+    # 2. Separar em Vocal e Instrumental (entrada_vocais e instrumental)
+    separator = Separator()
+    # Usando o modelo MDX-Net para vocais limpos
+    separator.load_model('UVRAnywhere') 
+    output_files = separator.separate(entrada)
     
-    result = submit_job(
-        mic, file_input, model_name, pitch, f0_method, index_rate, protect, 
-        vol_env, clean, clean_strength, split_audio, autotune, autotune_strength, 
-        filter_radius, fmt, reverb, reverb_room, reverb_damp, reverb_wet
-    )
-    return result
+    # Renomeando para facilitar (ajuste conforme o nome gerado pelo modelo)
+    os.rename(output_files[0], instrumental)
+    os.rename(output_files[1], entrada_vocais)
+
+    print("--- Iniciando Conversão RVC (Saída RVC Vocal) ---")
+    # 3. Converter a voz (entrada_vocais -> Saída RVC vocal)
+    rvc = RVCInference(device="cpu") # Mude para "cuda:0" se tiver GPU
+    rvc.load_model(caminho_modelo_pth)
+    rvc.infer_file(entrada_vocais, saida_rvc_vocal)
 
-with gr.Blocks(title="🎤 Ultimate RVC WebUI") as demo:
-    gr.Markdown("# 🎤 Ultimate RVC - Voice Conversion")
+    print("--- Mixagem Final (Saída RVC) ---")
+    # 4. Juntar Vocal convertido com Instrumental original
+    vocal_track = AudioSegment.from_file(saida_rvc_vocal)
+    inst_track = AudioSegment.from_file(instrumental)
     
+    # Sobrepor as duas faixas
+    combinado = inst_track.overlay(vocal_track)
+    combinado.export(saida_rvc_final, format="wav")
+
+    print(f"Processo concluído! Arquivos gerados:")
+    print(f"- Entrada: {entrada}")
+    print(f"- Vocal Original: {entrada_vocais}")
+    print(f"- Instrumental: {instrumental}")
+    print(f"- Vocal RVC: {saida_rvc_vocal}")
+    print(f"- Música Final: {saida_rvc_final}")
+
+# Uso: Informe o áudio e o caminho do seu modelo .pth treinado
+processar_audio_rvc("minha_musica.mp3", "meu_modelo_rvc.pth")
+
+# ── Startup ───────────────────────────────────────────────────────────────────
+startup_status = ""
+default_model = ""
+try:
+    default_model = startup_downloads()
+    startup_status = f"✅ Ready &nbsp;·&nbsp; {DEVICE_LABEL}"
+except Exception as e:
+    startup_status = f"⚠️ Some assets unavailable: {e} &nbsp;·&nbsp; {DEVICE_LABEL}"
+    logger.warning("Startup download issue: %s", e)
+
+initial_models = list_models()
+initial_value = default_model if default_model in initial_models else (
+    initial_models[0] if initial_models else None
+)
+
+# ── Gradio UI ─────────────────────────────────────────────────────────────────
+with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600)) as demo:
+
+    gr.HTML(f"""
+    <div id="header">
+        <h1>🎙️ RVC Voice Conversion</h1>
+        <p>Retrieval-Based Voice Conversion · record or upload · custom models · GPU/CPU auto</p>
+    </div>
+    <p id="status">{startup_status}</p>
+    """)
+
     with gr.Tabs():
+
+        # ── TAB 1: Convert ────────────────────────────────────────────────────
         with gr.Tab("🎤 Convert"):
             with gr.Row():
+
                 with gr.Column(scale=1):
+                    gr.Markdown("### 🔊 Input Audio")
                     with gr.Tabs():
-                        with gr.Tab("🎙️ Microfone"):
-                            inp_mic = gr.Audio(sources=["microphone"], type="filepath")
-                        with gr.Tab("📁 Áudio"):
-                            inp_file = gr.Audio(sources=["upload"], type="filepath")
-                        with gr.Tab("🎬 Vídeo"):
-                            inp_video = gr.File(file_types=[".mp4", ".mov", ".mkv"])
-                    model_dd = gr.Dropdown(choices=initial_models, value=initial_value, label="Modelo")
-                    pitch_sl = gr.Slider(-24, 24, value=0, step=1, label="Pitch")
-                    convert_btn = gr.Button("🚀 Converter", variant="primary")
-                    out_status = gr.Markdown()
-                    job_id_box = gr.Textbox(label="Job ID", interactive=False)
-                
+                        with gr.Tab("🎙️ Microphone"):
+                            inp_mic = gr.Audio(
+                                sources=["microphone"],
+                                type="filepath",
+                                label="Record",
+                            )
+                        with gr.Tab("📁 Upload File"):
+                            inp_file = gr.Audio(
+                                sources=["upload"],
+                                type="filepath",
+                                label="Upload audio (wav / mp3 / mp4 / flac / ogg …)",
+                            )
+
+                    gr.Markdown("### 🤖 Model")
+                    model_dd = gr.Dropdown(
+                        choices=initial_models,
+                        value=initial_value,
+                        label="Active Voice Model",
+                        interactive=True,
+                    )
+
+                    gr.Markdown("### 🎚️ Basic Settings")
+                    pitch_sl = gr.Slider(
+                        minimum=-24, maximum=24, value=0, step=1,
+                        label="Pitch Shift (semitones)",
+                        info="0 = unchanged · positive = higher · negative = lower",
+                    )
+                    f0_radio = gr.Radio(
+                        choices=["rmvpe", "fcpe", "crepe", "crepe-tiny"],
+                        value="rmvpe",
+                        label="Pitch Extraction Method",
+                        info="rmvpe = fastest & accurate · crepe = highest quality (slower)",
+                    )
+
                 with gr.Column(scale=1):
-                    with gr.Accordion("Avançado", open=False):
-                        index_rate_sl = gr.Slider(0.0, 1.0, value=0.75, step=0.05, label="Index Rate")
-                        protect_sl = gr.Slider(0.0, 0.5, value=0.5, step=0.01, label="Protect")
-                        filter_radius_sl = gr.Slider(0, 7, value=3, step=1, label="Filter Radius")
-                        vol_env_sl = gr.Slider(0.0, 1.0, value=0.25, step=0.05, label="Vol Envelope")
-                        fmt_radio = gr.Radio(["WAV", "MP3"], value="WAV", label="Formato")
-        
-        with gr.Tab("📋 Jobs"):
-            refresh_jobs_btn = gr.Button("🔄 Refresh")
-            queue_status = gr.Markdown(value=get_queue_info())
-            jobs_table = gr.Dataframe(headers=["ID", "Status", "Tempo", "Download"], interactive=False)
-            
-            def refresh():
-                return get_queue_info(), jobs_table_fn()
-            refresh_jobs_btn.click(refresh, outputs=[queue_status, jobs_table])
-        
+                    gr.Markdown("### ⚙️ Advanced Settings")
+                    with gr.Accordion("Expand advanced options", open=False):
+                        index_rate_sl = gr.Slider(
+                            0.0, 1.0, value=0.75, step=0.05,
+                            label="Index Rate",
+                            info="How strongly the FAISS index influences timbre (0 = off)",
+                        )
+                        protect_sl = gr.Slider(
+                            0.0, 0.5, value=0.5, step=0.01,
+                            label="Protect Consonants",
+                            info="Protects unvoiced consonants — 0.5 = max protection",
+                        )
+                        filter_radius_sl = gr.Slider(
+                            0, 7, value=3, step=1,
+                            label="Respiration Filter Radius",
+                            info="Median filter on pitch — higher = smoother, reduces breath noise",
+                        )
+                        vol_env_sl = gr.Slider(
+                            0.0, 1.0, value=0.25, step=0.05,
+                            label="Volume Envelope Mix",
+                            info="0.25 = natural blend · 1 = preserve input loudness · 0 = model output",
+                        )
+                        with gr.Row():
+                            clean_cb = gr.Checkbox(value=False, label="Noise Reduction")
+                            clean_sl = gr.Slider(
+                                0.0, 1.0, value=0.5, step=0.05,
+                                label="Reduction Strength",
+                            )
+                        with gr.Row():
+                            split_cb = gr.Checkbox(value=False, label="Split Long Audio")
+                            autotune_cb = gr.Checkbox(value=False, label="Autotune")
+                            autotune_sl = gr.Slider(
+                                0.0, 1.0, value=1.0, step=0.05,
+                                label="Autotune Strength",
+                                visible=False,
+                            )
+                            autotune_cb.change(
+                                fn=toggle_autotune,
+                                inputs=autotune_cb,
+                                outputs=autotune_sl,
+                            )
+
+                    gr.Markdown("**🎛️ Reverb**")
+                    reverb_cb = gr.Checkbox(value=False, label="Enable Reverb")
+                    with gr.Group(visible=False) as reverb_group:
+                        reverb_room_sl = gr.Slider(
+                            0.0, 1.0, value=0.15, step=0.05,
+                            label="Room Size",
+                            info="Larger = bigger sounding space",
+                        )
+                        reverb_damp_sl = gr.Slider(
+                            0.0, 1.0, value=0.7, step=0.05,
+                            label="Damping",
+                            info="Higher = more absorption, less echo tail",
+                        )
+                        reverb_wet_sl = gr.Slider(
+                            0.0, 1.0, value=0.15, step=0.05,
+                            label="Wet Level",
+                            info="How much reverb is mixed in (0.15 = subtle)",
+                        )
+                    reverb_cb.change(
+                        fn=lambda v: gr.update(visible=v),
+                        inputs=reverb_cb,
+                        outputs=reverb_group,
+                    )
+
+                    fmt_radio = gr.Radio(
+                        choices=["WAV", "MP3", "FLAC", "OPUS"],
+                        value="WAV",
+                        label="Output Format",
+                        info="OPUS = small file (~64 kbps, Telegram/Discord quality)",
+                    )
+                    convert_btn = gr.Button(
+                        "🚀 Convert Voice",
+                        variant="primary",
+                    )
+
+                    gr.Markdown("### 🎧 Output")
+                    out_status = gr.Markdown(value="")
+                    out_audio = gr.Audio(label="Result (if still on page)", type="filepath", interactive=False)
+
+                    gr.Markdown("#### 🔍 Check Job Status")
+                    with gr.Row():
+                        job_id_box = gr.Textbox(
+                            label="Job ID",
+                            placeholder="e.g. a3f2b1c9",
+                            scale=3,
+                        )
+                        poll_btn = gr.Button("🔄 Check", scale=1)
+                    poll_status = gr.Markdown(value="")
+                    poll_audio = gr.Audio(label="Result", type="filepath", interactive=False)
+
+        # ── TAB 2: Models ─────────────────────────────────────────────────────
         with gr.Tab("📦 Models"):
-            gr.Markdown("Upload .zip com model.pth")
+            gr.Markdown("""
+            ### Upload a Custom RVC Model
+            Provide a **`.zip`** containing:
+            - **`model.pth`** — weights (required)
+            - **`model.index`** — FAISS index (optional, improves voice matching)
+
+            **Built-in models** (pre-downloaded on startup):
+            Vestia Zeta v1 · Vestia Zeta v2 · Ayunda Risu · Gawr Gura
+            """)
             with gr.Row():
-                up_zip = gr.File(label="ZIP", file_types=[".zip"])
-                up_name = gr.Textbox(label="Nome")
-                up_btn = gr.Button("���� Upload")
-                up_status = gr.Textbox()
-                refresh_btn = gr.Button("🔄 Refresh")
-            
-            models_table = gr.Dataframe(label="Modelos")
-            up_btn.click(upload_model, inputs=[up_zip, up_name], outputs=[up_status, model_dd, models_table])
-            refresh_btn.click(refresh_models, outputs=[models_table, model_dd])
-    
+                with gr.Column(scale=1):
+                    up_zip = gr.File(label="Model ZIP", file_types=[".zip"])
+                    up_name = gr.Textbox(
+                        label="Model Name",
+                        placeholder="Leave blank to use zip filename",
+                    )
+                    up_btn = gr.Button("📤 Load Model", variant="primary")
+                    up_status = gr.Textbox(label="Status", interactive=False, lines=2)
+                with gr.Column(scale=1):
+                    gr.Markdown("### Loaded Models")
+                    models_table = gr.Dataframe(
+                        col_count=(1, "fixed"),
+                        value=[[m] for m in initial_models],
+                        interactive=False,
+                        label="",
+                    )
+                    refresh_btn = gr.Button("🔄 Refresh")
+
+            up_btn.click(
+                fn=upload_model,
+                inputs=[up_zip, up_name],
+                outputs=[up_status, model_dd, models_table],
+            )
+            refresh_btn.click(
+                fn=refresh_models,
+                outputs=[models_table, model_dd],
+            )
+
+        # ── TAB 3: Jobs ───────────────────────────────────────────────────────
+        with gr.Tab("📋 Jobs"):
+            gr.Markdown("All submitted jobs, newest first. Click **Refresh** to update.")
+            queue_status = gr.Markdown(value=get_queue_info, every=10)
+            jobs_table = gr.Dataframe(
+                headers=["Job ID", "Model", "Status", "Time", "Download"],
+                col_count=(5, "fixed"),
+                value=get_jobs_table,
+                interactive=False,
+                wrap=True,
+                datatype=["str", "str", "str", "str", "markdown"],
+                every=10,
+            )
+            refresh_jobs_btn = gr.Button("🔄 Refresh")
+
+            def _refresh_jobs():
+                return get_queue_info(), get_jobs_table()
+
+            refresh_jobs_btn.click(fn=_refresh_jobs, outputs=[queue_status, jobs_table])
+
+        # ── TAB 4: Help ───────────────────────────────────────────────────────
+        with gr.Tab("ℹ️ Help"):
+            gr.Markdown(f"""
+            ## How it works
+            RVC (Retrieval-Based Voice Conversion) transforms a voice recording to sound
+            like a target speaker using only that speaker's model file.
+
+            ---
+
+            ## Quick Guide
+            1. Open the **Convert** tab
+            2. **Record** via microphone or **upload** an audio file (wav, mp3, flac, ogg …)
+            3. Choose a **model** from the dropdown — 4 models are pre-loaded on startup
+            4. Set **Pitch Shift** if needed (e.g. male → female: try +12 semitones)
+            5. Click **🚀 Convert Voice** and wait for the result
+
+            ---
+
+            ## Built-in Models
+            | Model | Description |
+            |---|---|
+            | **Vestia Zeta v1** | Hololive ID VTuber, v1 model |
+            | **Vestia Zeta v2** | Hololive ID VTuber, v2 model (recommended) |
+            | **Ayunda Risu** | Hololive ID VTuber |
+            | **Gawr Gura** | Hololive EN VTuber |
+
+            ---
+
+            ## Pitch Extraction Methods
+            | Method | Speed | Quality | Best for |
+            |---|---|---|---|
+            | **rmvpe** | ⚡⚡⚡ | ★★★★ | General use (default) |
+            | **fcpe** | ⚡⚡ | ★★★★ | Singing |
+            | **crepe** | ⚡ | ★★★★★ | Highest quality, slow |
+            | **crepe-tiny** | ⚡⚡ | ★★★ | Low resource |
+
+            ---
+
+            ## Advanced Settings
+            | Setting | Description |
+            |---|---|
+            | **Index Rate** | Influence of FAISS index on output timbre (0.75 recommended) |
+            | **Protect Consonants** | Prevents artefacts on consonants (0.5 = max) |
+            | **Respiration Filter Radius** | Smooths pitch curve — higher reduces breath noise (0–7, default 3) |
+            | **Volume Envelope Mix** | 0.25 = natural blend · 1 = preserve input loudness |
+            | **Noise Reduction** | Removes background noise before conversion |
+            | **Split Long Audio** | Chunks audio for recordings > 60 s |
+            | **Autotune** | Snaps pitch to nearest musical note |
+
+            ---
+
+            ## Output Formats
+            | Format | Size | Quality |
+            |---|---|---|
+            | **WAV** | Large | Lossless |
+            | **FLAC** | Medium | Lossless compressed | | **mp4** | Big    | Lossless| 
+            | **MP3** | Small | Lossy |
+            | **OPUS** | Tiny (~64 kbps) | Telegram/Discord quality |
+
+            ---
+
+            **Device:** `{DEVICE_LABEL}`
+            **Max input duration:** {MAX_INPUT_DURATION // 60} minutes
+
+            ---
+
+            ## Credits
+            Engine: [Ultimate RVC](https://github.com/JackismyShephard/ultimate-rvc)
+            """)
+
+    # Wire convert button after all tabs
+    def _submit_and_extract_id(*args):
+        import re
+        status, audio = submit_job(*args)
+        match = re.search(r"[a-f0-9]{8}", status or "")
+        job_id = match.group(0) if match else ""
+        return status, audio, job_id, get_queue_info(), get_jobs_table()
+
     convert_btn.click(
-        _submit_and_extract_id,
+        fn=_submit_and_extract_id,
         inputs=[
-            inp_mic, inp_file, inp_video, model_dd, pitch_sl, gr.State("rmvpe"),
-            index_rate_sl, protect_sl, vol_env_sl, gr.State(False), gr.State(0.5),
-            gr.State(False), gr.State(False), gr.State(0.5), gr.State(0.5),
-            gr.State(0.5), gr.State(0.5), gr.State(0.5)
+            inp_mic, inp_file, model_dd,
+            pitch_sl, f0_radio,
+            index_rate_sl, protect_sl, vol_env_sl,
+            clean_cb, clean_sl,
+            split_cb, autotune_cb, autotune_sl,
+            filter_radius_sl,
+            fmt_radio,
+            reverb_cb, reverb_room_sl, reverb_damp_sl, reverb_wet_sl,
         ],
-        outputs=[out_status, job_id_box]
+        outputs=[out_status, out_audio, job_id_box, queue_status, jobs_table],
+    )
+
+    def _poll_and_refresh(job_id):
+        status, file = poll_job(job_id)
+        return status, file, get_queue_info(), get_jobs_table()
+
+    poll_btn.click(
+        fn=_poll_and_refresh,
+        inputs=[job_id_box],
+        outputs=[poll_status, poll_audio, queue_status, jobs_table],
     )
 
-demo.launch()
+
+# ── Launch ────────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=5)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("PORT", 7860)),
+        max_threads=10,
+        ssr_mode=False,
+        css=CSS,
+    )