fix: move theme/css from gr.Blocks() to demo.launch() for Gradio 6.x compatibility

README.md

@@ -0,0 +1,238 @@
+---
+title: AnimaStudio 🎬
+emoji: 🎬
+colorFrom: purple
+colorTo: pink
+sdk: gradio
+sdk_version: 6.0.2
+app_file: app.py
+pinned: true
+license: apache-2.0
+short_description: AI talking head & video dubbing — free, 23 languages
+tags:
+  - video-generation
+  - talking-head
+  - lip-sync
+  - avatar
+  - tts
+  - voice-cloning
+  - multilingual
+  - mcp-server
+  - echomimic
+  - chatterbox
+  - dubbing
+  - whisper
+  - nllb
+---
+
+# 🎬 AnimaStudio
+
+Turn any portrait photo into a talking head video using your voice or typed text, or dub any video into 23 languages — free, no sign-up required.
+
+---
+
+## ✨ Features
+
+| Feature | Details |
+|---------|---------|
+| 🎭 **Realistic Lip Sync** | EchoMimic V3 Flash (AAAI 2026) — state-of-the-art talking head animation |
+| 🗣️ **23-Language TTS** | Type text in any of 23 languages and generate natural speech |
+| 🎙️ **Voice Cloning** | Upload a voice reference clip to clone the speaking style |
+| 📤 **Audio Upload** | Upload your own WAV / MP3 / FLAC instead of using TTS |
+| 🎬 **Video Dubbing** | Upload a video (up to 60 s) and dub it into any of the 23 supported languages |
+| 📐 **3 Aspect Ratios** | 9:16 mobile, 1:1 square, 16:9 landscape |
+| 🌐 **4 UI Languages** | Full interface in English, Português (BR), Español, and عربي |
+| 📥 **Download** | One-click download of the generated MP4 |
+| 🤖 **MCP Server** | Use as a tool in Claude, Cursor, and any MCP-compatible agent |
+
+---
+
+## 🗣️ Supported TTS Languages
+
+Arabic · Danish · German · Greek · **English** · **Spanish** · Finnish · French · Hebrew · Hindi · Italian · Japanese · Korean · Malay · Dutch · Norwegian · Polish · **Portuguese** · Russian · Swedish · Swahili · Turkish · Chinese
+
+---
+
+## 📐 Output Formats
+
+| Preset | Dimensions | Best for |
+|--------|-----------|----------|
+| ▮ 9:16 | 576 × 1024 | Mobile, Reels, TikTok |
+| ◻ 1:1 | 512 × 512 | Social media, thumbnails |
+| ▬ 16:9 | 1024 × 576 | Presentations, YouTube |
+
+---
+
+## ⚙️ Advanced Settings
+
+| Setting | Default | Range | Description |
+|---------|---------|-------|-------------|
+| **Inference Steps** | 20 | 5–50 | More steps = higher quality, slower |
+| **Guidance Scale** | 3.5 | 1–10 | Higher = audio followed more strictly |
+| **Emotion Intensity** | 0.5 | 0–1 | Controls expressiveness of TTS voice |
+
+---
+
+## 🤖 MCP Server
+
+AnimaStudio runs as an **MCP (Model Context Protocol) server**, enabling AI agents to generate talking head videos programmatically.
+
+### Using with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "animastudio": {
+      "url": "https://lulavc-animastudio.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+### Tool parameters
+
+- **portrait_image** — portrait photo (file path or base64)
+- **text** — text for the avatar to speak (text mode)
+- **tts_language** — language for speech synthesis (23 options)
+- **voice_ref** — optional voice reference audio for cloning
+- **audio_file** — audio file path (audio mode)
+- **aspect_ratio** — output format (9:16, 1:1, 16:9)
+- **emotion** — emotion intensity 0–1
+- **num_steps** — inference steps (default 20)
+- **guidance_scale** — guidance scale (default 3.5)
+
+---
+
+## 🎬 Video Dubbing (Phase 2)
+
+Upload any video (up to 60 seconds) and dub it into a different language. The pipeline:
+
+1. **Whisper Turbo** transcribes the original speech (auto-detects language)
+2. **NLLB-200** translates the transcript to the target language
+3. **Chatterbox TTS** synthesizes the translated speech (with optional voice cloning)
+4. **ffmpeg** muxes the new audio track onto the original video
+
+### Dubbing Settings
+
+| Setting | Details |
+|---------|---------|
+| **Input Video** | Any video with speech, up to 60 seconds |
+| **Target Language** | Any of the 23 supported languages |
+| **Voice Reference** | Optional audio clip to clone the speaker's voice style |
+
+> Same language as source? The pipeline skips translation and re-synthesizes the audio directly.
+
+---
+
+## 🔧 Technical Details
+
+### Models
+
+| Model | Purpose | License | VRAM |
+|-------|---------|---------|------|
+| [EchoMimic V3 Flash](https://huggingface.co/BadToBest/EchoMimicV3) | Talking head video generation | Apache 2.0 | ~12 GB |
+| [Chatterbox Multilingual](https://huggingface.co/ResembleAI/chatterbox) | 23-language TTS with voice cloning | MIT | ~8 GB |
+| [Whisper Turbo](https://huggingface.co/openai/whisper-large-v3-turbo) | Speech transcription (809M params) | MIT | ~2 GB |
+| [NLLB-200 Distilled 600M](https://huggingface.co/facebook/nllb-200-distilled-600M) | Text translation (23 languages) | CC-BY-NC-4.0 | API (no local GPU) |
+
+### Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Tab 1: Create Video                                            │
+│                                                                 │
+│  Portrait Photo + Text ──→ Chatterbox TTS ──→ Audio WAV         │
+│                                                    │            │
+│  Portrait Photo + Audio ───────────────────────────┤            │
+│                                                    ▼            │
+│                                        EchoMimic V3 Flash       │
+│                                        (lip-sync animation)     │
+│                                                    │            │
+│                                                    ▼            │
+│                                        MP4 Video Output         │
+├─────────────────────────────────────────────────────────────────┤
+│  Tab 2: Dub Video                                               │
+│                                                                 │
+│  Video ──→ ffmpeg (extract audio)                               │
+│                  │                                              │
+│                  ▼                                              │
+│            Whisper Turbo (transcribe + detect language)          │
+│                  │                                              │
+│                  ▼                                              │
+│            NLLB-200 (translate to target language)               │
+│                  │                                              │
+│                  ▼                                              │
+│            Chatterbox TTS (synthesize translated speech)         │
+│                  │                                              │
+│                  ▼                                              │
+│            ffmpeg (mux new audio onto original video)            │
+│                  │                                              │
+│                  ▼                                              │
+│            Dubbed MP4 Output                                    │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### VRAM Management
+
+Models run sequentially on ZeroGPU (A10G, 24 GB):
+
+**Create Video tab:**
+1. Chatterbox TTS → generates audio → offloads to CPU
+2. EchoMimic V3 → generates video → offloads to CPU
+3. `torch.cuda.empty_cache()` between stages
+
+**Dub Video tab:**
+1. Whisper Turbo → transcribes audio (~2 GB) → offloads to CPU
+2. NLLB-200 → translates via HF Inference API (no local GPU)
+3. Chatterbox TTS → synthesizes dubbed speech → offloads to CPU
+4. `torch.cuda.empty_cache()` between stages
+
+Peak usage never exceeds ~16 GB.
+
+---
+
+## 💡 Tips for Best Results
+
+### Create Video
+1. **Use a clear, front-facing portrait** — well-lit, neutral background, face filling most of the frame
+2. **Keep audio under 20 seconds** — shorter = faster generation, tighter lip sync
+3. **Add a voice reference** — upload a 5–15 second clip in the target language for natural voice cloning
+4. **Match language to text** — select the correct TTS language to avoid accent issues
+5. **Emotion 0.4–0.6** — sweet spot for natural-sounding delivery
+6. **9:16 for social** — perfect for Reels, TikTok, and Stories
+7. **20–30 steps** — good quality/speed trade-off for most use cases
+
+### Dub Video
+8. **Keep videos under 60 seconds** — pipeline enforces this limit for VRAM and quality
+9. **Clear speech works best** — minimal background music/noise gives cleaner transcriptions
+10. **Add a voice reference** — clone the original speaker's voice for a more natural dub
+11. **Single-speaker videos** — the pipeline works best with one speaker at a time
+
+---
+
+## 🛠️ Running Locally
+
+```bash
+git clone https://huggingface.co/spaces/lulavc/AnimaStudio
+cd AnimaStudio
+pip install -r requirements.txt
+python app.py
+```
+
+Requires a CUDA GPU with at least 16 GB VRAM. Set `HF_TOKEN` for private model access.
+
+---
+
+## 📄 License
+
+- **Space code:** Apache 2.0
+- **EchoMimic V3:** [Apache 2.0](https://huggingface.co/BadToBest/EchoMimicV3)
+- **Chatterbox TTS:** [MIT](https://huggingface.co/ResembleAI/chatterbox)
+- **Whisper Turbo:** [MIT](https://huggingface.co/openai/whisper-large-v3-turbo)
+- **NLLB-200:** [CC-BY-NC-4.0](https://huggingface.co/facebook/nllb-200-distilled-600M)
+
+---
+
+**Space by [lulavc](https://huggingface.co/lulavc)** · Powered by [EchoMimic V3](https://huggingface.co/BadToBest/EchoMimicV3) + [Chatterbox](https://huggingface.co/ResembleAI/chatterbox) + [Whisper Turbo](https://huggingface.co/openai/whisper-large-v3-turbo) + [NLLB-200](https://huggingface.co/facebook/nllb-200-distilled-600M) · ZeroGPU · A10G

app.py

@@ -0,0 +1,539 @@
+import spaces
+import gradio as gr
+import torch
+import torchaudio
+import os
+import gc
+import sys
+import shutil
+import tempfile
+import subprocess
+import threading
+import logging
+
+import dubbing
+from i18n import T, EXAMPLES, ALL_EXAMPLES_FLAT, TTS_LANGUAGES, MAX_TEXT_LEN, MAX_AUDIO_SEC
+from styles import THEME, CSS
+
+log = logging.getLogger(__name__)
+
+# ── Config ────────────────────────────────────────────────────────────────────
+ECHOMIMIC_MODEL  = os.environ.get("ECHOMIMIC_MODEL",  "BadToBest/EchoMimicV3")
+CHATTERBOX_MODEL = os.environ.get("CHATTERBOX_MODEL", "ResembleAI/chatterbox")
+MAX_DUB_TEXT_LEN = 1500   # ~60s of typical speech at 150 wpm ≈ 900 chars; 1500 is safe headroom
+
+ASPECT_PRESETS = {
+    "▮ 9:16 · 576×1024": (576,  1024),
+    "◻ 1:1  · 512×512":  (512,   512),
+    "▬ 16:9 · 1024×576": (1024,  576),
+}
+
+DEFAULT_STEPS = 20
+DEFAULT_CFG   = 3.5
+DEFAULT_FPS   = 25
+
+# ── Runtime repo installs (avoid PyPI conflicts) ──────────────────────────────
+_ECHOMIMIC_REPO  = "https://github.com/antgroup/echomimic_v3.git"
+_ECHOMIMIC_DIR   = "/tmp/echomimic_v3"
+_CHATTERBOX_REPO = "https://github.com/resemble-ai/chatterbox.git"
+_CHATTERBOX_DIR  = "/tmp/chatterbox"
+_clone_lock      = threading.Lock()
+
+
+def _clone_repo(repo_url: str, dest: str, label: str):
+    """Thread-safe shallow clone. Uses .git presence to detect complete clones."""
+    with _clone_lock:
+        if not os.path.exists(os.path.join(dest, ".git")):
+            if os.path.exists(dest):
+                shutil.rmtree(dest)
+            log.info("Cloning %s…", label)
+            subprocess.run(
+                ["git", "clone", "--depth=1", repo_url, dest],
+                check=True, timeout=180,
+            )
+            log.info("%s cloned", label)
+        if dest not in sys.path:
+            sys.path.insert(0, dest)
+
+
+def _ensure_echomimic_repo():
+    _clone_repo(_ECHOMIMIC_REPO, _ECHOMIMIC_DIR, "EchoMimic V3")
+
+
+def _ensure_chatterbox_repo():
+    _clone_repo(_CHATTERBOX_REPO, _CHATTERBOX_DIR, "Chatterbox TTS")
+
+
+# ── Model singletons ──────────────────────────────────────────────────────────
+_tts_model = None
+_echo_pipe = None
+_echo_mode = None
+
+
+def _load_tts():
+    global _tts_model
+    if _tts_model is None:
+        _ensure_chatterbox_repo()
+        from chatterbox.tts import ChatterboxTTS
+        log.info("Loading Chatterbox TTS…")
+        _tts_model = ChatterboxTTS.from_pretrained(device="cpu")
+        log.info("Chatterbox TTS ready")
+    return _tts_model
+
+
+def _load_echomimic():
+    global _echo_pipe, _echo_mode
+    if _echo_pipe is not None:
+        return _echo_pipe, _echo_mode
+
+    try:
+        _ensure_echomimic_repo()
+        from echomimic_v3.pipelines.pipeline_echomimic_v3 import EchoMimicV3Pipeline
+        log.info("Loading EchoMimic V3 (local)…")
+        _echo_pipe = EchoMimicV3Pipeline.from_pretrained(ECHOMIMIC_MODEL, torch_dtype=torch.float16)
+        _echo_mode = "local"
+        log.info("EchoMimic V3 ready (local)")
+        return _echo_pipe, _echo_mode
+    except Exception as e:
+        log.warning("EchoMimic V3 local import failed: %s", e)
+
+    try:
+        from diffusers import DiffusionPipeline
+        log.info("Loading EchoMimic V3 via diffusers…")
+        _echo_pipe = DiffusionPipeline.from_pretrained(
+            ECHOMIMIC_MODEL, torch_dtype=torch.float16, trust_remote_code=True,
+        )
+        _echo_mode = "local"
+        log.info("EchoMimic V3 ready (diffusers)")
+        return _echo_pipe, _echo_mode
+    except Exception as e:
+        log.warning("EchoMimic V3 diffusers load failed: %s", e)
+
+    raise RuntimeError("EchoMimic V3 could not be loaded. Check requirements and model availability.")
+
+
+# ── Video utilities ───────────────────────────────────────────────────────────
+def _coerce_frames(frames):
+    """Normalise pipeline output to a list of (H, W, 3) uint8 numpy arrays."""
+    import numpy as np
+    result = []
+    for frame in frames:
+        if hasattr(frame, "save"):
+            arr = np.array(frame.convert("RGB"))
+        elif hasattr(frame, "cpu"):
+            arr = frame.cpu().float().numpy()
+            if arr.ndim == 3 and arr.shape[0] in (1, 3, 4):
+                arr = arr.transpose(1, 2, 0)
+            if arr.max() <= 1.0:
+                arr = (arr * 255).clip(0, 255)
+            arr = arr.astype(np.uint8)
+        else:
+            arr = np.array(frame)
+        if arr.ndim == 2:
+            import cv2
+            arr = cv2.cvtColor(arr, cv2.COLOR_GRAY2RGB)
+        elif arr.shape[2] == 4:
+            arr = arr[:, :, :3]
+        result.append(arr)
+    return result
+
+
+def _mux_video(frames, audio_path: str, fps: int = DEFAULT_FPS) -> str:
+    """Combine frames (PIL/tensor/ndarray) + audio into an MP4 file."""
+    import cv2
+
+    coerced = _coerce_frames(frames)
+    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
+        out_path = f.name
+    with tempfile.TemporaryDirectory() as tmpdir:
+        for i, arr in enumerate(coerced):
+            cv2.imwrite(os.path.join(tmpdir, f"{i:06d}.png"), cv2.cvtColor(arr, cv2.COLOR_RGB2BGR))
+        cmd = [
+            "ffmpeg", "-y", "-loglevel", "error",
+            "-framerate", str(fps),
+            "-i", os.path.join(tmpdir, "%06d.png"),
+            "-i", audio_path,
+            "-c:v", "libx264", "-preset", "fast", "-crf", "22",
+            "-c:a", "aac", "-b:a", "128k",
+            "-shortest", "-pix_fmt", "yuv420p",
+            out_path,
+        ]
+        subprocess.run(cmd, check=True, timeout=120)
+    return out_path
+
+
+# ── TTS ───────────────────────────────────────────────────────────────────────
+def _run_tts(text: str, voice_ref: str | None, emotion: float, language: str = "English") -> str:
+    """Generate speech WAV. Returns temp file path."""
+    model = _load_tts()
+    log.info("TTS: language=%s text_len=%d emotion=%.2f", language, len(text), emotion)
+    model.to("cuda")
+    try:
+        wav = model.generate(
+            text=text.strip(),
+            audio_prompt_path=voice_ref if voice_ref else None,
+            exaggeration=float(emotion),
+        )
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+            out_path = f.name
+        torchaudio.save(out_path, wav, model.sr)
+        return out_path
+    finally:
+        model.to("cpu")
+        torch.cuda.empty_cache()
+
+
+# ── EchoMimic ─────────────────────────────────────────────────────────────────
+def _run_echomimic(portrait_img, audio_path: str, width: int, height: int,
+                   num_steps: int, guidance_scale: float) -> str:
+    """Generate talking-head video. Returns MP4 file path."""
+    pipe, _ = _load_echomimic()
+    pipe.to("cuda")
+    try:
+        output = pipe(
+            ref_image=portrait_img,
+            audio_path=audio_path,
+            width=width,
+            height=height,
+            num_inference_steps=num_steps,
+            guidance_scale=guidance_scale,
+            fps=DEFAULT_FPS,
+        )
+        if hasattr(output, "frames"):
+            return _mux_video(output.frames[0], audio_path)
+        if hasattr(output, "videos"):
+            vid = output.videos[0]
+            if hasattr(vid, "unbind"):
+                return _mux_video(list(vid.unbind(0)), audio_path)
+            return _mux_video(vid, audio_path)
+        if isinstance(output, str):
+            return output
+        raise ValueError(f"Unexpected pipeline output type: {type(output)}")
+    finally:
+        pipe.to("cpu")
+        torch.cuda.empty_cache()
+        gc.collect()
+
+
+# ── Phase 1: Generate video endpoint ─────────────────────────────────────────
+@spaces.GPU(duration=180)
+def generate(portrait_img, input_mode: str, text: str, tts_language: str,
+             voice_ref, audio_file, aspect_ratio: str, emotion: float,
+             num_steps: int, guidance_scale: float, lang: str,
+             progress=gr.Progress(track_tqdm=True)):
+
+    t = T.get(lang, T["🇺🇸 English"])
+    if portrait_img is None:
+        raise gr.Error(t["err_no_portrait"])
+
+    width, height = ASPECT_PRESETS.get(aspect_ratio, (512, 512))
+    _tts_tmp: str | None = None
+
+    try:
+        if input_mode == "text":
+            if not text or not text.strip():
+                raise gr.Error(t["err_no_text"])
+            if len(text) > MAX_TEXT_LEN:
+                raise gr.Error(t["err_text_long"])
+            if voice_ref and not os.path.exists(voice_ref):
+                voice_ref = None
+            _tts_tmp = _run_tts(text, voice_ref, emotion, language=tts_language)
+            audio_path = _tts_tmp
+        else:
+            if audio_file is None:
+                raise gr.Error(t["err_no_audio"])
+            info = torchaudio.info(audio_file)
+            if (info.num_frames / info.sample_rate) > MAX_AUDIO_SEC:
+                raise gr.Error(t["err_audio_long"])
+            audio_path = audio_file
+
+        return _run_echomimic(portrait_img, audio_path, width, height, int(num_steps), float(guidance_scale))
+
+    except torch.cuda.OutOfMemoryError:
+        raise gr.Error(t["err_oom"])
+    except gr.Error:
+        raise
+    except Exception as e:
+        raise gr.Error(f"Generation failed: {str(e)[:400]}")
+    finally:
+        if _tts_tmp and os.path.exists(_tts_tmp):
+            try:
+                os.unlink(_tts_tmp)
+            except Exception:
+                pass
+        torch.cuda.empty_cache()
+        gc.collect()
+
+
+# ── Phase 2: Dubbing endpoint ─────────────────────────────────────────────────
+@spaces.GPU(duration=180)
+def dub_video(video_input, target_lang: str, voice_ref, emotion: float, lang: str,
+              progress=gr.Progress(track_tqdm=True)):
+
+    t = T.get(lang, T["🇺🇸 English"])
+    temp_files: list[str] = []
+
+    try:
+        if video_input is None:
+            raise gr.Error(t["err_no_video"])
+
+        duration = dubbing.get_video_duration(video_input)
+        if duration > dubbing.MAX_DUB_AUDIO_SEC:
+            raise gr.Error(t["err_video_long"])
+
+        progress(0.10, desc="Extracting audio…")
+        audio_path = dubbing.extract_audio(video_input)
+        temp_files.append(audio_path)
+
+        progress(0.25, desc="Transcribing…")
+        transcript = dubbing.transcribe(audio_path)
+        dubbing._unload_whisper()
+
+        source_display = transcript.language_display
+        if source_display != target_lang:
+            progress(0.45, desc="Translating…")
+            try:
+                translated_text = dubbing.translate(transcript.text, source_display, target_lang)
+            except Exception as exc:
+                raise gr.Error(f"{t['err_translate']} ({str(exc)[:200]}")
+        else:
+            translated_text = transcript.text
+
+        if len(translated_text) > MAX_DUB_TEXT_LEN:
+            raise gr.Error(t["err_dub_text_long"])
+
+        progress(0.60, desc="Synthesizing speech…")
+        if voice_ref and not os.path.exists(voice_ref):
+            voice_ref = None
+        dubbed_audio = _run_tts(translated_text, voice_ref, emotion, language=target_lang)
+        temp_files.append(dubbed_audio)
+
+        progress(0.85, desc="Combining video…")
+        output_path = dubbing.mux_dubbed_video(video_input, dubbed_audio)
+
+        status = f"✓ {source_display} → {target_lang} | {duration:.1f}s"
+        return output_path, transcript.text, translated_text, status
+
+    except torch.cuda.OutOfMemoryError:
+        raise gr.Error(t["err_oom"])
+    except gr.Error:
+        raise
+    except Exception as e:
+        raise gr.Error(f"Dubbing failed: {str(e)[:400]}")
+    finally:
+        for fp in temp_files:
+            if fp and os.path.exists(fp):
+                try:
+                    os.unlink(fp)
+                except Exception:
+                    pass
+        torch.cuda.empty_cache()
+        gc.collect()
+
+
+# ── Language switcher ─────────────────────────────────────────────────────────
+def switch_language(lang: str):
+    t = T.get(lang, T["🇺🇸 English"])
+    mode_choices = [(t["mode_text"], "text"), (t["mode_audio"], "audio")]
+    # 26 outputs — must match _lang_out list order below
+    return (
+        # Phase 1 (16)
+        gr.update(label=t["portrait_label"],   info=t["portrait_info"]),
+        gr.update(label=t["input_mode_label"], choices=mode_choices, value="text"),
+        gr.update(label=t["text_label"],        placeholder=t["text_ph"]),
+        gr.update(label=t["tts_lang_label"]),
+        gr.update(label=t["voice_ref_label"],   info=t["voice_ref_info"]),
+        gr.update(label=t["emotion_label"],     info=t["emotion_info"]),
+        gr.update(label=t["audio_label"],       info=t["audio_info"]),
+        gr.update(label=t["aspect_label"]),
+        gr.update(label=t["advanced"]),
+        gr.update(label=t["steps_label"],       info=t["steps_info"]),
+        gr.update(label=t["guidance_label"],    info=t["guidance_info"]),
+        gr.update(value=t["generate"]),
+        gr.update(value=t["examples_header"]),
+        gr.update(visible=True),    # text_group
+        gr.update(visible=False),   # audio_group
+        gr.update(label=t["output_label"]),
+        # Phase 2 (10)
+        gr.update(label=t["dub_video_label"],   info=t["dub_video_info"]),
+        gr.update(label=t["dub_target_label"]),
+        gr.update(label=t["dub_voice_label"],   info=t["dub_voice_info"]),
+        gr.update(label=t["dub_emotion_label"]),
+        gr.update(value=t["dub_btn"]),
+        gr.update(label=t["dub_output_label"]),
+        gr.update(label=t["dub_transcript"]),
+        gr.update(label=t["dub_translation"]),
+        gr.update(label=t["dub_status"]),
+        gr.update(label=t["dub_details"]),
+    )
+
+
+def _toggle_input_mode(mode: str, _lang: str):
+    is_text = (mode == "text")
+    return gr.update(visible=is_text), gr.update(visible=not is_text)
+
+
+# ── Interface ─────────────────────────────────────────────────────────────────
+with gr.Blocks(title="AnimaStudio 🎬") as demo:
+
+    gr.HTML("""
+    <div class="as-header">
+        <h1>🎬 AnimaStudio</h1>
+        <p class="tagline">AI Talking Head Video Creator &amp; Video Dubbing Studio</p>
+        <div class="badges">
+            <span class="badge badge-purple">🎭 Lip Sync</span>
+            <span class="badge badge-pink">🗣️ 23 TTS Languages</span>
+            <span class="badge badge-cyan">🎙️ Voice Cloning</span>
+            <span class="badge badge-teal">🎙️ Video Dubbing</span>
+            <span class="badge">⚡ EchoMimic V3</span>
+            <span class="badge badge-gold">🌐 EN · PT-BR · ES · AR</span>
+            <span class="badge">🤖 MCP Server</span>
+        </div>
+    </div>
+    """)
+
+    lang_selector = gr.Radio(
+        choices=list(T.keys()),
+        value="🇺🇸 English",
+        label=None,
+        container=False,
+        elem_id="lang-selector",
+    )
+
+    with gr.Tabs():
+
+        # ══ Tab 1: Create Video ════════════════════════════════════════════════
+        with gr.Tab("🎬 Create Video", id="tab-create"):
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=1, min_width=360):
+                    portrait = gr.Image(
+                        label="Portrait Photo",
+                        info="Upload a clear, front-facing face photo",
+                        type="pil",
+                        sources=["upload", "webcam"],
+                    )
+                    input_mode = gr.Radio(
+                        choices=[(T["🇺🇸 English"]["mode_text"], "text"),
+                                 (T["🇺🇸 English"]["mode_audio"], "audio")],
+                        value="text",
+                        label="Audio Input",
+                    )
+                    with gr.Group(visible=True) as text_group:
+                        text_input = gr.Textbox(
+                            label="Text",
+                            placeholder="Type what you want the avatar to say...",
+                            lines=4, max_lines=10,
+                        )
+                        tts_language = gr.Dropdown(choices=TTS_LANGUAGES, value="English", label="Speech Language")
+                        with gr.Row():
+                            voice_ref = gr.Audio(
+                                label="Voice Reference",
+                                info="Optional: upload audio to clone the voice style",
+                                type="filepath", sources=["upload"],
+                            )
+                        emotion = gr.Slider(0.0, 1.0, value=0.5, step=0.05,
+                                            label="Emotion Intensity", info="0 = neutral · 1 = very expressive")
+                    with gr.Group(visible=False) as audio_group:
+                        audio_upload = gr.Audio(
+                            label="Audio File",
+                            info="Upload WAV, MP3, or FLAC · max 30 seconds",
+                            type="filepath", sources=["upload", "microphone"],
+                        )
+                    aspect_ratio = gr.Dropdown(choices=list(ASPECT_PRESETS.keys()),
+                                               value="◻ 1:1  · 512×512", label="Format")
+                    with gr.Accordion("⚙️ Advanced Settings", open=False) as adv_acc:
+                        num_steps = gr.Slider(5, 50, value=DEFAULT_STEPS, step=1,
+                                              label="Inference Steps", info="More steps = higher quality, slower")
+                        guidance_scale = gr.Slider(1.0, 10.0, value=DEFAULT_CFG, step=0.5,
+                                                   label="Guidance Scale", info="Higher = follows audio more strictly")
+                    gen_btn = gr.Button("🎬  Generate Video", variant="primary", elem_id="gen-btn", size="lg")
+                    examples_header = gr.Markdown("### 💡 Try These Examples")
+                    gr.Examples(examples=ALL_EXAMPLES_FLAT, inputs=[text_input, tts_language, emotion], label=None)
+
+                with gr.Column(scale=1, min_width=440):
+                    output_video = gr.Video(label="Generated Video", format="mp4", autoplay=True,
+                                            height=640, elem_id="output-video", show_download_button=True)
+
+        # ══ Tab 2: Dub Video ═══════════════════════════════════════════════════
+        with gr.Tab("🎙️ Dub Video", id="tab-dub"):
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=1, min_width=360):
+                    dub_video_input = gr.Video(label="Input Video",
+                                               info="Upload a video to dub (max 60 seconds)",
+                                               sources=["upload"])
+                    dub_target_lang = gr.Dropdown(choices=TTS_LANGUAGES, value="English", label="Target Language")
+                    dub_voice_ref = gr.Audio(label="Voice Reference",
+                                             info="Optional: upload audio to clone voice style for dubbing",
+                                             type="filepath", sources=["upload"])
+                    dub_emotion = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="Emotion Intensity")
+                    dub_btn = gr.Button("🎙️  Dub Video", variant="primary", elem_id="dub-btn", size="lg")
+                    gr.HTML("""
+                    <div style="color:#94a3b8;font-size:0.82rem;margin-top:0.5rem;padding:0.75rem;
+                                background:rgba(6,182,212,0.05);border-radius:0.5rem;
+                                border:1px solid rgba(6,182,212,0.15);">
+                        <strong>How it works:</strong> Whisper transcribes → NLLB-200 translates →
+                        Chatterbox TTS synthesizes → audio replaces original track.
+                    </div>
+                    """)
+
+                with gr.Column(scale=1, min_width=440):
+                    dub_output_video = gr.Video(label="Dubbed Video", format="mp4", autoplay=True,
+                                                height=480, elem_id="dub-output-video", show_download_button=True)
+                    with gr.Accordion("Details", open=False) as dub_details_acc:
+                        dub_transcript_box = gr.Textbox(label="Detected Transcript", interactive=False, lines=4)
+                        dub_translation_box = gr.Textbox(label="Translation", interactive=False, lines=4)
+                        dub_status_box = gr.Textbox(label="Status", interactive=False, lines=2)
+
+    gr.HTML("""
+    <div class="as-footer">
+        <strong>Models:</strong>
+        <a href="https://huggingface.co/BadToBest/EchoMimicV3" target="_blank">EchoMimic V3</a>
+        (Apache 2.0) &nbsp;·&nbsp;
+        <a href="https://huggingface.co/ResembleAI/chatterbox" target="_blank">Chatterbox TTS</a>
+        (MIT) &nbsp;·&nbsp;
+        <a href="https://huggingface.co/openai/whisper-large-v3-turbo" target="_blank">Whisper Turbo</a>
+        (MIT) &nbsp;·&nbsp;
+        <a href="https://huggingface.co/facebook/nllb-200-distilled-600M" target="_blank">NLLB-200</a>
+        (CC-BY-NC) &nbsp;·&nbsp;
+        <strong>Space by:</strong>
+        <a href="https://huggingface.co/lulavc" target="_blank">lulavc</a>
+        &nbsp;·&nbsp; ZeroGPU &nbsp;·&nbsp; A10G
+    </div>
+    """)
+
+    # ── Events ────────────────────────────────────────────────────────────────
+    gen_btn.click(
+        generate,
+        inputs=[portrait, input_mode, text_input, tts_language,
+                voice_ref, audio_upload, aspect_ratio, emotion,
+                num_steps, guidance_scale, lang_selector],
+        outputs=output_video,
+    )
+
+    input_mode.change(_toggle_input_mode, inputs=[input_mode, lang_selector],
+                      outputs=[text_group, audio_group])
+
+    dub_btn.click(
+        dub_video,
+        inputs=[dub_video_input, dub_target_lang, dub_voice_ref, dub_emotion, lang_selector],
+        outputs=[dub_output_video, dub_transcript_box, dub_translation_box, dub_status_box],
+    )
+
+    # Language switcher — 26 outputs, must match switch_language() return tuple order
+    _lang_out = [
+        # Phase 1 (16)
+        portrait, input_mode, text_input, tts_language,
+        voice_ref, emotion, audio_upload, aspect_ratio,
+        adv_acc, num_steps, guidance_scale, gen_btn, examples_header,
+        text_group, audio_group, output_video,
+        # Phase 2 (10)
+        dub_video_input, dub_target_lang, dub_voice_ref,
+        dub_emotion, dub_btn, dub_output_video,
+        dub_transcript_box, dub_translation_box,
+        dub_status_box, dub_details_acc,
+    ]
+    lang_selector.change(switch_language, inputs=lang_selector, outputs=_lang_out)
+
+
+if __name__ == "__main__":
+    demo.launch(theme=THEME, css=CSS, mcp_server=True)

dubbing.py

@@ -0,0 +1,188 @@
+"""Video dubbing pipeline: extract audio → transcribe → translate → TTS → mux."""
+
+import gc
+import logging
+import os
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+import torch
+from huggingface_hub import InferenceClient
+
+from lang_codes import get_nllb_code, whisper_code_to_display
+
+log = logging.getLogger(__name__)
+
+# ── Constants ────────────────────────────────────────────────────────────────
+MAX_DUB_AUDIO_SEC = 60
+WHISPER_MODEL_SIZE = "turbo"   # ~809M params, ~2GB VRAM on A10G
+NLLB_MODEL_ID = "facebook/nllb-200-distilled-600M"
+
+# ── Singleton ─────────────────────────────────────────────────────────────────
+_whisper_model = None
+
+
+@dataclass(frozen=True)
+class TranscriptionResult:
+    text: str
+    language: str            # Whisper ISO 639-1 code (e.g. "en")
+    language_display: str    # Display name matching TTS_LANGUAGES (e.g. "English")
+    segments: tuple          # tuple of {"start", "end", "text"} dicts
+
+
+# ── Whisper lifecycle ─────────────────────────────────────────────────────────
+
+def _load_whisper():
+    global _whisper_model
+    if _whisper_model is None:
+        import whisper
+        log.info("Loading Whisper %s…", WHISPER_MODEL_SIZE)
+        _whisper_model = whisper.load_model(WHISPER_MODEL_SIZE, device="cpu")
+        log.info("Whisper %s ready", WHISPER_MODEL_SIZE)
+    return _whisper_model
+
+
+def _unload_whisper():
+    global _whisper_model
+    if _whisper_model is not None:
+        _whisper_model.to("cpu")
+        del _whisper_model
+        _whisper_model = None
+        torch.cuda.empty_cache()
+        gc.collect()
+        log.info("Whisper unloaded")
+
+
+# ── Step 1: Extract audio ─────────────────────────────────────────────────────
+
+def extract_audio(video_path: str) -> str:
+    """Extract audio from video as 16kHz mono WAV. Returns temp file path."""
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+        out_path = f.name
+    cmd = [
+        "ffmpeg", "-y", "-loglevel", "error",
+        "-i", video_path,
+        "-vn", "-acodec", "pcm_s16le",
+        "-ar", "16000", "-ac", "1",
+        out_path,
+    ]
+    subprocess.run(cmd, check=True, timeout=60)
+    return out_path
+
+
+# ── Step 2: Transcribe (GPU) ──────────────────────────────────────────────────
+
+def transcribe(audio_path: str) -> TranscriptionResult:
+    """Transcribe audio with Whisper turbo. Moves model to CUDA, then back to CPU."""
+    model = _load_whisper()
+    model.to("cuda")
+    try:
+        result = model.transcribe(audio_path, task="transcribe", fp16=True)
+        detected_lang = result.get("language", "en")
+        display_name = whisper_code_to_display(detected_lang) or "English"
+        segments = tuple(
+            {"start": s["start"], "end": s["end"], "text": s["text"]}
+            for s in result.get("segments", [])
+        )
+        return TranscriptionResult(
+            text=result["text"].strip(),
+            language=detected_lang,
+            language_display=display_name,
+            segments=segments,
+        )
+    finally:
+        model.to("cpu")
+        torch.cuda.empty_cache()
+        gc.collect()
+
+
+# ── Step 3: Translate via HF Inference API (no GPU) ──────────────────────────
+
+def translate(text: str, source_lang: str, target_lang: str) -> str:
+    """Translate text using NLLB-200 via HF Inference API.
+
+    Args:
+        text: Source text.
+        source_lang: Display name e.g. "English".
+        target_lang: Display name e.g. "Portuguese".
+
+    Returns:
+        Translated text string.
+    """
+    if source_lang == target_lang:
+        return text
+
+    src_code = get_nllb_code(source_lang)
+    tgt_code = get_nllb_code(target_lang)
+
+    # Client instantiated once outside the retry loop
+    client = InferenceClient()
+    last_exc: Optional[Exception] = None
+    for attempt in range(3):
+        try:
+            result = client.translation(
+                text,
+                model=NLLB_MODEL_ID,
+                src_lang=src_code,
+                tgt_lang=tgt_code,
+            )
+            if isinstance(result, str):
+                return result
+            if isinstance(result, dict):
+                return result.get("translation_text") or result.get("generated_text") or str(result)
+            return str(result)
+        except Exception as exc:
+            last_exc = exc
+            log.warning("Translation attempt %d failed: %s", attempt + 1, exc)
+            time.sleep(2 ** attempt)
+
+    raise RuntimeError(f"Translation failed after 3 attempts: {last_exc}") from last_exc
+
+
+# ── Step 4: Mux dubbed audio onto original video ──────────────────────────────
+
+def mux_dubbed_video(video_path: str, audio_path: str) -> str:
+    """Replace video audio with dubbed audio track. Returns output MP4 path.
+
+    Cleans up the output file if ffmpeg fails (no partial file leak).
+    """
+    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
+        out_path = f.name
+    cmd = [
+        "ffmpeg", "-y", "-loglevel", "error",
+        "-i", video_path,
+        "-i", audio_path,
+        "-c:v", "copy",
+        "-c:a", "aac", "-b:a", "128k",
+        "-map", "0:v:0", "-map", "1:a:0",
+        "-shortest",
+        out_path,
+    ]
+    try:
+        subprocess.run(cmd, check=True, timeout=120)
+        return out_path
+    except Exception:
+        # Clean up partial output file on ffmpeg failure
+        if os.path.exists(out_path):
+            try:
+                os.unlink(out_path)
+            except OSError:
+                pass
+        raise
+
+
+# ── Utility ───────────────────────────────────────────────────────────────────
+
+def get_video_duration(video_path: str) -> float:
+    """Return video duration in seconds using ffprobe."""
+    cmd = [
+        "ffprobe", "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        video_path,
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=30)
+    return float(result.stdout.strip())

i18n.py

@@ -0,0 +1,271 @@
+"""Internationalization: TTS language list, example texts, and UI translations."""
+
+MAX_TEXT_LEN  = 500
+MAX_AUDIO_SEC = 30
+
+TTS_LANGUAGES = [
+    "Arabic", "Danish", "German", "Greek", "English",
+    "Spanish", "Finnish", "French", "Hebrew", "Hindi",
+    "Italian", "Japanese", "Korean", "Malay", "Dutch",
+    "Norwegian", "Polish", "Portuguese", "Russian", "Swedish",
+    "Swahili", "Turkish", "Chinese",
+]
+
+# ── Examples per UI language ──────────────────────────────────────────────────
+# Format: [text, tts_language, emotion]
+EXAMPLES = {
+    "🇺🇸 English": [
+        ["Hello! Welcome to this presentation. Today I'll be sharing some exciting insights about artificial intelligence and how it's changing the world around us.", "English", 0.5],
+        ["I'm thrilled to announce the launch of our new project. After months of hard work and dedication, we've created something truly special I can't wait to share with you.", "English", 0.7],
+        ["Good morning, students! Today's lecture covers neural networks — the backbone of modern AI. By the end of this session you'll understand how machines learn from data.", "English", 0.4],
+        ["Breaking news: scientists have discovered a new method for sustainable energy production that could revolutionise how we power our cities. More details coming up.", "English", 0.6],
+    ],
+    "🇧🇷 Português": [
+        ["Olá a todos! Sejam bem-vindos a esta apresentação. Hoje vou compartilhar com vocês algumas descobertas incríveis sobre inteligência artificial e como ela está transformando o nosso mundo.", "Portuguese", 0.5],
+        ["Estou muito animado para anunciar o lançamento do nosso novo projeto. Depois de meses de trabalho dedicado, criamos algo verdadeiramente especial que mal posso esperar para mostrar a vocês.", "Portuguese", 0.7],
+        ["Bom dia, estudantes! A aula de hoje aborda redes neurais — a base da IA moderna. Ao final desta sessão, vocês vão entender como as máquinas aprendem com os dados.", "Portuguese", 0.4],
+        ["Esta receita tradicional foi passada de geração em geração na minha família. Hoje vou ensinar como preparar um prato delicioso que vai impressionar todos os seus convidados.", "Portuguese", 0.6],
+    ],
+    "🇪🇸 Español": [
+        ["¡Hola a todos! Bienvenidos a esta presentación. Hoy voy a compartir con ustedes algunos descubrimientos fascinantes sobre la inteligencia artificial y cómo está transformando nuestro mundo.", "Spanish", 0.5],
+        ["Estoy muy emocionado de anunciar el lanzamiento de nuestro nuevo proyecto. Después de meses de arduo trabajo hemos creado algo verdaderamente especial que no puedo esperar para mostrarles.", "Spanish", 0.7],
+        ["Buenos días, estudiantes. La clase de hoy trata sobre las redes neuronales, la columna vertebral de la IA moderna. Al final de esta sesión entenderán cómo las máquinas aprenden de los datos.", "Spanish", 0.4],
+        ["Esta receta tradicional ha pasado de generación en generación en mi familia. Hoy les enseñaré cómo preparar un plato delicioso que impresionará a todos sus invitados.", "Spanish", 0.6],
+    ],
+    "🇪🇬 عربي": [
+        ["مرحباً بالجميع! أهلاً وسهلاً بكم في هذا العرض التقديمي. اليوم سأشارككم بعض الاكتشافات المثيرة حول الذكاء الاصطناعي وكيف يُغيّر عالمنا من حولنا.", "Arabic", 0.5],
+        ["يسعدني الإعلان عن إطلاق مشروعنا الجديد. بعد أشهر من العمل الدؤوب أبدعنا شيئاً رائعاً حقاً لا أصبر على مشاركته معكم جميعاً.", "Arabic", 0.7],
+        ["صباح الخير أيها الطلاب! محاضرة اليوم تتناول الشبكات العصبية التي تمثّل الأساس التقني للذكاء الاصطناعي الحديث. بنهاية هذه الجلسة ستفهمون كيف تتعلم الآلات من البيانات.", "Arabic", 0.4],
+        ["هذه الوصفة التقليدية انتقلت من جيل إلى جيل في عائلتي. اليوم سأعلّمكم كيفية تحضير طبق شهي سيُبهر جميع ضيوفكم ويجعلهم يطلبون المزيد.", "Arabic", 0.6],
+    ],
+}
+
+ALL_EXAMPLES_FLAT = [ex for exs in EXAMPLES.values() for ex in exs]
+
+# ── UI translations ────────────────────────────────────────────────────────────
+T: dict[str, dict[str, str]] = {
+    "🇺🇸 English": {
+        # Phase 1: Create Video
+        "tab_create":        "🎬 Create Video",
+        "tagline":           "AI Talking Head Video Creator",
+        "input_mode_label":  "Audio Input",
+        "mode_text":         "Text to Speech",
+        "mode_audio":        "Upload Audio",
+        "portrait_label":    "Portrait Photo",
+        "portrait_info":     "Upload a clear, front-facing face photo",
+        "text_label":        "Text",
+        "text_ph":           "Type what you want the avatar to say...",
+        "tts_lang_label":    "Speech Language",
+        "voice_ref_label":   "Voice Reference",
+        "voice_ref_info":    "Optional: upload audio to clone the voice style",
+        "emotion_label":     "Emotion Intensity",
+        "emotion_info":      "0 = neutral · 1 = very expressive",
+        "audio_label":       "Audio File",
+        "audio_info":        "Upload WAV, MP3, or FLAC · max 30 seconds",
+        "aspect_label":      "Format",
+        "advanced":          "⚙️ Advanced Settings",
+        "steps_label":       "Inference Steps",
+        "steps_info":        "More steps = higher quality, slower",
+        "guidance_label":    "Guidance Scale",
+        "guidance_info":     "Higher = follows audio more strictly",
+        "generate":          "🎬  Generate Video",
+        "output_label":      "Generated Video",
+        "examples_header":   "### 💡 Try These Examples",
+        "err_no_portrait":   "Please upload a portrait photo.",
+        "err_no_text":       "Please enter some text.",
+        "err_no_audio":      "Please upload an audio file.",
+        "err_text_long":     f"Text too long (max {MAX_TEXT_LEN} characters).",
+        "err_audio_long":    f"Audio too long (max {MAX_AUDIO_SEC} seconds).",
+        "err_oom":           "GPU out of memory. Try a smaller format or fewer steps.",
+        "err_no_face":       "No face detected. Please upload a clear front-facing portrait.",
+        "err_model":         "Model not loaded. Please refresh and try again.",
+        # Phase 2: Dub Video
+        "tab_dub":           "🎙️ Dub Video",
+        "dub_tagline":       "Dub any video into 23 languages",
+        "dub_video_label":   "Input Video",
+        "dub_video_info":    "Upload a video to dub (max 60 seconds)",
+        "dub_target_label":  "Target Language",
+        "dub_voice_label":   "Voice Reference",
+        "dub_voice_info":    "Optional: upload audio to clone voice style for dubbing",
+        "dub_emotion_label": "Emotion Intensity",
+        "dub_btn":           "🎙️  Dub Video",
+        "dub_output_label":  "Dubbed Video",
+        "dub_transcript":    "Detected Transcript",
+        "dub_translation":   "Translation",
+        "dub_status":        "Status",
+        "dub_details":       "Details",
+        "err_no_video":      "Please upload a video.",
+        "err_video_long":    "Video too long (max 60 seconds).",
+        "err_translate":     "Translation failed. Please try again.",
+        "err_transcribe":    "Transcription failed. Please try again.",
+        "err_dub_text_long": "Transcription too long to synthesize. Please use a shorter video.",
+    },
+    "🇧🇷 Português": {
+        # Phase 1: Create Video
+        "tab_create":        "🎬 Criar Vídeo",
+        "tagline":           "Criador de Vídeo Avatar com IA",
+        "input_mode_label":  "Entrada de Áudio",
+        "mode_text":         "Texto para Fala",
+        "mode_audio":        "Enviar Áudio",
+        "portrait_label":    "Foto Retrato",
+        "portrait_info":     "Envie uma foto frontal clara do rosto",
+        "text_label":        "Texto",
+        "text_ph":           "Digite o que você quer que o avatar diga...",
+        "tts_lang_label":    "Idioma da Fala",
+        "voice_ref_label":   "Referência de Voz",
+        "voice_ref_info":    "Opcional: envie um áudio para clonar o estilo de voz",
+        "emotion_label":     "Intensidade da Emoção",
+        "emotion_info":      "0 = neutro · 1 = muito expressivo",
+        "audio_label":       "Arquivo de Áudio",
+        "audio_info":        "Envie WAV, MP3 ou FLAC · máx. 30 segundos",
+        "aspect_label":      "Formato",
+        "advanced":          "⚙️ Configurações Avançadas",
+        "steps_label":       "Etapas de Inferência",
+        "steps_info":        "Mais etapas = maior qualidade, mais lento",
+        "guidance_label":    "Escala de Orientação",
+        "guidance_info":     "Maior = segue o áudio com mais precisão",
+        "generate":          "🎬  Gerar Vídeo",
+        "output_label":      "Vídeo Gerado",
+        "examples_header":   "### 💡 Experimente Estes Exemplos",
+        "err_no_portrait":   "Por favor, envie uma foto retrato.",
+        "err_no_text":       "Por favor, insira algum texto.",
+        "err_no_audio":      "Por favor, envie um arquivo de áudio.",
+        "err_text_long":     f"Texto muito longo (máx. {MAX_TEXT_LEN} caracteres).",
+        "err_audio_long":    f"Áudio muito longo (máx. {MAX_AUDIO_SEC} segundos).",
+        "err_oom":           "GPU sem memória. Tente um formato menor ou menos etapas.",
+        "err_no_face":       "Nenhum rosto detectado. Envie uma foto retrato frontal clara.",
+        "err_model":         "Modelo não carregado. Atualize a página e tente novamente.",
+        # Phase 2: Dub Video
+        "tab_dub":           "🎙️ Dublar Vídeo",
+        "dub_tagline":       "Duble qualquer vídeo em 23 idiomas",
+        "dub_video_label":   "Vídeo de Entrada",
+        "dub_video_info":    "Envie um vídeo para dublar (máx. 60 segundos)",
+        "dub_target_label":  "Idioma de Destino",
+        "dub_voice_label":   "Referência de Voz",
+        "dub_voice_info":    "Opcional: envie áudio para clonar o estilo de voz na dublagem",
+        "dub_emotion_label": "Intensidade da Emoção",
+        "dub_btn":           "🎙️  Dublar Vídeo",
+        "dub_output_label":  "Vídeo Dublado",
+        "dub_transcript":    "Transcrição Detectada",
+        "dub_translation":   "Tradução",
+        "dub_status":        "Status",
+        "dub_details":       "Detalhes",
+        "err_no_video":      "Por favor, envie um vídeo.",
+        "err_video_long":    "Vídeo muito longo (máx. 60 segundos).",
+        "err_translate":     "Tradução falhou. Por favor, tente novamente.",
+        "err_transcribe":    "Transcrição falhou. Por favor, tente novamente.",
+        "err_dub_text_long": "Transcrição longa demais para sintetizar. Use um vídeo mais curto.",
+    },
+    "🇪🇸 Español": {
+        # Phase 1: Create Video
+        "tab_create":        "🎬 Crear Vídeo",
+        "tagline":           "Creador de Vídeo Avatar con IA",
+        "input_mode_label":  "Entrada de Audio",
+        "mode_text":         "Texto a Voz",
+        "mode_audio":        "Subir Audio",
+        "portrait_label":    "Foto Retrato",
+        "portrait_info":     "Sube una foto frontal clara del rostro",
+        "text_label":        "Texto",
+        "text_ph":           "Escribe lo que quieres que diga el avatar...",
+        "tts_lang_label":    "Idioma del Habla",
+        "voice_ref_label":   "Referencia de Voz",
+        "voice_ref_info":    "Opcional: sube un audio para clonar el estilo de voz",
+        "emotion_label":     "Intensidad Emocional",
+        "emotion_info":      "0 = neutro · 1 = muy expresivo",
+        "audio_label":       "Archivo de Audio",
+        "audio_info":        "Sube WAV, MP3 o FLAC · máx. 30 segundos",
+        "aspect_label":      "Formato",
+        "advanced":          "⚙️ Configuración Avanzada",
+        "steps_label":       "Pasos de Inferencia",
+        "steps_info":        "Más pasos = mayor calidad, más lento",
+        "guidance_label":    "Escala de Guía",
+        "guidance_info":     "Mayor = sigue el audio con más precisión",
+        "generate":          "🎬  Generar Vídeo",
+        "output_label":      "Vídeo Generado",
+        "examples_header":   "### 💡 Prueba Estos Ejemplos",
+        "err_no_portrait":   "Por favor, sube una foto retrato.",
+        "err_no_text":       "Por favor, ingresa algún texto.",
+        "err_no_audio":      "Por favor, sube un archivo de audio.",
+        "err_text_long":     f"Texto demasiado largo (máx. {MAX_TEXT_LEN} caracteres).",
+        "err_audio_long":    f"Audio demasiado largo (máx. {MAX_AUDIO_SEC} segundos).",
+        "err_oom":           "Sin memoria GPU. Prueba un formato menor o menos pasos.",
+        "err_no_face":       "No se detectó rostro. Sube una foto retrato frontal clara.",
+        "err_model":         "Modelo no cargado. Recarga la página e intenta de nuevo.",
+        # Phase 2: Dub Video
+        "tab_dub":           "🎙️ Doblar Vídeo",
+        "dub_tagline":       "Dobla cualquier vídeo a 23 idiomas",
+        "dub_video_label":   "Vídeo de Entrada",
+        "dub_video_info":    "Sube un vídeo para doblar (máx. 60 segundos)",
+        "dub_target_label":  "Idioma de Destino",
+        "dub_voice_label":   "Referencia de Voz",
+        "dub_voice_info":    "Opcional: sube audio para clonar el estilo de voz en el doblaje",
+        "dub_emotion_label": "Intensidad Emocional",
+        "dub_btn":           "🎙️  Doblar Vídeo",
+        "dub_output_label":  "Vídeo Doblado",
+        "dub_transcript":    "Transcripción Detectada",
+        "dub_translation":   "Traducción",
+        "dub_status":        "Estado",
+        "dub_details":       "Detalles",
+        "err_no_video":      "Por favor, sube un vídeo.",
+        "err_video_long":    "Vídeo demasiado largo (máx. 60 segundos).",
+        "err_translate":     "Traducción fallida. Por favor, inténtalo de nuevo.",
+        "err_transcribe":    "Transcripción fallida. Por favor, inténtalo de nuevo.",
+        "err_dub_text_long": "Transcripción demasiado larga. Usa un vídeo más corto.",
+    },
+    "🇪🇬 عربي": {
+        # Phase 1: Create Video
+        "tab_create":        "🎬 إنشاء فيديو",
+        "tagline":           "منشئ فيديو الأفاتار بالذكاء الاصطناعي",
+        "input_mode_label":  "مدخل الصوت",
+        "mode_text":         "نص إلى كلام",
+        "mode_audio":        "رفع ملف صوتي",
+        "portrait_label":    "صورة الوجه",
+        "portrait_info":     "ارفع صورة واضحة للوجه من الأمام",
+        "text_label":        "النص",
+        "text_ph":           "اكتب ما تريد أن يقوله الأفاتار...",
+        "tts_lang_label":    "لغة الكلام",
+        "voice_ref_label":   "مرجع الصوت",
+        "voice_ref_info":    "اختياري: ارفع ملفاً صوتياً لاستنساخ أسلوب الصوت",
+        "emotion_label":     "شدة التعبير العاطفي",
+        "emotion_info":      "0 = محايد · 1 = تعبيري جداً",
+        "audio_label":       "الملف الصوتي",
+        "audio_info":        "ارفع WAV أو MP3 أو FLAC · الحد الأقصى 30 ثانية",
+        "aspect_label":      "التنسيق",
+        "advanced":          "⚙️ الإعدادات المتقدمة",
+        "steps_label":       "خطوات الاستدلال",
+        "steps_info":        "المزيد من الخطوات = جودة أعلى، وقت أطول",
+        "guidance_label":    "مقياس التوجيه",
+        "guidance_info":     "أعلى = يتبع الصوت بدقة أكبر",
+        "generate":          "🎬  توليد الفيديو",
+        "output_label":      "الفيديو المُنشأ",
+        "examples_header":   "### 💡 جرّب هذه الأمثلة",
+        "err_no_portrait":   "الرجاء رفع صورة وجه.",
+        "err_no_text":       "الرجاء إدخال نص.",
+        "err_no_audio":      "الرجاء رفع ملف صوتي.",
+        "err_text_long":     f"النص طويل جداً (الحد الأقصى {MAX_TEXT_LEN} حرف).",
+        "err_audio_long":    f"الصوت طويل جداً (الحد الأقصى {MAX_AUDIO_SEC} ثانية).",
+        "err_oom":           "نفدت ذاكرة GPU. جرّب تنسيقاً أصغر أو خطوات أقل.",
+        "err_no_face":       "لم يُكتشف أي وجه. ارفع صورة وجه واضحة من الأمام.",
+        "err_model":         "النموذج غير محمّل. أعد تحميل الصفحة وحاول مجدداً.",
+        # Phase 2: Dub Video
+        "tab_dub":           "🎙️ دبلجة فيديو",
+        "dub_tagline":       "دبلج أي فيديو إلى 23 لغة",
+        "dub_video_label":   "الفيديو المُدخل",
+        "dub_video_info":    "ارفع فيديو للدبلجة (الحد الأقصى 60 ثانية)",
+        "dub_target_label":  "اللغة الهدف",
+        "dub_voice_label":   "مرجع الصوت",
+        "dub_voice_info":    "اختياري: ارفع ملفاً صوتياً لاستنساخ أسلوب الصوت في الدبلجة",
+        "dub_emotion_label": "شدة التعبير العاطفي",
+        "dub_btn":           "🎙️  دبلجة الفيديو",
+        "dub_output_label":  "الفيديو المدبلج",
+        "dub_transcript":    "النص المُكتشف",
+        "dub_translation":   "الترجمة",
+        "dub_status":        "الحالة",
+        "dub_details":       "التفاصيل",
+        "err_no_video":      "الرجاء رفع فيديو.",
+        "err_video_long":    "الفيديو طويل جداً (الحد الأقصى 60 ثانية).",
+        "err_translate":     "فشلت الترجمة. الرجاء المحاولة مجدداً.",
+        "err_transcribe":    "فشل النسخ. الرجاء المحاولة مجدداً.",
+        "err_dub_text_long": "النص المُكتشف طويل جداً. استخدم مقطعاً أقصر.",
+    },
+}

lang_codes.py

@@ -0,0 +1,66 @@
+"""Language code mappings between TTS display names, Whisper ISO-639-1, and NLLB BCP-47."""
+
+from dataclasses import dataclass
+from typing import Mapping
+
+
+@dataclass(frozen=True)
+class LangInfo:
+    display: str      # Display name matching TTS_LANGUAGES (e.g., "Portuguese")
+    nllb: str         # NLLB-200 BCP-47 flores code (e.g., "por_Latn")
+    whisper: str      # Whisper ISO 639-1 code (e.g., "pt")
+
+
+LANG_MAP: Mapping[str, LangInfo] = {
+    "Arabic":     LangInfo("Arabic",     "arb_Arab", "ar"),
+    "Danish":     LangInfo("Danish",     "dan_Latn", "da"),
+    "German":     LangInfo("German",     "deu_Latn", "de"),
+    "Greek":      LangInfo("Greek",      "ell_Grek", "el"),
+    "English":    LangInfo("English",    "eng_Latn", "en"),
+    "Spanish":    LangInfo("Spanish",    "spa_Latn", "es"),
+    "Finnish":    LangInfo("Finnish",    "fin_Latn", "fi"),
+    "French":     LangInfo("French",     "fra_Latn", "fr"),
+    "Hebrew":     LangInfo("Hebrew",     "heb_Hebr", "he"),
+    "Hindi":      LangInfo("Hindi",      "hin_Deva", "hi"),
+    "Italian":    LangInfo("Italian",    "ita_Latn", "it"),
+    "Japanese":   LangInfo("Japanese",   "jpn_Jpan", "ja"),
+    "Korean":     LangInfo("Korean",     "kor_Hang", "ko"),
+    "Malay":      LangInfo("Malay",      "zsm_Latn", "ms"),
+    "Dutch":      LangInfo("Dutch",      "nld_Latn", "nl"),
+    "Norwegian":  LangInfo("Norwegian",  "nob_Latn", "no"),
+    "Polish":     LangInfo("Polish",     "pol_Latn", "pl"),
+    "Portuguese": LangInfo("Portuguese", "por_Latn", "pt"),
+    "Russian":    LangInfo("Russian",    "rus_Cyrl", "ru"),
+    "Swedish":    LangInfo("Swedish",    "swe_Latn", "sv"),
+    "Swahili":    LangInfo("Swahili",    "swh_Latn", "sw"),
+    "Turkish":    LangInfo("Turkish",    "tur_Latn", "tr"),
+    "Chinese":    LangInfo("Chinese",    "zho_Hans", "zh"),
+}
+
+
+def get_nllb_code(lang_display: str) -> str:
+    info = LANG_MAP.get(lang_display)
+    if info is None:
+        raise ValueError(f"Unknown language: {lang_display!r}")
+    return info.nllb
+
+
+def get_whisper_code(lang_display: str) -> str:
+    info = LANG_MAP.get(lang_display)
+    if info is None:
+        raise ValueError(f"Unknown language: {lang_display!r}")
+    return info.whisper
+
+
+def whisper_code_to_display(whisper_code: str) -> str | None:
+    for info in LANG_MAP.values():
+        if info.whisper == whisper_code:
+            return info.display
+    return None
+
+
+def nllb_code_to_display(nllb_code: str) -> str | None:
+    for info in LANG_MAP.values():
+        if info.nllb == nllb_code:
+            return info.display
+    return None

requirements.txt

@@ -0,0 +1,34 @@
+# ── Exact versions matching chatterbox-tts 0.1.6 deps ────────────────────────
+torch==2.6.0
+torchaudio==2.6.0
+torchvision==0.21.0
+transformers==4.46.3
+tokenizers==0.20.3
+diffusers==0.29.0
+safetensors==0.5.3
+accelerate==1.2.1
+
+# ── Gradio (conflicts with chatterbox-tts PyPI — use GitHub clone instead) ───
+gradio==6.0.2
+spaces
+
+# ── Chatterbox runtime deps (no chatterbox-tts pip install — cloned at runtime) ─
+librosa==0.11.0
+s3tokenizer
+resemble-perth==1.0.1
+conformer==0.3.2
+spacy-pkuseg
+pykakasi==2.3.0
+pyloudnorm
+omegaconf
+numpy>=1.24.0
+
+# ── Other ─────────────────────────────────────────────────────────────────────
+opencv-python-headless
+Pillow>=10.0.0
+huggingface_hub>=0.23.0
+
+# ── Phase 2: Video Dubbing ───────────────────────────────────────────────────
+openai-whisper
+tiktoken
+more-itertools

styles.py

@@ -0,0 +1,153 @@
+"""Gradio theme and CSS for AnimaStudio."""
+import gradio as gr
+
+THEME = gr.themes.Soft(
+    primary_hue="purple",
+    secondary_hue="pink",
+    neutral_hue="slate",
+)
+
+CSS = """
+/* ── Global ─────────────────────────────────────── */
+.gradio-container {
+    max-width: 1380px !important;
+    margin: 0 auto !important;
+}
+
+/* ── Header ──────────────────────────────────────── */
+.as-header {
+    text-align: center;
+    padding: 2.4rem 1rem 2rem;
+    border-radius: 1.5rem;
+    margin-bottom: 1.5rem;
+    background: linear-gradient(135deg, #1a0b2e 0%, #2d1b4e 40%, #1a1040 70%, #0d0b1e 100%);
+    border: 1px solid rgba(168,85,247,0.25);
+    box-shadow: 0 4px 60px rgba(168,85,247,0.1), inset 0 1px 0 rgba(255,255,255,0.05);
+    position: relative;
+    overflow: hidden;
+}
+
+.as-header::before {
+    content: '';
+    position: absolute;
+    top: -50%; left: -50%;
+    width: 200%; height: 200%;
+    background: radial-gradient(ellipse at center, rgba(168,85,247,0.08) 0%, transparent 60%);
+    pointer-events: none;
+}
+
+.as-header h1 {
+    font-size: 3.2rem !important;
+    font-weight: 900 !important;
+    margin: 0 0 0.6rem !important;
+    line-height: 1.05 !important;
+    background: linear-gradient(90deg, #e879f9 0%, #a855f7 40%, #f472b6 80%, #fb923c 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    letter-spacing: -0.035em;
+}
+
+.as-header .tagline {
+    color: #94a3b8 !important;
+    font-size: 1.0rem !important;
+    margin: 0 0 1rem !important;
+}
+
+.as-header .badges {
+    display: flex;
+    justify-content: center;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+}
+
+/* ── Badges ───────────────────────────────────────── */
+.badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.3rem;
+    padding: 0.25rem 0.75rem;
+    border-radius: 999px;
+    font-size: 0.78rem;
+    font-weight: 600;
+    background: rgba(255,255,255,0.06);
+    border: 1px solid rgba(255,255,255,0.1);
+    color: #cbd5e1;
+}
+.badge-purple { border-color: rgba(168,85,247,0.4);  color: #a855f7; background: rgba(168,85,247,0.08); }
+.badge-pink   { border-color: rgba(244,114,182,0.4); color: #f472b6; background: rgba(244,114,182,0.08); }
+.badge-cyan   { border-color: rgba(34,211,238,0.4);  color: #22d3ee; background: rgba(34,211,238,0.08); }
+.badge-gold   { border-color: rgba(251,191,36,0.4);  color: #fbbf24; background: rgba(251,191,36,0.08); }
+.badge-teal   { border-color: rgba(20,184,166,0.4);  color: #14b8a6; background: rgba(20,184,166,0.08); }
+
+/* ── Language selector ────────────────────────────── */
+#lang-selector .wrap { gap: 4px !important; justify-content: center !important; }
+#lang-selector label span { font-size: 0.9rem !important; }
+#lang-selector { margin-bottom: 0.5rem !important; }
+
+/* ── Generate Button ──────────────────────────────── */
+#gen-btn {
+    background: linear-gradient(135deg, #a855f7 0%, #ec4899 100%) !important;
+    border: none !important;
+    font-size: 1.15rem !important;
+    font-weight: 700 !important;
+    padding: 0.85rem 1rem !important;
+    border-radius: 0.85rem !important;
+    color: white !important;
+    box-shadow: 0 4px 24px rgba(168,85,247,0.4) !important;
+    transition: all 0.2s ease !important;
+    letter-spacing: 0.02em !important;
+    width: 100% !important;
+}
+#gen-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 32px rgba(168,85,247,0.55) !important;
+}
+#gen-btn:active { transform: translateY(0) !important; }
+
+/* ── Dub Button ────────────────────────────────────── */
+#dub-btn {
+    background: linear-gradient(135deg, #06b6d4 0%, #a855f7 100%) !important;
+    border: none !important;
+    font-size: 1.15rem !important;
+    font-weight: 700 !important;
+    padding: 0.85rem 1rem !important;
+    border-radius: 0.85rem !important;
+    color: white !important;
+    box-shadow: 0 4px 24px rgba(6,182,212,0.4) !important;
+    transition: all 0.2s ease !important;
+    letter-spacing: 0.02em !important;
+    width: 100% !important;
+}
+#dub-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 32px rgba(6,182,212,0.55) !important;
+}
+#dub-btn:active { transform: translateY(0) !important; }
+
+/* ── Output Video ─────────────────────────────────── */
+#output-video, #dub-output-video {
+    border-radius: 1rem !important;
+    overflow: hidden !important;
+    background: #0f172a !important;
+    min-height: 420px !important;
+}
+
+/* ── Footer ──���────────────────────────────────────── */
+.as-footer {
+    text-align: center;
+    padding: 1.2rem 0 0.5rem;
+    color: #475569;
+    font-size: 0.82rem;
+    border-top: 1px solid #1e293b;
+    margin-top: 1rem;
+}
+.as-footer a { color: #a855f7 !important; text-decoration: none !important; }
+.as-footer a:hover { text-decoration: underline !important; }
+
+/* ── Mobile ───────────────────────────────────────── */
+@media (max-width: 768px) {
+    .as-header h1 { font-size: 2rem !important; }
+    .badges { gap: 0.35rem !important; }
+}
+"""