Upload 2 files

app.py

@@ -1,22 +1,19 @@
 """
 Audiobook Generator - English Source to Multi-Language Audio
-Powered by Qwen3.5-Omni-Plus + Qwen3-TTS-VC via DashScope API
-
-Three voice modes:
-  1. Preset Voices: Use built-in Qwen voices (via Qwen3.5-Omni-Plus)
-  2. Cloned Voice: Clone a voice from audio sample (via Qwen3-TTS-VC)
-  3. Both support translation from English to 36 languages
+Powered by:
+  - Qwen3.5-Omni-Plus (preset voices, 36 languages)
+  - Qwen3-TTS-VC (voice cloning, 10 languages)
+  - YourVoic API (1000+ emotional voices, 93+ languages including Arabic, Swahili, Indian languages)
 
 Deploy as a Hugging Face Space:
   1. Create a new Space (SDK: Gradio)
   2. Upload app.py and requirements.txt
-  3. Add DASHSCOPE_API_KEY as a Space Secret
+  3. Add secrets: DASHSCOPE_API_KEY (required), YOURVOIC_API_KEY (optional)
 """
 
 import os
 import base64
 import json
-import math
 import pathlib
 import shutil
 import struct
@@ -29,7 +26,6 @@ import gradio as gr
 import requests as http_requests
 from openai import OpenAI
 
-# Optional document parsers
 try:
     import pypdf
     HAS_PYPDF = True
@@ -42,57 +38,126 @@ try:
 except ImportError:
     HAS_DOCX = False
 
-# Configuration
+# ==========================================
+# CONFIGURATION
+# ==========================================
 OMNI_MODEL = "qwen3.5-omni-plus"
 TTS_VC_MODEL = "qwen3-tts-vc-2026-01-22"
 VOICE_CLONE_MODEL = "qwen-voice-enrollment"
 
-BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+DASHSCOPE_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
 DASHSCOPE_API_URL = "https://dashscope-intl.aliyuncs.com/api/v1"
 VOICE_CLONE_URL = f"{DASHSCOPE_API_URL}/services/audio/tts/customization"
 TTS_SYNTHESIS_URL = f"{DASHSCOPE_API_URL}/services/aigc/multimodal-generation/generation"
 
+# YourVoic API
+YOURVOIC_TTS_URL = "https://yourvoic.com/api/v1/tts/generate"
+YOURVOIC_VOICES_URL = "https://yourvoic.com/api/v1/voices"
+
 MAX_CHARS_PER_CHUNK = 1500
 
-# Languages
+# ==========================================
+# LANGUAGES - split by engine
+# ==========================================
+# "engine": "qwen" = Qwen Preset + Clone, "yourvoic" = YourVoic only, "both" = available on both
 LANGUAGES = {
-    "English": {"code": "en", "native": "English", "tier": "core"},
-    "Chinese (Mandarin)": {"code": "zh", "native": "Chinese", "tier": "core"},
-    "Japanese": {"code": "ja", "native": "Japanese", "tier": "core"},
-    "Korean": {"code": "ko", "native": "Korean", "tier": "core"},
-    "German": {"code": "de", "native": "Deutsch", "tier": "core"},
-    "French": {"code": "fr", "native": "Francais", "tier": "core"},
-    "Russian": {"code": "ru", "native": "Russian", "tier": "core"},
-    "Portuguese": {"code": "pt", "native": "Portugues", "tier": "core"},
-    "Spanish": {"code": "es", "native": "Espanol", "tier": "core"},
-    "Italian": {"code": "it", "native": "Italiano", "tier": "core"},
-    "Arabic": {"code": "ar", "native": "Arabic", "tier": "extended"},
-    "Dutch": {"code": "nl", "native": "Nederlands", "tier": "extended"},
-    "Hindi": {"code": "hi", "native": "Hindi", "tier": "extended"},
-    "Urdu": {"code": "ur", "native": "Urdu", "tier": "extended"},
-    "Swahili": {"code": "sw", "native": "Kiswahili", "tier": "extended"},
+    # -- Qwen Core (11 languages: 10 starred + Arabic) --
+    "English": {"code": "en", "engine": "qwen", "yourvoic": "en-US"},
+    "Chinese (Mandarin)": {"code": "zh", "engine": "qwen", "yourvoic": "zh-CN"},
+    "Japanese": {"code": "ja", "engine": "qwen", "yourvoic": "ja-JP"},
+    "Korean": {"code": "ko", "engine": "qwen", "yourvoic": "ko-KR"},
+    "German": {"code": "de", "engine": "qwen", "yourvoic": "de-DE"},
+    "French": {"code": "fr", "engine": "qwen", "yourvoic": "fr-FR"},
+    "Russian": {"code": "ru", "engine": "qwen", "yourvoic": "ru-RU"},
+    "Portuguese": {"code": "pt", "engine": "qwen", "yourvoic": "pt-BR"},
+    "Spanish": {"code": "es", "engine": "qwen", "yourvoic": "es-ES"},
+    "Italian": {"code": "it", "engine": "qwen", "yourvoic": "it-IT"},
+    "Arabic": {"code": "ar", "engine": "qwen", "yourvoic": "ar-SA"},
+    # -- YourVoic: African Languages --
+    "Afrikaans": {"code": "af", "engine": "yourvoic", "yourvoic": "af-ZA"},
+    "Amharic": {"code": "am", "engine": "yourvoic", "yourvoic": "am-ET"},
+    "Swahili": {"code": "sw", "engine": "yourvoic", "yourvoic": "sw-KE"},
+    # -- YourVoic: Core Indian Languages --
+    "Hindi": {"code": "hi", "engine": "yourvoic", "yourvoic": "hi-IN"},
+    "Marathi": {"code": "mr", "engine": "yourvoic", "yourvoic": "mr-IN"},
+    "Bengali": {"code": "bn", "engine": "yourvoic", "yourvoic": "bn-IN"},
+    "Telugu": {"code": "te", "engine": "yourvoic", "yourvoic": "te-IN"},
+    "Tamil": {"code": "ta", "engine": "yourvoic", "yourvoic": "ta-IN"},
+    "Gujarati": {"code": "gu", "engine": "yourvoic", "yourvoic": "gu-IN"},
+    "Kannada": {"code": "kn", "engine": "yourvoic", "yourvoic": "kn-IN"},
+    "Malayalam": {"code": "ml", "engine": "yourvoic", "yourvoic": "ml-IN"},
+    "Punjabi": {"code": "pa", "engine": "yourvoic", "yourvoic": "pa-IN"},
+    "Odia": {"code": "or", "engine": "yourvoic", "yourvoic": "or-IN"},
+    "Assamese": {"code": "as", "engine": "yourvoic", "yourvoic": "as-IN"},
+    "Maithili": {"code": "mai", "engine": "yourvoic", "yourvoic": "mai-IN"},
+    "Kashmiri": {"code": "ks", "engine": "yourvoic", "yourvoic": "ks-IN"},
+    "Sindhi": {"code": "sd", "engine": "yourvoic", "yourvoic": "sd-IN"},
+    "Konkani": {"code": "kok", "engine": "yourvoic", "yourvoic": "kok-IN"},
+    "Dogri": {"code": "doi", "engine": "yourvoic", "yourvoic": "doi-IN"},
+    "Manipuri": {"code": "mni", "engine": "yourvoic", "yourvoic": "mni-IN"},
+    "Bodo": {"code": "brx", "engine": "yourvoic", "yourvoic": "brx-IN"},
+    "Sanskrit": {"code": "sa", "engine": "yourvoic", "yourvoic": "sa-IN"},
+    # -- YourVoic: Related South Asian Languages --
+    "Urdu": {"code": "ur", "engine": "yourvoic", "yourvoic": "ur-PK"},
+    "Nepali": {"code": "ne", "engine": "yourvoic", "yourvoic": "ne-NP"},
+    "Sinhala": {"code": "si", "engine": "yourvoic", "yourvoic": "si-LK"},
 }
 
+# Qwen languages (for preset + clone)
+QWEN_LANGUAGES = {k for k, v in LANGUAGES.items() if v["engine"] == "qwen"}
+
+# Voice cloning only supports the original 10 (not Arabic)
 VOICE_CLONE_LANGUAGES = {
     "English", "Chinese (Mandarin)", "Japanese", "Korean", "German",
     "French", "Russian", "Portuguese", "Spanish", "Italian",
 }
 
+# YourVoic languages
+YOURVOIC_LANGUAGES = {k for k, v in LANGUAGES.items() if v["engine"] == "yourvoic"}
+
 PRESET_VOICES = [
-    "Cherry -- Sunny, friendly",
-    "Jennifer -- Cinematic narrator",
-    "Katerina -- Mature, rich rhythm",
-    "Ethan -- Warm, energetic",
-    "Ryan -- Dramatic, rhythmic",
-    "Kai -- Soothing, calm",
-    "Aiden -- Young, lively",
-    "Eldric Sage -- Authoritative narrator",
-    "Arthur -- Classic, mature",
-    "Bella -- Elegant, warm",
-    "Vivian -- Professional, clear",
-    "Seren -- Calm, measured",
-    "Dolce -- Sweet, melodic",
-    "Vincent -- Rich, theatrical",
+    "Cherry -- Sunny, friendly", "Serena -- Gentle, soft",
+    "Jennifer -- Cinematic narrator", "Katerina -- Mature, rich rhythm",
+    "Ethan -- Warm, energetic", "Ryan -- Dramatic, rhythmic",
+    "Kai -- Soothing, calm", "Neil -- Precise, clear",
+    "Lenn -- Rational, steady", "Eldric Sage -- Authoritative narrator",
+    "Arthur -- Classic, mature", "Bella -- Elegant, warm",
+    "Vivian -- Professional, clear", "Seren -- Calm, measured",
+    "Dolce -- Sweet, melodic", "Bellona -- Strong, commanding",
+    "Vincent -- Rich, theatrical", "Andre -- Deep, resonant",
+    "Mia -- Young, versatile", "Aiden -- Young, lively",
+]
+
+# YourVoic voices organized by language
+YOURVOIC_VOICES = [
+    "Peter -- English, Professional male",
+    "Sarah -- English, Warm female",
+    "Caleb -- English, Expressive male",
+    "Natasha -- Hindi, Versatile female",
+    "Rahul -- Hindi, Friendly male",
+    "Deepika -- Hindi, Professional female",
+    "Aditya -- Hindi, Lively male",
+    "Priya -- Tamil, Caring female",
+    "Sneha -- Bengali, Wise female",
+    "Arjun -- Telugu, Strong male",
+    "Divya -- Kannada, Expressive female",
+    "Anjali -- Marathi, Professional female",
+    "Vikram -- Punjabi, Warm male",
+    "Kavya -- Odia, Energetic female",
+    "Nikhil -- Malayalam, Advanced male",
+]
+
+YOURVOIC_MODELS = [
+    "aura-max -- Premium quality (best for audiobooks)",
+    "aura-prime -- Balanced quality and speed",
+    "aura-lite -- Fast, good for previews",
+    "rapid-max -- Fast with good quality",
+    "rapid-flash -- Fastest, real-time apps",
+]
+
+YOURVOIC_EMOTIONS = [
+    "neutral", "friendly", "hopeful", "cheerful", "sad",
+    "excited", "angry", "terrified", "shouting", "whispering",
 ]
 
 
@@ -100,12 +165,16 @@ def get_voice_name(label):
     return label.split("--")[0].strip()
 
 
-# Audio helpers
+def get_yourvoic_model(label):
+    return label.split("--")[0].strip()
+
+
+# ==========================================
+# AUDIO HELPERS
+# ==========================================
 def base64_to_wav(b64_data, output_path):
     audio_bytes = base64.b64decode(b64_data)
-    sr = 24000
-    nc = 1
-    bps = 16
+    sr, nc, bps = 24000, 1, 16
     br = sr * nc * bps // 8
     ba = nc * bps // 8
     ds = len(audio_bytes)
@@ -146,494 +215,423 @@ def concatenate_wavs(wav_files, output_path):
 
 def generate_silence(duration_sec, output_path):
     subprocess.run(
-        ["ffmpeg", "-y", "-f", "lavfi",
-         "-i", "anullsrc=r=24000:cl=mono",
+        ["ffmpeg", "-y", "-f", "lavfi", "-i", "anullsrc=r=24000:cl=mono",
          "-t", str(duration_sec), "-acodec", "pcm_s16le", output_path],
         capture_output=True, check=True,
     )
 
 
-# Document extraction
-def extract_text_from_pdf(filepath):
-    if not HAS_PYPDF:
-        raise ImportError("pypdf is not installed.")
-    reader = pypdf.PdfReader(filepath)
-    pages = []
-    for page in reader.pages:
-        text = page.extract_text()
-        if text:
-            pages.append(text.strip())
-    return "\n\n".join(pages)
-
-
-def extract_text_from_docx(filepath):
-    if not HAS_DOCX:
-        raise ImportError("python-docx is not installed.")
-    doc = docx.Document(filepath)
-    paragraphs = []
-    for para in doc.paragraphs:
-        text = para.text.strip()
-        if text:
-            paragraphs.append(text)
-    return "\n\n".join(paragraphs)
-
-
+# ==========================================
+# DOCUMENT EXTRACTION
+# ==========================================
 def extract_text_from_file(filepath):
     ext = os.path.splitext(filepath)[1].lower()
     if ext == ".pdf":
-        return extract_text_from_pdf(filepath)
+        if not HAS_PYPDF:
+            raise gr.Error("pypdf not installed.")
+        reader = pypdf.PdfReader(filepath)
+        return "\n\n".join(p.extract_text().strip() for p in reader.pages if p.extract_text())
     elif ext in (".docx", ".doc"):
         if ext == ".doc":
-            try:
-                tmp_dir = tempfile.mkdtemp()
-                subprocess.run(
-                    ["libreoffice", "--headless", "--convert-to", "docx",
-                     "--outdir", tmp_dir, filepath],
-                    capture_output=True, check=True, timeout=60,
-                )
-                docx_name = os.path.splitext(os.path.basename(filepath))[0] + ".docx"
-                docx_path = os.path.join(tmp_dir, docx_name)
-                if os.path.exists(docx_path):
-                    text = extract_text_from_docx(docx_path)
-                    shutil.rmtree(tmp_dir, ignore_errors=True)
-                    return text
-            except Exception:
-                pass
-            raise gr.Error("Cannot read .doc files. Please save as .docx or .pdf.")
-        return extract_text_from_docx(filepath)
+            raise gr.Error("Please save as .docx or .pdf.")
+        if not HAS_DOCX:
+            raise gr.Error("python-docx not installed.")
+        doc = docx.Document(filepath)
+        return "\n\n".join(p.text.strip() for p in doc.paragraphs if p.text.strip())
     else:
         with open(filepath, "r", encoding="utf-8", errors="replace") as f:
             return f.read()
 
 
-# Text splitting
+# ==========================================
+# TEXT SPLITTING
+# ==========================================
 def split_text_into_chunks(text, max_chars=MAX_CHARS_PER_CHUNK):
     text = text.strip()
     if not text:
         return []
     if len(text) <= max_chars:
         return [text]
-
-    chunks = []
-    paragraphs = re.split(r"\n\s*\n", text)
-    current_chunk = ""
-
+    chunks, paragraphs, current = [], re.split(r"\n\s*\n", text), ""
     for para in paragraphs:
         para = para.strip()
         if not para:
             continue
-        if len(current_chunk) + len(para) + 2 <= max_chars:
-            current_chunk = (current_chunk + "\n\n" + para).strip()
+        if len(current) + len(para) + 2 <= max_chars:
+            current = (current + "\n\n" + para).strip()
         else:
-            if current_chunk:
-                chunks.append(current_chunk)
-                current_chunk = ""
+            if current:
+                chunks.append(current)
             if len(para) > max_chars:
                 sentences = re.split(r"(?<=[.!?])\s+", para)
-                for sentence in sentences:
-                    if len(current_chunk) + len(sentence) + 1 <= max_chars:
-                        current_chunk = (current_chunk + " " + sentence).strip()
+                current = ""
+                for s in sentences:
+                    if len(current) + len(s) + 1 <= max_chars:
+                        current = (current + " " + s).strip()
                     else:
-                        if current_chunk:
-                            chunks.append(current_chunk)
-                        if len(sentence) > max_chars:
-                            words = sentence.split()
-                            current_chunk = ""
-                            for word in words:
-                                if len(current_chunk) + len(word) + 1 <= max_chars:
-                                    current_chunk = (current_chunk + " " + word).strip()
-                                else:
-                                    if current_chunk:
-                                        chunks.append(current_chunk)
-                                    current_chunk = word
-                        else:
-                            current_chunk = sentence
+                        if current:
+                            chunks.append(current)
+                        current = s
             else:
-                current_chunk = para
-
-    if current_chunk:
-        chunks.append(current_chunk)
+                current = para
+    if current:
+        chunks.append(current)
     return chunks
 
 
-# ==============================
-# VOICE CLONING
-# ==============================
+# ==========================================
+# VOICE CLONING (Qwen)
+# ==========================================
 def prepare_clone_audio(audio_path):
-    """
-    Prepare audio for voice cloning:
-    - Accept 10s to 3min input
-    - Trim to best 60s (API max) from the middle for voice consistency
-    - Convert to mono WAV at 24kHz for best quality
-    Returns path to the prepared file.
-    """
-    # Get duration
     result = subprocess.run(
         ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
          "-of", "default=noprint_wrappers=1:nokey=1", audio_path],
         capture_output=True, text=True,
     )
     duration = float(result.stdout.strip())
-
     if duration < 10:
-        raise ValueError(
-            f"Audio is too short ({duration:.1f}s). "
-            f"Please provide at least 10 seconds of clear speech."
-        )
-
-    # If under 60s, just convert format; if over 60s, take the best 60s
-    tmp_prepared = audio_path + "_prepared.wav"
-
+        raise ValueError(f"Audio too short ({duration:.1f}s). Need at least 10 seconds.")
+    tmp = audio_path + "_prepared.wav"
     if duration <= 60:
-        # Convert to proper format (mono, 24kHz, 16-bit WAV)
-        subprocess.run(
-            ["ffmpeg", "-y", "-i", audio_path,
-             "-ar", "24000", "-ac", "1", "-acodec", "pcm_s16le",
-             tmp_prepared],
-            capture_output=True, check=True,
-        )
+        subprocess.run(["ffmpeg", "-y", "-i", audio_path, "-ar", "24000", "-ac", "1",
+                        "-acodec", "pcm_s16le", tmp], capture_output=True, check=True)
     else:
-        # Take 60s from 5s into the audio (skip intro silence/noise)
         start = min(5, duration - 60)
-        subprocess.run(
-            ["ffmpeg", "-y", "-ss", str(start), "-t", "60",
-             "-i", audio_path,
-             "-ar", "24000", "-ac", "1", "-acodec", "pcm_s16le",
-             tmp_prepared],
-            capture_output=True, check=True,
-        )
-
-    return tmp_prepared
+        subprocess.run(["ffmpeg", "-y", "-ss", str(start), "-t", "60", "-i", audio_path,
+                        "-ar", "24000", "-ac", "1", "-acodec", "pcm_s16le", tmp],
+                       capture_output=True, check=True)
+    return tmp
 
 
-def clone_voice(audio_path, api_key, preferred_name="audiobook_voice"):
-    # Prepare audio (trim if needed, convert format)
-    prepared_path = prepare_clone_audio(audio_path)
-
-    filepath = pathlib.Path(prepared_path)
-    if not filepath.exists():
-        raise FileNotFoundError(f"Prepared audio file not found: {prepared_path}")
-
-    b64_str = base64.b64encode(filepath.read_bytes()).decode()
-    data_uri = f"data:audio/wav;base64,{b64_str}"
-
-    # Clean up prepared file
+def clone_voice(audio_path, api_key):
+    prepared = prepare_clone_audio(audio_path)
+    b64 = base64.b64encode(pathlib.Path(prepared).read_bytes()).decode()
     try:
-        os.remove(prepared_path)
+        os.remove(prepared)
     except OSError:
         pass
-
-    payload = {
+    resp = http_requests.post(VOICE_CLONE_URL, json={
         "model": VOICE_CLONE_MODEL,
         "input": {
-            "action": "create",
-            "target_model": TTS_VC_MODEL,
-            "preferred_name": preferred_name,
-            "audio": {"data": data_uri},
+            "action": "create", "target_model": TTS_VC_MODEL,
+            "preferred_name": "audiobook_voice",
+            "audio": {"data": f"data:audio/wav;base64,{b64}"},
         },
-    }
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-    }
-
-    resp = http_requests.post(VOICE_CLONE_URL, json=payload, headers=headers, timeout=60)
+    }, headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}, timeout=60)
     if resp.status_code != 200:
-        raise RuntimeError(f"Voice cloning failed ({resp.status_code}): {resp.text}")
-
-    try:
-        return resp.json()["output"]["voice"]
-    except (KeyError, ValueError) as e:
-        raise RuntimeError(f"Failed to parse voice clone response: {e}\n{resp.text}")
-
-
-# ==============================
-# TTS WITH CLONED VOICE
-# ==============================
-def synthesize_with_cloned_voice(text, voice_id, language, api_key, output_dir, chunk_index):
-    lang_type_map = {
-        "English": "English", "Chinese (Mandarin)": "Chinese",
-        "Japanese": "Japanese", "Korean": "Korean",
-        "German": "German", "French": "French",
-        "Russian": "Russian", "Portuguese": "Portuguese",
-        "Spanish": "Spanish", "Italian": "Italian",
-    }
-    language_type = lang_type_map.get(language, "English")
-
-    payload = {
-        "model": TTS_VC_MODEL,
-        "input": {
-            "text": text,
-            "voice": voice_id,
-            "language_type": language_type,
-        },
-    }
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-    }
+        raise RuntimeError(f"Voice clone failed: {resp.text[:300]}")
+    return resp.json()["output"]["voice"]
 
-    try:
-        resp = http_requests.post(TTS_SYNTHESIS_URL, json=payload, headers=headers, timeout=120)
-        if resp.status_code != 200:
-            return None, f"TTS failed ({resp.status_code}): {resp.text[:200]}"
-
-        result = resp.json()
-        audio_url = result.get("output", {}).get("audio", {}).get("url")
-        if not audio_url:
-            return None, f"No audio URL in response: {json.dumps(result)[:200]}"
-
-        output_wav = os.path.join(output_dir, f"vc_chunk_{chunk_index:04d}.wav")
-        audio_resp = http_requests.get(audio_url, timeout=120)
-        if audio_resp.status_code != 200:
-            return None, "Failed to download audio from URL"
-
-        with open(output_wav, "wb") as f:
-            f.write(audio_resp.content)
-
-        return output_wav, None
 
-    except Exception as e:
-        return None, str(e)
-
-
-# ==============================
-# TRANSLATION (text only)
-# ==============================
+# ==========================================
+# TRANSLATION (Qwen text-only)
+# ==========================================
 def translate_text(client, text, target_language, lang_config):
     response = client.chat.completions.create(
-        model=OMNI_MODEL,
-        modalities=["text"],
+        model=OMNI_MODEL, modalities=["text"],
         messages=[
-            {
-                "role": "system",
-                "content": (
-                    f"You are a professional translator. Translate English text into "
-                    f"natural, fluent {target_language} ({lang_config['native']}). "
-                    f"Output ONLY the translated text."
-                ),
-            },
-            {
-                "role": "user",
-                "content": f"Translate the following into {target_language}:\n\n{text}",
-            },
+            {"role": "system", "content": f"Translate English to {target_language}. Output ONLY the translation."},
+            {"role": "user", "content": f"Translate:\n\n{text}"},
         ],
     )
     return response.choices[0].message.content.strip()
 
 
-# ==============================
-# SPEECH WITH PRESET VOICE
-# ==============================
+# ==========================================
+# TTS MODE 1: PRESET VOICE (Qwen Omni)
+# ==========================================
 def generate_speech_preset(client, text, voice, language, lang_config, translate, chunk_index, output_dir):
     output_wav = os.path.join(output_dir, f"chunk_{chunk_index:04d}.wav")
-
     if translate and language != "English":
-        system_prompt = (
-            f"You are a professional audiobook narrator and translator.\n"
-            f"Translate the English text into natural {language} ({lang_config['native']}).\n"
-            f"Read the translation aloud with expressive audiobook narration.\n"
-            f"Respond ONLY with the spoken {language} narration."
-        )
-        user_text = f"Translate into {language} and narrate as an audiobook:\n\n{text}"
+        sys_prompt = (f"Translate English to {language} ({lang_config['native']}) "
+                      f"and narrate expressively. Respond ONLY with spoken {language} narration.")
+        user_text = f"Translate into {language} and narrate:\n\n{text}"
     else:
-        system_prompt = (
-            "You are a professional audiobook narrator.\n"
-            "Read the text with clear, expressive narration.\n"
-            "Respond ONLY with the spoken narration."
-        )
-        user_text = f"Narrate as an audiobook:\n\n{text}"
-
+        sys_prompt = "Narrate expressively as an audiobook. Respond ONLY with narration."
+        user_text = f"Narrate:\n\n{text}"
     try:
         completion = client.chat.completions.create(
             model=OMNI_MODEL,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_text},
-            ],
-            modalities=["text", "audio"],
-            audio={"voice": voice, "format": "wav"},
-            stream=True,
-            stream_options={"include_usage": True},
+            messages=[{"role": "system", "content": sys_prompt}, {"role": "user", "content": user_text}],
+            modalities=["text", "audio"], audio={"voice": voice, "format": "wav"},
+            stream=True, stream_options={"include_usage": True},
         )
-
-        audio_chunks = []
-        transcript_parts = []
-
+        audio_parts, text_parts = [], []
         for event in completion:
             if not event.choices:
                 continue
             delta = event.choices[0].delta
             if hasattr(delta, "content") and delta.content:
-                transcript_parts.append(delta.content)
+                text_parts.append(delta.content)
             if hasattr(delta, "audio") and delta.audio:
-                if isinstance(delta.audio, dict):
-                    if "data" in delta.audio:
-                        audio_chunks.append(delta.audio["data"])
+                if isinstance(delta.audio, dict) and "data" in delta.audio:
+                    audio_parts.append(delta.audio["data"])
                 elif hasattr(delta.audio, "data") and delta.audio.data:
-                    audio_chunks.append(delta.audio.data)
-
-        transcript = "".join(transcript_parts)
-
-        if audio_chunks:
-            full_audio_b64 = "".join(audio_chunks)
-            base64_to_wav(full_audio_b64, output_wav)
+                    audio_parts.append(delta.audio.data)
+        transcript = "".join(text_parts)
+        if audio_parts:
+            base64_to_wav("".join(audio_parts), output_wav)
             return output_wav, transcript
         return None, "No audio received"
-
     except Exception as e:
         return None, str(e)
 
 
-# ==============================
+# ==========================================
+# TTS MODE 2: CLONED VOICE (Qwen TTS-VC)
+# ==========================================
+def generate_speech_cloned(client, text, voice_id, language, lang_config, translate, api_key, chunk_index, output_dir):
+    output_wav = os.path.join(output_dir, f"vc_chunk_{chunk_index:04d}.wav")
+    final_text = text
+    if translate and language != "English":
+        final_text = translate_text(client, text, language, lang_config)
+    lang_map = {
+        "English": "English", "Chinese (Mandarin)": "Chinese", "Japanese": "Japanese",
+        "Korean": "Korean", "German": "German", "French": "French",
+        "Russian": "Russian", "Portuguese": "Portuguese", "Spanish": "Spanish", "Italian": "Italian",
+    }
+    resp = http_requests.post(TTS_SYNTHESIS_URL, json={
+        "model": TTS_VC_MODEL,
+        "input": {"text": final_text, "voice": voice_id, "language_type": lang_map.get(language, "English")},
+    }, headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}, timeout=120)
+    if resp.status_code != 200:
+        return None, final_text, f"TTS failed ({resp.status_code})"
+    audio_url = resp.json().get("output", {}).get("audio", {}).get("url")
+    if audio_url:
+        audio_resp = http_requests.get(audio_url, timeout=120)
+        with open(output_wav, "wb") as f:
+            f.write(audio_resp.content)
+        return output_wav, final_text, None
+    return None, final_text, "No audio URL"
+
+
+# ==========================================
+# TTS MODE 3: YOURVOIC (emotional voices, 93+ languages)
+# ==========================================
+def generate_speech_yourvoic(client, text, voice, yv_model, emotion, language, lang_config, translate,
+                             api_key, chunk_index, output_dir):
+    """Generate speech using YourVoic API. Handles translation via Qwen then TTS via YourVoic."""
+    output_file = os.path.join(output_dir, f"yv_chunk_{chunk_index:04d}.mp3")
+
+    # Translate if needed
+    final_text = text
+    transcript = text
+    if translate and language != "English":
+        try:
+            ds_key = os.environ.get("DASHSCOPE_API_KEY", "")
+            if ds_key and client:
+                final_text = translate_text(client, text, language, lang_config)
+                transcript = final_text
+        except Exception as e:
+            print(f"[YourVoic] Translation failed, using English: {e}")
+
+    # Build request
+    yourvoic_lang = lang_config.get("yourvoic", "en-US")
+    payload = {
+        "text": final_text,
+        "voice": voice,
+        "language": yourvoic_lang,
+        "model": yv_model,
+        "speed": 0.9,  # Slightly slower for audiobook pacing
+    }
+    # Add emotion if not neutral
+    if emotion and emotion != "neutral":
+        payload["emotion"] = emotion
+
+    headers = {
+        "X-API-Key": api_key,
+        "Content-Type": "application/json",
+    }
+
+    try:
+        resp = http_requests.post(YOURVOIC_TTS_URL, json=payload, headers=headers, timeout=120)
+        print(f"[YourVoic] Chunk {chunk_index}: status={resp.status_code}, size={len(resp.content)} bytes")
+
+        if resp.status_code != 200:
+            error_msg = resp.text[:200]
+            print(f"[YourVoic] Error: {error_msg}")
+            return None, transcript, f"YourVoic API error ({resp.status_code}): {error_msg}"
+
+        # Check if response is JSON (contains audio_url) or direct audio bytes
+        content_type = resp.headers.get("Content-Type", "")
+
+        if "application/json" in content_type:
+            data = resp.json()
+            audio_url = data.get("audio_url") or data.get("url")
+            if audio_url:
+                audio_resp = http_requests.get(audio_url, timeout=120)
+                with open(output_file, "wb") as f:
+                    f.write(audio_resp.content)
+            else:
+                return None, transcript, f"No audio URL in response: {json.dumps(data)[:200]}"
+        else:
+            # Direct audio bytes
+            with open(output_file, "wb") as f:
+                f.write(resp.content)
+
+        # Convert MP3 to WAV for consistent concatenation
+        output_wav = output_file.replace(".mp3", ".wav")
+        subprocess.run(
+            ["ffmpeg", "-y", "-i", output_file, "-ar", "24000", "-ac", "1",
+             "-acodec", "pcm_s16le", output_wav],
+            capture_output=True, check=True,
+        )
+        return output_wav, transcript, None
+
+    except Exception as e:
+        return None, transcript, str(e)
+
+
+# ==========================================
 # MAIN PIPELINE
-# ==============================
+# ==========================================
 def generate_audiobook(text_input, file_input, target_language, voice_mode,
-                       preset_voice_label, clone_audio, add_pauses, progress=gr.Progress()):
+                       preset_voice_label, clone_audio, yourvoic_voice_label,
+                       yourvoic_model_label, yourvoic_emotion,
+                       add_pauses, progress=gr.Progress()):
     # Resolve text
     if file_input is not None:
-        try:
-            progress(0.02, desc="Extracting text from document...")
-            text = extract_text_from_file(file_input)
-        except gr.Error:
-            raise
-        except Exception as e:
-            raise gr.Error(f"Failed to read file: {e}")
+        progress(0.02, desc="Extracting text from document...")
+        text = extract_text_from_file(file_input)
     elif text_input and text_input.strip():
         text = text_input.strip()
     else:
         raise gr.Error("Please provide text or upload a file.")
-
     if len(text) < 10:
         raise gr.Error("Text is too short.")
 
-    api_key = os.environ.get("DASHSCOPE_API_KEY", "")
-    if not api_key:
-        raise gr.Error("DASHSCOPE_API_KEY not set. Add it in Settings > Secrets.")
+    ds_key = os.environ.get("DASHSCOPE_API_KEY", "")
+    yv_key = os.environ.get("YOURVOIC_API_KEY", "")
 
     lang_config = LANGUAGES[target_language]
+    lang_engine = lang_config["engine"]
     use_clone = voice_mode == "Clone a Voice"
+    use_yourvoic = voice_mode == "YourVoic (Emotional AI)"
     translate = target_language != "English"
-    client = OpenAI(api_key=api_key, base_url=BASE_URL)
+
+    # Auto-correct engine if language requires it
+    if lang_engine == "yourvoic" and not use_yourvoic:
+        # Language only supported by YourVoic, force switch
+        use_yourvoic = True
+        use_clone = False
+    elif lang_engine == "qwen" and use_yourvoic:
+        # User chose YourVoic but language is Qwen-only — allow it since YourVoic
+        # supports most languages, but Qwen languages also work on YourVoic
+        pass
+
+    # Validate keys
+    if use_yourvoic:
+        if not yv_key:
+            raise gr.Error("YOURVOIC_API_KEY not set. Add it in Settings > Secrets. Get one at yourvoic.com/api/user")
+        if translate and not ds_key:
+            raise gr.Error("DASHSCOPE_API_KEY needed for translation. Add it in Settings > Secrets.")
+    else:
+        if not ds_key:
+            raise gr.Error("DASHSCOPE_API_KEY not set. Add it in Settings > Secrets.")
+
+    client = OpenAI(api_key=ds_key, base_url=DASHSCOPE_BASE_URL) if ds_key else None
     tmp_dir = tempfile.mkdtemp(prefix="audiobook_")
 
     # Voice cloning setup
     cloned_voice_id = None
     if use_clone:
         if clone_audio is None:
-            raise gr.Error("Please upload a voice sample (10-60 seconds of clear speech).")
-
+            raise gr.Error("Upload a voice sample for cloning.")
         if target_language not in VOICE_CLONE_LANGUAGES:
-            raise gr.Error(
-                f"Voice cloning TTS supports: {', '.join(sorted(VOICE_CLONE_LANGUAGES))}. "
-                f"'{target_language}' is not supported with cloned voices. Use a preset voice instead."
-            )
-
-        progress(0.03, desc="Cloning voice from audio sample...")
-        try:
-            cloned_voice_id = clone_voice(clone_audio, api_key)
-            progress(0.08, desc="Voice cloned successfully!")
-        except Exception as e:
-            raise gr.Error(f"Voice cloning failed: {e}")
+            raise gr.Error(f"Voice cloning supports: {', '.join(sorted(VOICE_CLONE_LANGUAGES))}")
+        progress(0.03, desc="Cloning voice...")
+        cloned_voice_id = clone_voice(clone_audio, ds_key)
 
     try:
-        # Split text
-        progress(0.10, desc="Splitting text into chunks...")
+        progress(0.08, desc="Splitting text...")
         chunks = split_text_into_chunks(text)
         total_chunks = len(chunks)
         total_chars = sum(len(c) for c in chunks)
 
-        # Process each chunk
-        audio_files = []
-        all_transcripts = []
+        audio_files, all_transcripts = [], []
         silence_path = os.path.join(tmp_dir, "silence.wav")
         if add_pauses:
             generate_silence(1.5, silence_path)
 
         for i, chunk in enumerate(chunks):
-            frac = 0.12 + 0.75 * (i / total_chunks)
+            frac = 0.10 + 0.78 * (i / total_chunks)
             progress(frac, desc=f"Narrating chunk {i+1}/{total_chunks}...")
 
-            if use_clone:
-                # CLONED VOICE PIPELINE
-                final_text = chunk
-                if translate:
-                    try:
-                        final_text = translate_text(client, chunk, target_language, lang_config)
-                        all_transcripts.append(final_text)
-                    except Exception as e:
-                        all_transcripts.append(f"Translation failed for chunk {i+1}: {e}")
-                        final_text = chunk
-
-                wav_path, error = synthesize_with_cloned_voice(
-                    final_text, cloned_voice_id, target_language, api_key, tmp_dir, i,
-                )
+            wav_path, transcript, error = None, None, None
 
-                if wav_path:
-                    audio_files.append(wav_path)
-                else:
-                    all_transcripts.append(f"TTS failed for chunk {i+1}: {error}")
-                    fail_silence = os.path.join(tmp_dir, f"fail_{i:04d}.wav")
-                    generate_silence(2.0, fail_silence)
-                    audio_files.append(fail_silence)
+            if use_yourvoic:
+                yv_voice = get_voice_name(yourvoic_voice_label)
+                yv_model = get_yourvoic_model(yourvoic_model_label)
+                wav_path, transcript, error = generate_speech_yourvoic(
+                    client, chunk, yv_voice, yv_model, yourvoic_emotion,
+                    target_language, lang_config, translate,
+                    yv_key, i, tmp_dir,
+                )
+            elif use_clone:
+                wav_path, transcript, error = generate_speech_cloned(
+                    client, chunk, cloned_voice_id, target_language,
+                    lang_config, translate, ds_key, i, tmp_dir,
+                )
             else:
-                # PRESET VOICE PIPELINE
                 voice = get_voice_name(preset_voice_label)
                 wav_path, transcript = generate_speech_preset(
                     client, chunk, voice, target_language,
                     lang_config, translate, i, tmp_dir,
                 )
+                error = None if wav_path else transcript
 
-                if wav_path:
-                    audio_files.append(wav_path)
-                else:
-                    all_transcripts.append(f"Chunk {i+1} failed: {transcript}")
-                    fail_silence = os.path.join(tmp_dir, f"fail_{i:04d}.wav")
-                    generate_silence(2.0, fail_silence)
-                    audio_files.append(fail_silence)
+            if wav_path:
+                audio_files.append(wav_path)
+            else:
+                all_transcripts.append(f"Chunk {i+1} failed: {error}")
+                fail_sil = os.path.join(tmp_dir, f"fail_{i:04d}.wav")
+                generate_silence(2.0, fail_sil)
+                audio_files.append(fail_sil)
 
-                if transcript and "failed" not in transcript.lower():
-                    all_transcripts.append(transcript)
+            if transcript and "failed" not in str(transcript).lower():
+                all_transcripts.append(transcript)
 
-            # Pause between chunks
             if add_pauses and i < total_chunks - 1 and audio_files:
                 audio_files.append(silence_path)
 
         if not audio_files:
             raise gr.Error("No audio was generated.")
 
-        # Concatenate
         progress(0.90, desc="Assembling audiobook...")
         final_audio = os.path.join(tmp_dir, "audiobook.wav")
         concatenate_wavs(audio_files, final_audio)
 
-        # Convert to MP3
         progress(0.95, desc="Converting to MP3...")
         final_mp3 = os.path.join(tmp_dir, "audiobook.mp3")
         subprocess.run(
-            ["ffmpeg", "-y", "-i", final_audio,
-             "-codec:a", "libmp3lame", "-b:a", "128k",
-             "-ar", "24000", "-ac", "1", final_mp3],
+            ["ffmpeg", "-y", "-i", final_audio, "-codec:a", "libmp3lame",
+             "-b:a", "128k", "-ar", "24000", "-ac", "1", final_mp3],
             capture_output=True, check=True,
         )
 
         progress(1.0, desc="Done!")
 
         audio_size = os.path.getsize(final_mp3) / (1024 * 1024)
-        voice_info = f"Cloned voice (ID: {cloned_voice_id[:20]}...)" if use_clone else preset_voice_label
+        if use_yourvoic:
+            voice_info = f"YourVoic: {yourvoic_voice_label} ({yourvoic_emotion})"
+            mode_info = f"YourVoic API ({yourvoic_model_label})"
+        elif use_clone:
+            voice_info = f"Cloned (ID: {cloned_voice_id[:20]}...)"
+            mode_info = "Qwen3-TTS-VC"
+        else:
+            voice_info = preset_voice_label
+            mode_info = "Qwen3.5-Omni-Plus"
+
         stats = (
             f"**Audiobook Generated!**\n\n"
             f"- **Source:** {total_chars:,} characters in {total_chunks} chunks\n"
             f"- **Language:** {target_language} ({lang_config['native']})\n"
             f"- **Voice:** {voice_info}\n"
-            f"- **Mode:** {'Voice Clone via Qwen3-TTS-VC' if use_clone else 'Preset via Qwen3.5-Omni-Plus'}\n"
+            f"- **Engine:** {mode_info}\n"
             f"- **File size:** {audio_size:.1f} MB\n"
         )
-        if lang_config["tier"] == "extended" and not use_clone:
-            stats += "\n> Note: Extended language - voice quality may vary."
 
         transcript_text = "\n\n---\n\n".join(all_transcripts) if all_transcripts else ""
-
         return final_mp3, stats, transcript_text
 
     except gr.Error:
@@ -642,20 +640,18 @@ def generate_audiobook(text_input, file_input, target_language, voice_mode,
         raise gr.Error(f"Pipeline error: {str(e)}")
 
 
-# ==============================
+# ==========================================
 # GRADIO UI
-# ==============================
+# ==========================================
 SAMPLE_TEXT = """Chapter 1: The Beginning
 
-The old lighthouse stood at the edge of the world, or so it seemed to the girl who had lived in its shadow all her life. Each morning, she would climb the winding iron staircase to the lamp room, counting exactly one hundred and forty-seven steps, and watch the sun rise from the sea like a great golden coin tossed by the gods.
-
-"One day," she whispered to the seagulls that perched on the railing, "I'll follow that sun to wherever it goes."
+The old lighthouse stood at the edge of the world, or so it seemed to the girl who had lived in its shadow all her life. Each morning, she would climb the winding iron staircase to the lamp room, counting exactly one hundred and forty-seven steps, and watch the sun rise from the sea like a great golden coin.
 
-The gulls, as always, said nothing. They merely tilted their heads and regarded her with ancient, knowing eyes before launching themselves into the wind.
+"One day," she whispered to the seagulls, "I'll follow that sun to wherever it goes."
 
-Her name was Elena, and she was seventeen years old. She had hair the color of dark honey and eyes that changed with the weather - grey in storms, green in sunlight, and something altogether different in the strange purple twilight that sometimes settled over the coast in autumn.
+Her name was Elena, and she was seventeen years old. She had hair the color of dark honey and eyes that changed with the weather - grey in storms, green in sunlight.
 
-The lighthouse keeper, her grandfather, was a man of few words but many stories. He kept them locked away like treasures in a chest, only bringing them out on winter nights when the storms howled outside and the old building trembled like a living thing.
+The lighthouse keeper, her grandfather, was a man of few words but many stories. He kept them locked away like treasures in a chest, only bringing them out on winter nights when the storms howled outside.
 
 "Tell me about the ships," Elena would say, curling up in the worn armchair by the fire.
 
@@ -663,111 +659,127 @@ And he would smile - that slow, careful smile that seemed to cost him something
 
 DESCRIPTION = """
 # Audiobook Generator
-### English Text to Multi-Language Audiobook with Voice Cloning
+### English Text to Multi-Language Audiobook
+**Three Voice Engines**
 
-Upload English text and generate a narrated audiobook in **selected languages**.
-Choose a **preset voice** or **clone any voice** from a short audio sample!
+| Engine | Languages | Best for |
+|--------|-----------|----------|
+| **Qwen Preset** (20 voices) | English, Chinese, Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian, Arabic | General audiobooks |
+| **Qwen Clone** (your voice) | Same 10 core (excl. Arabic) | Personalized narration |
+| **YourVoic** (1000+ emotional voices) | African: Afrikaans, Amharic, Swahili. Indian: Hindi, Marathi, Bengali, Telugu, Tamil + 16 more. South Asian: Urdu, Nepali, Sinhala | Indian/African languages, emotional narration |
 
+The app automatically selects the right engine based on your chosen language. Or pick manually!
 """
 
+# Build language dropdown grouped by engine
 lang_choices = []
-for name, cfg in LANGUAGES.items():
-    if cfg["tier"] == "core":
-        lang_choices.append(f"* {name}")
-for name, cfg in LANGUAGES.items():
-    if cfg["tier"] == "extended":
-        lang_choices.append(name)
+# Qwen languages first (starred)
+for name in LANGUAGES:
+    if LANGUAGES[name]["engine"] == "qwen":
+        lang_choices.append(f"Q: {name}")
+# African languages
+for name in ["Afrikaans", "Amharic", "Swahili"]:
+    if name in LANGUAGES:
+        lang_choices.append(f"YV: {name}")
+# Indian languages
+for name in ["Hindi", "Marathi", "Bengali", "Telugu", "Tamil", "Gujarati", "Kannada",
+             "Malayalam", "Punjabi", "Odia", "Assamese", "Maithili", "Kashmiri",
+             "Sindhi", "Konkani", "Dogri", "Manipuri", "Bodo", "Sanskrit"]:
+    if name in LANGUAGES:
+        lang_choices.append(f"YV: {name}")
+# South Asian
+for name in ["Urdu", "Nepali", "Sinhala"]:
+    if name in LANGUAGES:
+        lang_choices.append(f"YV: {name}")
 
 
 def clean_language_name(choice):
-    return choice.replace("* ", "").strip()
+    return choice.replace("Q: ", "").replace("YV: ", "").replace("* ", "").strip()
+
+
+def auto_select_engine(language_name):
+    """Auto-select the right voice engine based on language."""
+    if language_name in LANGUAGES:
+        return LANGUAGES[language_name]["engine"]
+    return "qwen"
 
 
 def on_voice_mode_change(mode):
     if mode == "Clone a Voice":
-        return gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
+        return (gr.update(visible=False), gr.update(visible=True), gr.update(visible=True),
+                gr.update(visible=False), gr.update(visible=False), gr.update(visible=False))
+    elif mode == "YourVoic (Emotional AI)":
+        return (gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+                gr.update(visible=True), gr.update(visible=True), gr.update(visible=True))
+    else:  # Preset Voice
+        return (gr.update(visible=True), gr.update(visible=False), gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=False), gr.update(visible=False))
+
+
+def on_language_change(lang_choice):
+    """Auto-switch voice engine when language changes."""
+    lang = clean_language_name(lang_choice)
+    engine = auto_select_engine(lang)
+    if engine == "yourvoic":
+        return gr.update(value="YourVoic (Emotional AI)")
     else:
-        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+        return gr.update(value="Preset Voice")
 
 
 def generate_wrapper(text_input, file_input, language_choice, voice_mode,
-                     preset_voice, clone_audio, add_pauses, progress=gr.Progress()):
+                     preset_voice, clone_audio, yv_voice, yv_model, yv_emotion,
+                     add_pauses, progress=gr.Progress()):
     language = clean_language_name(language_choice)
     return generate_audiobook(
         text_input, file_input, language, voice_mode,
-        preset_voice, clone_audio, add_pauses, progress,
+        preset_voice, clone_audio, yv_voice, yv_model, yv_emotion,
+        add_pauses, progress,
     )
 
 
-with gr.Blocks(
-    title="Audiobook Generator",
-    theme=gr.themes.Soft(
-        primary_hue="indigo",
-        secondary_hue="purple",
-        neutral_hue="slate",
-    ),
-) as demo:
+with gr.Blocks(title="Audiobook Generator") as demo:
 
     gr.Markdown(DESCRIPTION)
 
     with gr.Row():
         with gr.Column(scale=1):
-            text_input = gr.Textbox(
-                label="English Text",
-                placeholder="Paste your English text here...",
-                lines=10,
-                max_lines=25,
-            )
-            file_input = gr.File(
-                label="Or Upload a Document (.txt, .md, .pdf, .docx)",
-                file_types=[".txt", ".md", ".text", ".pdf", ".docx", ".doc"],
-                type="filepath",
-            )
+            text_input = gr.Textbox(label="English Text", placeholder="Paste your English text here...",
+                                    lines=10, max_lines=25)
+            file_input = gr.File(label="Or Upload (.txt, .md, .pdf, .docx)",
+                                 file_types=[".txt", ".md", ".text", ".pdf", ".docx", ".doc"], type="filepath")
             sample_btn = gr.Button("Load Sample Text", variant="secondary", size="sm")
 
-            target_lang = gr.Dropdown(
-                choices=lang_choices,
-                value="* English",
-                label="Target Language",
-                info="* = Core (best quality). Voice cloning supports core languages only.",
-            )
+            target_lang = gr.Dropdown(choices=lang_choices, value="Q: English", label="Target Language",
+                                      info="Q: = Qwen engine, YV: = YourVoic engine. Auto-switches voice engine.")
 
             voice_mode = gr.Radio(
-                choices=["Preset Voice", "Clone a Voice"],
-                value="Preset Voice",
-                label="Voice Mode",
-            )
-
-            preset_voice = gr.Dropdown(
-                choices=PRESET_VOICES,
-                value="Jennifer -- Cinematic narrator",
-                label="Preset Narrator Voice",
-                visible=True,
+                choices=["Preset Voice", "Clone a Voice", "YourVoic (Emotional AI)"],
+                value="Preset Voice", label="Voice Engine",
             )
 
-            clone_audio = gr.Audio(
-                label="Upload Voice Sample (10 seconds to 3 minutes, WAV/MP3/M4A)",
-                type="filepath",
-                visible=False,
-            )
+            # Preset voice controls
+            preset_voice = gr.Dropdown(choices=PRESET_VOICES, value="Jennifer -- Cinematic narrator",
+                                       label="Qwen Preset Voice", visible=True)
 
+            # Clone voice controls
+            clone_audio = gr.Audio(label="Voice Sample (10s-3min)", type="filepath", visible=False)
             clone_info = gr.Markdown(
-                value=(
-                    "> **Voice cloning tips:**\n"
-                    "> - Use 10 seconds to 3 minutes of clear, single-speaker audio\n"
-                    "> - Longer samples give better voice quality (auto-trimmed to best 60s)\n"
-                    "> - No background music or noise\n"
-                    "> - WAV (16-bit), MP3, or M4A format\n"
-                    "> - Cloned voice TTS supports 10 core languages only"
-                ),
+                value=("> **Voice cloning tips:** 10-180s clear speech, no background noise. "
+                       "Supports 10 core languages only."),
                 visible=False,
             )
 
-            add_pauses = gr.Checkbox(
-                value=True,
-                label="Add pauses between sections",
-                info="1.5s silence between chunks",
-            )
+            # YourVoic controls
+            yv_voice = gr.Dropdown(choices=YOURVOIC_VOICES, value="Peter -- English, Professional male",
+                                   label="YourVoic Voice", visible=False, allow_custom_value=True,
+                                   info="Type any voice name or pick from the list")
+            yv_model = gr.Dropdown(choices=YOURVOIC_MODELS, value="aura-max -- Premium quality (best for audiobooks)",
+                                   label="YourVoic Model", visible=False)
+            yv_emotion = gr.Dropdown(choices=YOURVOIC_EMOTIONS, value="friendly",
+                                     label="Emotion Style", visible=False,
+                                     info="Add emotional expression to the narration")
+
+            add_pauses = gr.Checkbox(value=True, label="Add pauses between sections", info="1.5s silence between chunks")
 
             generate_btn = gr.Button("Generate Audiobook", variant="primary", size="lg")
 
@@ -779,22 +791,29 @@ with gr.Blocks(
 
     sample_btn.click(fn=lambda: SAMPLE_TEXT, outputs=text_input)
 
+    # Auto-switch voice engine when language changes
+    target_lang.change(fn=on_language_change, inputs=target_lang, outputs=[voice_mode])
+
     voice_mode.change(
-        fn=on_voice_mode_change,
-        inputs=voice_mode,
-        outputs=[preset_voice, clone_audio, clone_info],
+        fn=on_voice_mode_change, inputs=voice_mode,
+        outputs=[preset_voice, clone_audio, clone_info, yv_voice, yv_model, yv_emotion],
     )
 
     generate_btn.click(
         fn=generate_wrapper,
         inputs=[text_input, file_input, target_lang, voice_mode,
-                preset_voice, clone_audio, add_pauses],
+                preset_voice, clone_audio, yv_voice, yv_model, yv_emotion, add_pauses],
         outputs=[audio_output, stats_output, transcript_output],
     )
 
     gr.Markdown(
         "---\n"
-        
+        "**Engines:**\n\n"
+        "**Qwen Preset:** 11 languages (EN, ZH, JA, KO, DE, FR, RU, PT, ES, IT, AR) via Qwen3.5-Omni-Plus\n\n"
+        "**Qwen Clone:** 10 languages (same minus Arabic) via Qwen3-TTS-VC\n\n"
+        "**YourVoic:** African (Afrikaans, Amharic, Swahili) + Indian (Hindi, Tamil, Telugu + 17 more) "
+        "+ South Asian (Urdu, Nepali, Sinhala) via YourVoic API with emotional voices\n\n"
+        "Built with Gradio | Qwen by Alibaba | YourVoic by YourVoic Private Limited"
     )
 
 if __name__ == "__main__":