Upload 4 files

README.md

@@ -12,18 +12,19 @@ license: apache-2.0
 
 # Qwen3-TTS Demo
 
-Open-source text-to-speech with three modes:
+Open-source text-to-speech with four modes:
 
 1. **Custom Voice** - Pick a preset speaker with optional emotion instructions
 2. **Voice Design** - Describe any voice in natural language and the AI creates it
 3. **Voice Clone** - Clone a voice from a 3-second audio sample
+4. **Multi-Speaker Story** - Auto-detect characters, assign voices, add emotions, generate full audiobook
 
 ## Setup
 
-No API keys needed. The models load automatically from HuggingFace.
-
 Hardware: Requires GPU (runs on ZeroGPU for free on HF Spaces).
 
+Optional: Add DASHSCOPE_API_KEY in Secrets for the Multi-Speaker Story mode (character detection + emotion analysis).
+
 ## Supported Languages
 
 English, Chinese, Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian

app.py

@@ -1,11 +1,17 @@
 """
 Qwen3-TTS Demo — Self-hosted Text-to-Speech
-Three modes: Custom Voice, Voice Design, Voice Clone
+Modes: Custom Voice, Voice Design, Voice Clone, Multi-Speaker Story
 Runs on HF Spaces with ZeroGPU (free)
 """
 
 import os
+import json
+import re
 import tempfile
+import subprocess
+import shutil
+import struct
+
 import torch
 import spaces
 import gradio as gr
@@ -13,14 +19,44 @@ import soundfile as sf
 
 from qwen_tts import Qwen3TTSModel
 
+# Optional: DashScope for smart character detection + emotion injection
+try:
+    from openai import OpenAI
+    HAS_OPENAI = True
+except ImportError:
+    HAS_OPENAI = False
+
+# ==========================================
+# CONFIG
+# ==========================================
+OMNI_MODEL = "qwen3.5-omni-plus"
+DASHSCOPE_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+
+LANGUAGES = ["Auto", "English", "Chinese", "Japanese", "Korean", "German",
+             "French", "Russian", "Portuguese", "Spanish", "Italian"]
+
+SPEAKERS = {
+    "Vivian": {"desc": "Bright, edgy young female", "lang": "Chinese", "gender": "female"},
+    "Serena": {"desc": "Warm, gentle young female", "lang": "Chinese", "gender": "female"},
+    "Uncle_Fu": {"desc": "Seasoned male, low mellow timbre", "lang": "Chinese", "gender": "male"},
+    "Dylan": {"desc": "Youthful Beijing male, clear natural", "lang": "Chinese", "gender": "male"},
+    "Eric": {"desc": "Lively Chengdu male, slightly husky", "lang": "Chinese", "gender": "male"},
+    "Ryan": {"desc": "Dynamic male, strong rhythmic drive", "lang": "English", "gender": "male"},
+    "Aiden": {"desc": "Sunny American male, clear midrange", "lang": "English", "gender": "male"},
+    "Ono_Anna": {"desc": "Playful Japanese female, light nimble", "lang": "Japanese", "gender": "female"},
+    "Sohee": {"desc": "Warm Korean female, rich emotion", "lang": "Korean", "gender": "female"},
+}
+
+SPEAKER_CHOICES = [f"{name} -- {info['desc']} ({info['lang']})" for name, info in SPEAKERS.items()]
+MALE_SPEAKERS = [n for n, s in SPEAKERS.items() if s["gender"] == "male"]
+FEMALE_SPEAKERS = [n for n, s in SPEAKERS.items() if s["gender"] == "female"]
+
 # ==========================================
 # MODEL LOADING
 # ==========================================
-# Models are loaded on-demand per mode to save VRAM
 _models = {}
 
 def get_model(model_type):
-    """Load model lazily. Models share the tokenizer so memory is manageable."""
     if model_type not in _models:
         model_map = {
             "custom": "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice",
@@ -37,215 +73,482 @@ def get_model(model_type):
     return _models[model_type]
 
 
-# ==========================================
-# CONFIG
-# ==========================================
-LANGUAGES = ["Auto", "English", "Chinese", "Japanese", "Korean", "German",
-             "French", "Russian", "Portuguese", "Spanish", "Italian"]
+def get_llm_client():
+    ds_key = os.environ.get("DASHSCOPE_API_KEY", "")
+    if ds_key and HAS_OPENAI:
+        return OpenAI(api_key=ds_key, base_url=DASHSCOPE_BASE_URL)
+    return None
 
-SPEAKERS = {
-    "Vivian": "Bright, edgy young female (Chinese)",
-    "Serena": "Warm, gentle young female (Chinese)",
-    "Uncle_Fu": "Seasoned male, low mellow timbre (Chinese)",
-    "Dylan": "Youthful Beijing male, clear natural (Chinese)",
-    "Eric": "Lively Chengdu male, slightly husky (Chinese/Sichuan)",
-    "Ryan": "Dynamic male, strong rhythmic drive (English)",
-    "Aiden": "Sunny American male, clear midrange (English)",
-    "Ono_Anna": "Playful Japanese female, light nimble (Japanese)",
-    "Sohee": "Warm Korean female, rich emotion (Korean)",
-}
-
-SPEAKER_CHOICES = [f"{name} -- {desc}" for name, desc in SPEAKERS.items()]
 
-EMOTION_EXAMPLES = [
-    "Very happy and excited",
-    "Speak sadly, with a heavy heart",
-    "Whisper softly and mysteriously",
-    "Angry and frustrated tone",
-    "Calm, warm bedtime story narrator",
-    "Professional news anchor delivery",
-    "Dramatic storytelling with suspense",
-]
+# ==========================================
+# AUDIO HELPERS
+# ==========================================
+def concatenate_wavs(wav_files, output_path):
+    if not wav_files:
+        return
+    if len(wav_files) == 1:
+        shutil.copy2(wav_files[0], output_path)
+        return
+    list_file = output_path + ".txt"
+    with open(list_file, "w") as f:
+        for w in wav_files:
+            f.write(f"file '{w}'\n")
+    subprocess.run(["ffmpeg", "-y", "-f", "concat", "-safe", "0",
+                    "-i", list_file, "-c", "copy", output_path],
+                   capture_output=True, check=True)
+    os.remove(list_file)
+
+
+def generate_silence(dur, path):
+    subprocess.run(["ffmpeg", "-y", "-f", "lavfi", "-i", "anullsrc=r=24000:cl=mono",
+                    "-t", str(dur), "-acodec", "pcm_s16le", path],
+                   capture_output=True, check=True)
 
 
 # ==========================================
-# TTS FUNCTIONS
+# SINGLE-SPEAKER MODES
 # ==========================================
 @spaces.GPU
 def generate_custom_voice(text, language, speaker_label, instruction):
-    """Mode 1: Custom Voice — pick a preset speaker with optional instruction."""
     if not text.strip():
         raise gr.Error("Please enter some text.")
-
     model = get_model("custom")
     speaker = speaker_label.split("--")[0].strip()
     lang = language if language != "Auto" else "Auto"
-
-    kwargs = {
-        "text": text,
-        "language": lang,
-        "speaker": speaker,
-    }
+    kwargs = {"text": text, "language": lang, "speaker": speaker}
     if instruction and instruction.strip():
         kwargs["instruct"] = instruction.strip()
-
-    print(f"[TTS] Custom voice: speaker={speaker}, lang={lang}, instruct={instruction[:50] if instruction else 'none'}")
+    print(f"[TTS] Custom: speaker={speaker}, lang={lang}")
     wavs, sr = model.generate_custom_voice(**kwargs)
-
-    output_path = os.path.join(tempfile.mkdtemp(), "custom_voice.wav")
-    sf.write(output_path, wavs[0], sr)
-    print(f"[TTS] Generated: {output_path}, {len(wavs[0])/sr:.1f}s")
-    return output_path
+    path = os.path.join(tempfile.mkdtemp(), "custom.wav")
+    sf.write(path, wavs[0], sr)
+    return path
 
 
 @spaces.GPU
 def generate_voice_design(text, language, voice_description):
-    """Mode 2: Voice Design — describe the voice you want in natural language."""
     if not text.strip():
         raise gr.Error("Please enter some text.")
     if not voice_description.strip():
         raise gr.Error("Please describe the voice you want.")
-
     model = get_model("design")
     lang = language if language != "Auto" else "Auto"
-
-    print(f"[TTS] Voice design: lang={lang}, desc={voice_description[:80]}")
-    wavs, sr = model.generate_voice_design(
-        text=text,
-        language=lang,
-        instruct=voice_description,
-    )
-
-    output_path = os.path.join(tempfile.mkdtemp(), "voice_design.wav")
-    sf.write(output_path, wavs[0], sr)
-    print(f"[TTS] Generated: {output_path}, {len(wavs[0])/sr:.1f}s")
-    return output_path
+    print(f"[TTS] Design: lang={lang}, desc={voice_description[:60]}")
+    wavs, sr = model.generate_voice_design(text=text, language=lang, instruct=voice_description)
+    path = os.path.join(tempfile.mkdtemp(), "design.wav")
+    sf.write(path, wavs[0], sr)
+    return path
 
 
 @spaces.GPU
 def generate_voice_clone(text, language, ref_audio, ref_text):
-    """Mode 3: Voice Clone — clone a voice from a 3+ second audio sample."""
     if not text.strip():
         raise gr.Error("Please enter some text.")
     if ref_audio is None:
         raise gr.Error("Please upload a reference audio sample.")
-
     model = get_model("clone")
     lang = language if language != "Auto" else "Auto"
+    kwargs = {"text": text, "language": lang, "ref_audio": ref_audio}
+    if ref_text and ref_text.strip():
+        kwargs["ref_text"] = ref_text.strip()
+    else:
+        kwargs["x_vector_only_mode"] = True
+    print(f"[TTS] Clone: lang={lang}")
+    wavs, sr = model.generate_voice_clone(**kwargs)
+    path = os.path.join(tempfile.mkdtemp(), "clone.wav")
+    sf.write(path, wavs[0], sr)
+    return path
+
+
+# ==========================================
+# MULTI-SPEAKER: Character Detection + Emotion
+# ==========================================
+def detect_characters_and_emotions(client, text):
+    """Use AI to detect characters, split segments, and add emotion instructions."""
+    response = client.chat.completions.create(
+        model=OMNI_MODEL, modalities=["text"],
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    "You are an audiobook director. Analyze this story text and:\n"
+                    "1. Identify all characters (including a Narrator for non-dialogue)\n"
+                    "2. Detect each character's gender\n"
+                    "3. Split the text into segments by speaker\n"
+                    "4. For each segment, add an emotion/delivery instruction for the voice actor\n\n"
+                    "Output ONLY valid JSON:\n"
+                    "{\n"
+                    '  "characters": [\n'
+                    '    {"name": "Narrator", "gender": "neutral"},\n'
+                    '    {"name": "Elena", "gender": "female"},\n'
+                    '    {"name": "Grandfather", "gender": "male"}\n'
+                    "  ],\n"
+                    '  "segments": [\n'
+                    '    {"speaker": "Narrator", "text": "The lighthouse stood tall.", "emotion": "Calm, atmospheric storytelling tone"},\n'
+                    '    {"speaker": "Elena", "text": "One day I will leave.", "emotion": "Wistful, dreamy, with quiet determination"},\n'
+                    '    {"speaker": "Narrator", "text": "The old man smiled.", "emotion": "Warm, gentle narration"}\n'
+                    "  ]\n"
+                    "}\n\n"
+                    "Rules:\n"
+                    "- Narrator handles all non-dialogue text\n"
+                    "- Emotion should describe HOW to speak: tone, mood, energy, pacing\n"
+                    "- Be specific with emotions: not just 'sad' but 'quietly heartbroken, voice barely above a whisper'\n"
+                    "- Match emotions to the story context\n"
+                    "- Include ALL text, do not skip anything\n"
+                    "- Merge consecutive segments by the same speaker\n"
+                    "- Output ONLY JSON, no markdown, no backticks"
+                ),
+            },
+            {"role": "user", "content": f"Direct this story:\n\n{text[:8000]}"},
+        ],
+    )
+
+    raw = response.choices[0].message.content.strip()
+    raw = re.sub(r'^```json\s*', '', raw)
+    raw = re.sub(r'\s*```$', '', raw)
+
+    try:
+        data = json.loads(raw)
+        return data.get("characters", []), data.get("segments", [])
+    except json.JSONDecodeError as e:
+        print(f"[MultiSpeaker] JSON parse failed: {e}\n{raw[:500]}")
+        return [{"name": "Narrator", "gender": "neutral"}], [{"speaker": "Narrator", "text": text, "emotion": "Calm narration"}]
+
+
+def assign_voices(characters):
+    """Auto-assign voices to characters based on gender."""
+    voice_map = {}
+    male_idx, female_idx = 0, 0
+
+    for char in characters:
+        name = char["name"]
+        gender = char.get("gender", "neutral")
+
+        if name == "Narrator":
+            voice_map[name] = {"speaker": "Ryan", "type": "custom"}
+        elif gender == "male":
+            voice_map[name] = {"speaker": MALE_SPEAKERS[male_idx % len(MALE_SPEAKERS)], "type": "custom"}
+            male_idx += 1
+        elif gender == "female":
+            voice_map[name] = {"speaker": FEMALE_SPEAKERS[female_idx % len(FEMALE_SPEAKERS)], "type": "custom"}
+            female_idx += 1
+        else:
+            voice_map[name] = {"speaker": "Ryan", "type": "custom"}
+
+    return voice_map
+
+
+@spaces.GPU
+def generate_segment_audio(text, language, speaker, emotion, seg_idx, tmp_dir):
+    """Generate audio for a single segment with emotion instruction."""
+    model = get_model("custom")
+    lang = language if language != "Auto" else "Auto"
 
     kwargs = {
         "text": text,
         "language": lang,
-        "ref_audio": ref_audio,
+        "speaker": speaker,
     }
-    if ref_text and ref_text.strip():
-        kwargs["ref_text"] = ref_text.strip()
+    if emotion and emotion.strip():
+        kwargs["instruct"] = emotion.strip()
+
+    try:
+        wavs, sr = model.generate_custom_voice(**kwargs)
+        path = os.path.join(tmp_dir, f"seg_{seg_idx:04d}.wav")
+        sf.write(path, wavs[0], sr)
+        return path, None
+    except Exception as e:
+        return None, str(e)
+
+
+def generate_multi_speaker_story(text_input, file_input, language, progress=gr.Progress()):
+    """Full multi-speaker pipeline with auto character detection and emotions."""
+    # Resolve text
+    if file_input is not None:
+        ext = os.path.splitext(file_input)[1].lower()
+        if ext == ".pdf":
+            try:
+                import pypdf
+                reader = pypdf.PdfReader(file_input)
+                text = "\n\n".join(p.extract_text().strip() for p in reader.pages if p.extract_text())
+            except Exception as e:
+                raise gr.Error(f"PDF read failed: {e}")
+        elif ext == ".docx":
+            try:
+                import docx
+                doc = docx.Document(file_input)
+                text = "\n\n".join(p.text.strip() for p in doc.paragraphs if p.text.strip())
+            except Exception as e:
+                raise gr.Error(f"DOCX read failed: {e}")
+        else:
+            with open(file_input, "r", encoding="utf-8", errors="replace") as f:
+                text = f.read()
+    elif text_input and text_input.strip():
+        text = text_input.strip()
     else:
-        kwargs["x_vector_only_mode"] = True
+        raise gr.Error("Please provide a story text.")
 
-    print(f"[TTS] Voice clone: lang={lang}, ref_text={'yes' if ref_text else 'speaker-embed only'}")
-    wavs, sr = model.generate_voice_clone(**kwargs)
+    if len(text) < 30:
+        raise gr.Error("Text too short for multi-speaker generation.")
+
+    # Check for LLM client
+    client = get_llm_client()
+    if not client:
+        raise gr.Error(
+            "DASHSCOPE_API_KEY needed for character detection and emotion analysis. "
+            "Add it in Settings > Secrets."
+        )
+
+    tmp_dir = tempfile.mkdtemp(prefix="multispeaker_")
+
+    # Step 1: Detect characters and emotions
+    progress(0.05, desc="Analyzing story characters and emotions...")
+    characters, segments = detect_characters_and_emotions(client, text)
+    print(f"[MultiSpeaker] {len(characters)} characters, {len(segments)} segments")
+
+    # Step 2: Assign voices
+    voice_map = assign_voices(characters)
+    print(f"[MultiSpeaker] Voice map: { {k: v['speaker'] for k, v in voice_map.items()} }")
+
+    # Step 3: Generate audio per segment
+    audio_files = []
+    all_transcripts = []
+    total = len(segments)
+
+    # Create pause files
+    speaker_pause = os.path.join(tmp_dir, "sp.wav")
+    section_pause = os.path.join(tmp_dir, "sec.wav")
+    generate_silence(0.4, speaker_pause)
+    generate_silence(1.0, section_pause)
+
+    prev_speaker = None
+
+    for i, seg in enumerate(segments):
+        frac = 0.10 + 0.80 * (i / max(total, 1))
+        speaker_name = seg.get("speaker", "Narrator")
+        seg_text = seg.get("text", "").strip()
+        emotion = seg.get("emotion", "")
+
+        if not seg_text:
+            continue
+
+        voice_info = voice_map.get(speaker_name, voice_map.get("Narrator", {"speaker": "Ryan"}))
+        progress(frac, desc=f"[{speaker_name}] Segment {i+1}/{total}...")
+
+        # Pause between different speakers
+        if prev_speaker and prev_speaker != speaker_name:
+            audio_files.append(speaker_pause)
+
+        # Split long segments
+        if len(seg_text) > 1500:
+            sub_texts = []
+            sentences = re.split(r'(?<=[.!?])\s+', seg_text)
+            current = ""
+            for s in sentences:
+                if len(current) + len(s) + 1 <= 1500:
+                    current = (current + " " + s).strip()
+                else:
+                    if current:
+                        sub_texts.append(current)
+                    current = s
+            if current:
+                sub_texts.append(current)
+        else:
+            sub_texts = [seg_text]
+
+        for j, sub in enumerate(sub_texts):
+            seg_idx = i * 100 + j
+            wav_path, error = generate_segment_audio(
+                sub, language, voice_info["speaker"], emotion, seg_idx, tmp_dir
+            )
+            if wav_path:
+                audio_files.append(wav_path)
+            else:
+                print(f"[MultiSpeaker] Seg {i} failed: {error}")
+                fail = os.path.join(tmp_dir, f"fail_{seg_idx}.wav")
+                generate_silence(1.5, fail)
+                audio_files.append(fail)
+                all_transcripts.append(f"**[{speaker_name}]** FAILED: {error}")
+
+        emotion_tag = f" *({emotion})*" if emotion else ""
+        all_transcripts.append(f"**[{speaker_name}]**{emotion_tag} {seg_text[:200]}{'...' if len(seg_text) > 200 else ''}")
+
+        # Section pause
+        if i < total - 1:
+            audio_files.append(section_pause)
+
+        prev_speaker = speaker_name
+
+    if not audio_files:
+        raise gr.Error("No audio generated.")
+
+    # Step 4: Assemble
+    progress(0.92, desc="Assembling audiobook...")
+    final_wav = os.path.join(tmp_dir, "story.wav")
+    concatenate_wavs(audio_files, final_wav)
+
+    progress(0.96, desc="Converting to MP3...")
+    final_mp3 = os.path.join(tmp_dir, "story.mp3")
+    subprocess.run(["ffmpeg", "-y", "-i", final_wav, "-codec:a", "libmp3lame",
+                    "-b:a", "128k", "-ar", "24000", "-ac", "1", final_mp3],
+                   capture_output=True, check=True)
+
+    progress(1.0, desc="Done!")
+
+    # Stats
+    size_mb = os.path.getsize(final_mp3) / (1024 * 1024)
+    cast = "\n".join(f"  - **{c['name']}** ({c.get('gender', '?')}) → {voice_map.get(c['name'], {}).get('speaker', '?')}"
+                     for c in characters)
+    stats = (
+        f"**Multi-Speaker Story Generated!**\n\n"
+        f"- **Segments:** {total}\n"
+        f"- **Characters:** {len(characters)}\n"
+        f"- **File size:** {size_mb:.1f} MB\n\n"
+        f"**Cast:**\n{cast}\n"
+    )
+    transcript = "\n\n".join(all_transcripts)
 
-    output_path = os.path.join(tempfile.mkdtemp(), "voice_clone.wav")
-    sf.write(output_path, wavs[0], sr)
-    print(f"[TTS] Generated: {output_path}, {len(wavs[0])/sr:.1f}s")
-    return output_path
+    return final_mp3, stats, transcript
 
 
 # ==========================================
 # GRADIO UI
 # ==========================================
+SAMPLE_STORY = """Chapter 1: The Lighthouse
+
+The old lighthouse stood at the edge of the world. Each morning, Elena climbed one hundred and forty-seven iron steps to the lamp room and watched the sun rise from the sea.
+
+"One day," she whispered to the seagulls, "I'll follow that sun to wherever it goes."
+
+The gulls said nothing. They merely tilted their heads and launched themselves into the wind.
+
+Her grandfather was a man of few words but many stories.
+
+"Tell me about the ships," Elena would say, curling up in the worn armchair by the fire.
+
+And he would smile that slow, careful smile and begin: "There was a ship once, long ago, that sailed beyond the edge of every map. Its captain was a woman with eyes like starlight and a voice that could calm any storm."
+
+"What happened to her?" Elena asked, leaning forward.
+
+"She found what she was looking for," her grandfather said quietly. "But the price was higher than she imagined."
+
+Elena stared into the fire. "Would you pay it? The price, I mean."
+
+The old man was silent for a long time. "I already did," he finally whispered. "I already did."
+"""
+
 DESCRIPTION = """
 # Qwen3-TTS Demo
-### Open-Source Text-to-Speech (1.7B)
-
-Three modes for generating speech:
+### Open-Source Text-to-Speech (1.7B) — Self-Hosted, No API Keys for TTS
 
 | Mode | What it does |
 |------|-------------|
-| **Custom Voice** | Pick a preset voice + optional emotion/style instruction |
-| **Voice Design** | Describe the voice you want in plain English |
-| **Voice Clone** | Clone any voice from a 3-second audio sample |
+| **Custom Voice** | Pick a preset voice + optional emotion instruction |
+| **Voice Design** | Describe any voice in natural language |
+| **Voice Clone** | Clone a voice from 3 seconds of audio |
+| **Multi-Speaker Story** | Auto-detect characters, assign voices, add emotions — full audiobook |
 
-Supports 10 languages: English, Chinese, Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian.
-Running on ZeroGPU — completely free.
+10 languages supported. Running on ZeroGPU (free).
 """
 
 with gr.Blocks(title="Qwen3-TTS Demo") as demo:
 
     gr.Markdown(DESCRIPTION)
 
+    # ── Tab 1: Custom Voice ──
     with gr.Tab("Custom Voice"):
-        gr.Markdown("Pick a preset speaker and optionally add emotion/style instructions.")
+        gr.Markdown("Pick a preset speaker with optional emotion/style.")
         with gr.Row():
             with gr.Column():
-                cv_text = gr.Textbox(label="Text to Speak", lines=4,
-                                     placeholder="Enter the text you want spoken...")
+                cv_text = gr.Textbox(label="Text", lines=4, placeholder="Enter text...")
                 cv_lang = gr.Dropdown(choices=LANGUAGES, value="Auto", label="Language")
                 cv_speaker = gr.Dropdown(choices=SPEAKER_CHOICES,
                                          value="Ryan -- Dynamic male, strong rhythmic drive (English)",
                                          label="Speaker")
-                cv_instruct = gr.Textbox(label="Emotion / Style Instruction (optional)",
-                                         placeholder="e.g. Very happy and excited, Speak sadly, Whisper softly...")
+                cv_instruct = gr.Textbox(label="Emotion / Style (optional)",
+                                         placeholder="e.g. Very happy, Whisper softly, Speak with authority...")
                 cv_btn = gr.Button("Generate", variant="primary")
             with gr.Column():
                 cv_audio = gr.Audio(label="Generated Speech", type="filepath")
-
         cv_btn.click(fn=generate_custom_voice,
-                     inputs=[cv_text, cv_lang, cv_speaker, cv_instruct],
-                     outputs=cv_audio)
+                     inputs=[cv_text, cv_lang, cv_speaker, cv_instruct], outputs=cv_audio)
 
+    # ── Tab 2: Voice Design ──
     with gr.Tab("Voice Design"):
-        gr.Markdown("Describe the voice you want in natural language — the AI creates it from scratch.")
+        gr.Markdown("Describe the voice you want — the AI creates it.")
         with gr.Row():
             with gr.Column():
-                vd_text = gr.Textbox(label="Text to Speak", lines=4,
-                                     placeholder="Enter the text you want spoken...")
+                vd_text = gr.Textbox(label="Text", lines=4, placeholder="Enter text...")
                 vd_lang = gr.Dropdown(choices=LANGUAGES, value="English", label="Language")
                 vd_desc = gr.Textbox(label="Voice Description", lines=3,
-                                     placeholder="e.g. Warm, captivating storyteller with a slight British accent, male...")
+                                     placeholder="e.g. Warm male storyteller with British accent...")
                 gr.Examples(
-                    examples=[[ex] for ex in [
-                        "Warm, captivating male storyteller with a slight British accent",
-                        "Young energetic female voice, cheerful and bright, American",
-                        "Deep authoritative male voice, news anchor style, very clear",
-                        "Gentle elderly grandmother voice, kind and soothing",
-                        "Speak in an incredulous tone with panic creeping into the voice",
-                    ]],
-                    inputs=[vd_desc],
-                    label="Example Descriptions",
+                    examples=[
+                        ["Warm, captivating male storyteller with a slight British accent"],
+                        ["Young energetic female, cheerful and bright, American"],
+                        ["Deep authoritative male, news anchor style"],
+                        ["Gentle elderly grandmother, kind and soothing"],
+                        ["Speak with panic creeping into the voice, incredulous"],
+                    ],
+                    inputs=[vd_desc], label="Examples",
                 )
                 vd_btn = gr.Button("Generate", variant="primary")
             with gr.Column():
                 vd_audio = gr.Audio(label="Generated Speech", type="filepath")
-
         vd_btn.click(fn=generate_voice_design,
-                     inputs=[vd_text, vd_lang, vd_desc],
-                     outputs=vd_audio)
+                     inputs=[vd_text, vd_lang, vd_desc], outputs=vd_audio)
 
+    # ── Tab 3: Voice Clone ──
     with gr.Tab("Voice Clone"):
-        gr.Markdown("Clone any voice from a short audio sample (3+ seconds). Provide the transcript for best quality.")
+        gr.Markdown("Clone any voice from a short audio sample (3+ seconds).")
         with gr.Row():
             with gr.Column():
-                vc_text = gr.Textbox(label="Text to Speak (in the cloned voice)", lines=4,
-                                     placeholder="Enter what you want the cloned voice to say...")
+                vc_text = gr.Textbox(label="Text (in cloned voice)", lines=4, placeholder="What should the cloned voice say...")
                 vc_lang = gr.Dropdown(choices=LANGUAGES, value="English", label="Language")
-                vc_ref_audio = gr.Audio(label="Reference Audio (3+ seconds)", type="filepath")
-                vc_ref_text = gr.Textbox(label="Transcript of Reference Audio (optional, improves quality)",
-                                         placeholder="Type what the person says in the reference audio...")
+                vc_ref = gr.Audio(label="Reference Audio (3+ seconds)", type="filepath")
+                vc_ref_text = gr.Textbox(label="Transcript (optional, improves quality)",
+                                         placeholder="What the person says in the reference...")
                 vc_btn = gr.Button("Clone & Generate", variant="primary")
             with gr.Column():
-                vc_audio = gr.Audio(label="Generated Speech (Cloned Voice)", type="filepath")
-
+                vc_audio = gr.Audio(label="Cloned Voice Speech", type="filepath")
         vc_btn.click(fn=generate_voice_clone,
-                     inputs=[vc_text, vc_lang, vc_ref_audio, vc_ref_text],
-                     outputs=vc_audio)
+                     inputs=[vc_text, vc_lang, vc_ref, vc_ref_text], outputs=vc_audio)
+
+    # ── Tab 4: Multi-Speaker Story ──
+    with gr.Tab("Multi-Speaker Story"):
+        gr.Markdown(
+            "Paste a story with dialogue and the AI automatically:\n"
+            "1. Detects all characters and their genders\n"
+            "2. Assigns unique voices (male/female matched)\n"
+            "3. Adds emotion instructions per line (sad, whispered, excited...)\n"
+            "4. Generates the full audiobook with different voices\n\n"
+            "*Requires DASHSCOPE_API_KEY for character/emotion analysis. TTS is local.*"
+        )
+        with gr.Row():
+            with gr.Column():
+                ms_text = gr.Textbox(label="Story Text", lines=10, placeholder="Paste your story with dialogue...")
+                ms_file = gr.File(label="Or Upload (.txt, .pdf, .docx)",
+                                  file_types=[".txt", ".md", ".pdf", ".docx"], type="filepath")
+                ms_lang = gr.Dropdown(choices=LANGUAGES, value="English", label="Language")
+                ms_sample = gr.Button("Load Sample Story", variant="secondary", size="sm")
+                ms_btn = gr.Button("Generate Multi-Speaker Audiobook", variant="primary", size="lg")
+            with gr.Column():
+                ms_audio = gr.Audio(label="Multi-Speaker Audiobook", type="filepath")
+                ms_stats = gr.Markdown(label="Cast & Stats")
+                with gr.Accordion("Full Transcript (with emotions)", open=False):
+                    ms_transcript = gr.Markdown()
+
+        ms_sample.click(fn=lambda: SAMPLE_STORY, outputs=ms_text)
+        ms_btn.click(fn=generate_multi_speaker_story,
+                     inputs=[ms_text, ms_file, ms_lang],
+                     outputs=[ms_audio, ms_stats, ms_transcript])
 
     gr.Markdown(
         "---\n"
-        "**Model:** Qwen3-TTS-12Hz-1.7B (Apache 2.0) | "
+        "**Models:** Qwen3-TTS-12Hz-1.7B (Apache 2.0) | "
         "**Languages:** EN, ZH, JA, KO, DE, FR, RU, PT, ES, IT | "
-        "**Running on:** HF Spaces ZeroGPU"
+        "**TTS:** Self-hosted on ZeroGPU | "
+        "**Character Analysis:** Cloud AI (optional, for Multi-Speaker mode)"
     )
 
 if __name__ == "__main__":

packages.txt

@@ -0,0 +1,3 @@
+sox
+ffmpeg
+libsox-fmt-all

requirements.txt

@@ -3,3 +3,6 @@ torch>=2.1.0
 soundfile>=0.12.0
 gradio>=5.25.0
 audioop-lts; python_version >= "3.13"
+openai>=1.52.0
+pypdf>=4.0.0
+python-docx>=1.1.0