Update app.py

app.py

@@ -1,7 +1,5 @@
 # ============================================================
 # CRITICAL: Auto-accept Coqui license - MUST BE FIRST
-# This patches the input() function to automatically answer 'y'
-# to any license prompts from Coqui TTS
 # ============================================================
 import builtins
 
@@ -24,6 +22,8 @@ import tempfile
 import os
 import time
 import numpy as np
+import wave
+import contextlib
 from pathlib import Path
 
 # ============================================================
@@ -42,16 +42,67 @@ _loading_error = None
 _model_downloading = False
 
 # ============================================================
-#  CHECK IF MODEL IS ALREADY DOWNLOADED
+#  AUDIO VALIDATION FUNCTIONS
+# ============================================================
+def get_audio_duration(file_path):
+    """Get duration of WAV file in seconds."""
+    try:
+        with contextlib.closing(wave.open(file_path, 'r')) as f:
+            frames = f.getnframes()
+            rate = f.getframerate()
+            duration = frames / float(rate)
+            return duration
+    except Exception:
+        return 0
+
+def validate_audio_quality(file_path):
+    """Check if audio file has good quality for voice cloning."""
+    try:
+        duration = get_audio_duration(file_path)
+        
+        if duration < 3.0:
+            return False, f"Audio is too short ({duration:.1f} seconds). Minimum 6 seconds recommended."
+        if duration < 6.0:
+            return False, f"Audio is short ({duration:.1f} seconds). For best results, use 6-10 seconds."
+        
+        # Check file size
+        file_size = os.path.getsize(file_path)
+        if file_size < 5000:  # Less than 5KB
+            return False, "Audio file appears to be empty or corrupted."
+        
+        return True, f"Audio duration: {duration:.1f} seconds (good!)"
+        
+    except Exception as e:
+        return False, f"Could not read audio file: {str(e)}"
+
+def check_audio_encoded(file_path):
+    """Check if audio file is properly encoded."""
+    try:
+        # Try to read with soundfile
+        import soundfile as sf
+        data, samplerate = sf.read(file_path)
+        if len(data.shape) == 1:  # Mono
+            pass
+        elif len(data.shape) == 2 and data.shape[1] == 1:  # Mono
+            pass
+        else:
+            return False, "Audio should be mono (single channel). Please convert to mono."
+        
+        if samplerate < 16000:
+            return False, f"Sample rate ({samplerate}Hz) is too low. Use 22050Hz or higher."
+        
+        return True, f"Audio format OK: {samplerate}Hz, mono"
+    except Exception as e:
+        return True, "Could not verify audio format (will try anyway)"
+
+# ============================================================
+#  MODEL LOADING
 # ============================================================
 def is_model_downloaded():
     """Check if the XTTS-v2 model is already downloaded."""
     model_path = os.path.expanduser("~/.local/share/tts/tts_models--multilingual--multi-dataset--xtts_v2")
     return os.path.exists(model_path)
 
-# ============================================================
-#  MODEL LOADING WITH PROGRESS & ERROR HANDLING
-# ============================================================
 def get_tts(progress_callback=None):
     """Lazy-load the XTTS-v2 model with proper error handling."""
     global _tts, _model_loading, _loading_error, _model_downloading
@@ -60,42 +111,36 @@ def get_tts(progress_callback=None):
         return _tts
     
     if _loading_error is not None:
-        raise gr.Error(f"Failed to load TTS model: {_loading_error}")
+        raise Exception(_loading_error)
     
     if _model_loading:
-        raise gr.Error("Model is still loading. Please wait a few seconds and try again.")
+        raise Exception("Model is still loading")
     
     try:
         _model_loading = True
         
-        # Check if model needs to be downloaded
         if not is_model_downloaded():
             _model_downloading = True
             if progress_callback:
-                progress_callback(0.1, desc="📥 Model not found. Downloading 4GB file... (2-5 minutes)")
+                progress_callback(0.1, desc="📥 Downloading 4GB model... (2-5 minutes)")
             print("=" * 60)
-            print("XTTS-v2 model not found. Downloading 4GB model from Hugging Face...")
-            print("This will take 2-5 minutes on first run. Please wait...")
+            print("Downloading XTTS-v2 model (4GB)...")
             print("=" * 60)
         
         from TTS.api import TTS
         
         if progress_callback:
-            progress_callback(0.3, desc="🔄 Loading XTTS-v2 model into memory...")
+            progress_callback(0.3, desc="🔄 Loading model into memory...")
         
-        # Load the multilingual XTTS-v2 model
         _tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=torch.cuda.is_available())
         
-        # Move to GPU if available
         if torch.cuda.is_available():
             _tts.to("cuda")
             if progress_callback:
                 progress_callback(0.8, desc="✅ Model loaded on GPU")
-            print("Model loaded on GPU")
         else:
             if progress_callback:
                 progress_callback(0.8, desc="⚠️ Model loaded on CPU (slower)")
-            print("Model loaded on CPU (synthesis will be slower)")
         
         _model_loading = False
         _model_downloading = False
@@ -105,46 +150,7 @@ def get_tts(progress_callback=None):
         _loading_error = str(e)
         _model_loading = False
         _model_downloading = False
-        raise gr.Error(f"Failed to load TTS model: {str(e)}")
-
-# ============================================================
-#  AUDIO VALIDATION
-# ============================================================
-def validate_audio_file(audio_path):
-    """Check if the uploaded audio file is valid for voice cloning."""
-    if audio_path is None:
-        return False, "No audio file provided."
-    
-    if not os.path.exists(audio_path):
-        return False, "Audio file not found."
-    
-    # Check file size (max 50MB)
-    file_size = os.path.getsize(audio_path)
-    if file_size > 50 * 1024 * 1024:
-        return False, f"Audio file too large ({file_size / 1024 / 1024:.1f}MB). Maximum size: 50MB"
-    
-    # Check file extension
-    if not audio_path.lower().endswith(('.wav', '.mp3', '.m4a', '.flac')):
-        return False, "Audio format not supported. Please upload WAV, MP3, M4A, or FLAC."
-    
-    return True, "Valid audio file."
-
-# ============================================================
-#  TEXT VALIDATION
-# ============================================================
-def validate_text(text):
-    """Validate the input text before synthesis."""
-    if not text or not text.strip():
-        return False, "Please enter some text to synthesize."
-    
-    if len(text) > MAX_TEXT_LENGTH:
-        return False, f"Text exceeds {MAX_TEXT_LENGTH} characters. Current length: {len(text)}"
-    
-    # Check for common issues
-    if len(text.strip()) < 2:
-        return False, "Text is too short. Please enter at least 2 characters."
-    
-    return True, "Valid text."
+        raise Exception(str(e))
 
 # ============================================================
 #  MAIN SYNTHESIS FUNCTION
@@ -156,50 +162,51 @@ def synthesize(
     speed: float = 1.0,
     progress=gr.Progress()
 ):
-    """
-    Synthesize speech using zero-shot voice cloning.
-    
-    Args:
-        text: Text to synthesize (max 2000 chars)
-        reference_audio: Path to reference WAV file (6+ seconds)
-        language: Language code (en, es, fr, de, etc.)
-        speed: Speaking speed (0.5 to 2.0)
-        progress: Gradio progress bar
-    
-    Returns:
-        Path to generated audio file
-    """
-    # Validate inputs
+    """Synthesize speech using zero-shot voice cloning."""
+    
     progress(0, desc="🔍 Validating inputs...")
     
     # Validate text
-    is_valid, error_msg = validate_text(text)
-    if not is_valid:
-        raise gr.Error(error_msg)
+    if not text or not text.strip():
+        raise gr.Error("Please enter some text to synthesize.")
+    
+    if len(text) > MAX_TEXT_LENGTH:
+        raise gr.Error(f"Text exceeds {MAX_TEXT_LENGTH} characters. Current length: {len(text)}")
     
     # Validate audio
-    is_valid, error_msg = validate_audio_file(reference_audio)
+    if reference_audio is None:
+        raise gr.Error("Please upload a reference audio clip of your voice.")
+    
+    if not os.path.exists(reference_audio):
+        raise gr.Error("Reference audio file not found. Please upload again.")
+    
+    # Check audio quality
+    progress(0.05, desc="🔊 Checking audio quality...")
+    is_valid, msg = validate_audio_quality(reference_audio)
     if not is_valid:
-        raise gr.Error(f"Invalid reference audio: {error_msg}")
+        raise gr.Error(msg)
     
-    # Validate language
+    # Show audio info to user
+    print(f"Audio info: {msg}")
+    
+    # Check language
     if language not in SUPPORTED_LANGUAGES:
-        raise gr.Error(f"Unsupported language: {language}. Supported: {', '.join(SUPPORTED_LANGUAGES)}")
+        raise gr.Error(f"Unsupported language: {language}")
     
-    # Validate speed
+    # Check speed
     if speed < 0.5 or speed > 2.0:
         raise gr.Error(f"Speed must be between 0.5 and 2.0. Got: {speed}")
     
     try:
-        # Show download warning if this is first time
+        # Show download warning if first time
         if not is_model_downloaded():
-            progress(0.05, desc="⚠️ FIRST RUN: Downloading 4GB model (2-5 minutes). Please wait...")
+            progress(0.1, desc="⚠️ FIRST RUN: Downloading 4GB model (2-5 minutes)...")
         
-        # Load TTS model with progress callback
-        progress(0.1, desc="🔄 Loading TTS model...")
+        # Load model
+        progress(0.2, desc="🔄 Loading TTS model...")
         tts = get_tts(progress_callback=progress)
         
-        # Create temporary output file
+        # Create output file
         progress(0.4, desc="📝 Preparing synthesis...")
         timestamp = int(time.time())
         output_path = tempfile.NamedTemporaryFile(
@@ -210,39 +217,60 @@ def synthesize(
         # Generate speech
         progress(0.6, desc="🎤 Synthesizing speech (10-30 seconds)...")
         
-        tts.tts_to_file(
-            text=text.strip(),
-            speaker_wav=reference_audio,
-            language=language,
-            file_path=output_path,
-            speed=speed,
-        )
+        # Try different approaches if the first fails
+        try:
+            tts.tts_to_file(
+                text=text.strip(),
+                speaker_wav=reference_audio,
+                language=language,
+                file_path=output_path,
+                speed=speed,
+            )
+        except IndexError as e:
+            if "list index out of range" in str(e):
+                # This usually means the reference audio is problematic
+                raise gr.Error(
+                    "❌ Could not extract voice from reference audio.\n\n"
+                    "Please ensure:\n"
+                    "1. Audio is at least 6 seconds long\n"
+                    "2. Audio contains clear speech (no silence)\n"
+                    "3. Audio is in WAV format with 22050Hz sample rate\n"
+                    "4. There is only one speaker in the audio\n\n"
+                    "Try uploading a different audio clip."
+                )
+            else:
+                raise e
+        except Exception as e:
+            raise e
         
-        # Verify output file was created
+        # Verify output
         progress(0.9, desc="✅ Finalizing...")
         if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
             raise Exception("Output file was not created or is empty")
         
         progress(1.0, desc="✨ Complete!")
-        
         return output_path
         
+    except gr.Error:
+        # Re-raise Gradio errors as-is
+        raise
     except Exception as e:
         error_msg = str(e)
-        # Provide more user-friendly error messages
         if "CUDA out of memory" in error_msg:
-            raise gr.Error("❌ GPU out of memory. Try shorter text or use CPU mode.")
-        elif "timeout" in error_msg.lower():
-            raise gr.Error("❌ Synthesis timed out. Try with shorter text.")
-        elif "EOF" in error_msg:
-            raise gr.Error("❌ License acceptance issue. The auto-accept patch should handle this. Please try again.")
-        elif "No such file or directory" in error_msg and "reference" in error_msg.lower():
-            raise gr.Error("❌ Reference audio file issue. Please re-upload your audio file.")
+            raise gr.Error("❌ GPU out of memory. Try shorter text or enable CPU mode.")
+        elif "list index out of range" in error_msg:
+            raise gr.Error(
+                "❌ Voice cloning failed. This usually means:\n"
+                "• Reference audio is too short (need 6+ seconds)\n"
+                "• Audio doesn't contain clear speech\n"
+                "• Audio format is not supported\n\n"
+                "Try uploading a clean 6-10 second WAV file."
+            )
         else:
             raise gr.Error(f"❌ Synthesis failed: {error_msg}")
 
 # ============================================================
-#  BATCH SYNTHESIS (for long texts)
+#  BATCH SYNTHESIS
 # ============================================================
 def synthesize_batch(
     text: str,
@@ -252,20 +280,16 @@ def synthesize_batch(
     chunk_size: int = 500,
     progress=gr.Progress()
 ):
-    """
-    Synthesize long text by splitting into chunks and concatenating.
-    Useful for texts > 1000 characters.
-    """
+    """Synthesize long text by splitting into chunks."""
     if not text or not text.strip():
         raise gr.Error("Please enter some text to synthesize.")
     
     if len(text) <= MAX_TEXT_LENGTH:
-        # Use regular synthesis for shorter texts
         return synthesize(text, reference_audio, language, speed, progress)
     
     progress(0.05, desc="📝 Splitting text into chunks...")
     
-    # Split text into sentences or chunks
+    # Split into sentences
     sentences = text.replace('\n', ' ').split('. ')
     chunks = []
     current_chunk = ""
@@ -289,29 +313,35 @@ def synthesize_batch(
     
     progress(0.1, desc=f"📊 Split into {len(chunks)} chunks")
     
-    # Synthesize each chunk
+    # Synthesize chunks
     audio_files = []
     total_chunks = len(chunks)
     
     for i, chunk in enumerate(chunks):
         chunk_progress = 0.1 + (0.7 * (i / total_chunks))
-        progress(chunk_progress, desc=f"🎤 Synthesizing chunk {i+1}/{total_chunks}...")
+        progress(chunk_progress, desc=f"🎤 Chunk {i+1}/{total_chunks}...")
         
         with tempfile.NamedTemporaryFile(suffix=f"_chunk_{i}.wav", delete=False) as f:
             chunk_path = f.name
         
-        tts = get_tts()
-        tts.tts_to_file(
-            text=chunk.strip(),
-            speaker_wav=reference_audio,
-            language=language,
-            file_path=chunk_path,
-            speed=speed,
-        )
-        audio_files.append(chunk_path)
-    
-    # Concatenate audio files
-    progress(0.85, desc="🔊 Concatenating audio chunks...")
+        try:
+            tts = get_tts()
+            tts.tts_to_file(
+                text=chunk.strip(),
+                speaker_wav=reference_audio,
+                language=language,
+                file_path=chunk_path,
+                speed=speed,
+            )
+            audio_files.append(chunk_path)
+        except IndexError as e:
+            raise gr.Error(
+                "❌ Voice cloning failed on chunk {i+1}. This usually means the reference audio "
+                "doesn't contain clear speech. Please upload a cleaner audio clip."
+            )
+    
+    # Combine audio
+    progress(0.85, desc="🔊 Combining audio...")
     
     try:
         from pydub import AudioSegment
@@ -324,7 +354,7 @@ def synthesize_batch(
         output_path = tempfile.NamedTemporaryFile(suffix="_combined.wav", delete=False).name
         combined.export(output_path, format="wav")
         
-        # Clean up chunk files
+        # Cleanup
         for audio_file in audio_files:
             try:
                 os.unlink(audio_file)
@@ -335,40 +365,34 @@ def synthesize_batch(
         return output_path
         
     except Exception as e:
-        raise gr.Error(f"Failed to concatenate audio chunks: {str(e)}")
+        raise gr.Error(f"Failed to combine audio: {str(e)}")
 
 # ============================================================
 #  UTILITY FUNCTIONS
 # ============================================================
 def clear_cache():
-    """Clear the TTS model cache to free memory."""
     global _tts
     _tts = None
-    torch.cuda.empty_cache() if torch.cuda.is_available() else None
-    return "🗑️ Model cache cleared. Next synthesis will reload the model."
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    return "🗑️ Model cache cleared."
 
 def get_model_status():
-    """Get current model loading status."""
     if _tts is not None:
-        device = "GPU" if torch.cuda.is_available() and next(_tts.model.parameters()).is_cuda else "CPU"
+        device = "GPU" if torch.cuda.is_available() else "CPU"
         return f"✅ Model loaded on {device}"
     elif _model_loading:
         if _model_downloading:
-            return "📥 Downloading model (4GB)... Please wait 2-5 minutes on first run"
+            return "📥 Downloading model (4GB)... 2-5 minutes"
         return "⏳ Model is loading..."
     elif _loading_error:
-        return f"❌ Model failed to load: {_loading_error}"
-    elif not is_model_downloaded():
-        return "📥 Model will download on first synthesis (4GB, 2-5 minutes)"
+        return f"❌ Error: {_loading_error[:50]}..."
     else:
-        return "🔄 Model not loaded yet"
+        return "🔄 Model not loaded (will load on first use)"
 
 def estimate_duration(text: str, speed: float = 1.0):
-    """Estimate the duration of synthesized speech."""
     if not text:
         return 0
-    
-    # Rough estimate: ~150 characters per second at normal speed
     chars_per_second = 150 * speed
     duration = len(text) / chars_per_second
     return round(duration, 1)
@@ -377,335 +401,108 @@ def estimate_duration(text: str, speed: float = 1.0):
 #  GRADIO UI
 # ============================================================
 with gr.Blocks(
-    title="VoxForge TTS — Voice Clone Backend",
-    theme=gr.themes.Soft(
-        primary_hue="purple",
-        secondary_hue="teal",
-    ),
-    css="""
-    .gradio-container {
-        max-width: 1200px !important;
-        margin: auto !important;
-    }
-    .status-text {
-        font-family: monospace;
-        font-size: 0.9em;
-    }
-    """
+    title="VoxForge TTS — Voice Clone",
+    theme=gr.themes.Soft(primary_hue="purple", secondary_hue="teal"),
 ) as demo:
     
-    # Header
     gr.Markdown(
         """
-        # 🎙️ VoxForge TTS — Professional Voice Cloning
+        # 🎙️ VoxForge TTS — Voice Cloning
         
-        **Zero-shot voice cloning** powered by Coqui XTTS-v2. Upload any 6-second WAV file and synthesize natural speech in 14 languages.
+        **Upload a 6-10 second WAV file of any voice** and make it say anything in 14 languages.
         
-        ⚠️ **First time use**: The 4GB model will download on your first synthesis (2-5 minutes). Please be patient!
+        ⚠️ **First use**: Downloads 4GB model (2-5 minutes). Please be patient!
         """
     )
     
-    with gr.Tabs():
-        # ========================================================
-        # TAB 1: STANDARD SYNTHESIS
-        # ========================================================
-        with gr.TabItem("🎤 Standard Synthesis"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    text_input = gr.Textbox(
-                        label="📝 Text to Synthesize",
-                        placeholder="Enter up to 2000 characters...\n\nExample: Hello, this is my cloned voice speaking naturally.",
-                        lines=8,
-                        max_length=MAX_TEXT_LENGTH
-                    )
-                    
-                    with gr.Row():
-                        char_count = gr.Label(value=f"0 / {MAX_TEXT_LENGTH} characters", label="Character Count")
-                        est_duration = gr.Label(value="Estimated duration: 0s", label="Estimated Duration")
-                    
-                    ref_audio = gr.Audio(
-                        label="🎵 Reference Voice (6+ seconds, clear WAV recommended)",
-                        type="filepath",
-                        sources=["upload", "microphone"]
-                    )
-                    
-                    with gr.Row():
-                        language = gr.Dropdown(
-                            choices=SUPPORTED_LANGUAGES,
-                            value="en",
-                            label="🌐 Language"
-                        )
-                        speed_slider = gr.Slider(
-                            0.5, 2.0, 
-                            value=1.0, 
-                            step=0.05, 
-                            label="⚡ Speech Speed"
-                        )
-                    
-                    with gr.Row():
-                        synthesize_btn = gr.Button(
-                            "🎵 Generate Speech", 
-                            variant="primary", 
-                            size="lg"
-                        )
-                        clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="lg")
-                    
-                    with gr.Accordion("⚙️ Advanced Options", open=False):
-                        model_status = gr.Label(value=get_model_status(), label="Model Status")
-                        clear_cache_btn = gr.Button("Clear Model Cache", variant="secondary", size="sm")
-                        clear_cache_output = gr.Textbox(label="Cache Action", interactive=False, visible=False)
-                
-                with gr.Column(scale=1):
-                    audio_output = gr.Audio(
-                        label="🔊 Generated Speech",
-                        type="filepath",
-                        interactive=False
-                    )
-                    
-                    gr.Markdown(
-                        """
-                        ### 💡 Tips for Best Results
-                        
-                        1. **Reference Audio**: Use a clean 6-10 second WAV file at 22050Hz mono
-                        2. **Text Quality**: Write naturally with proper punctuation
-                        3. **Language**: Match the language of your reference voice
-                        4. **Speed**: Adjust between 0.8-1.2 for most natural results
-                        
-                        ---
-                        
-                        ### ⏱️ Performance Notes
-                        - **First synthesis**: 2-5 minutes (downloading 4GB model)
-                        - **Subsequent syntheses**: 10-30 seconds
-                        - **GPU recommended**: Enable T4 GPU in Space settings
-                        
-                        ---
-                        
-                        ### Supported Languages
-                        English, Spanish, French, German, Italian, Portuguese, Polish, 
-                        Turkish, Russian, Dutch, Czech, Arabic, Chinese, Japanese
-                        """
-                    )
-            
-            # Event handlers for Tab 1
-            def update_char_count(text):
-                if text:
-                    return f"{len(text)} / {MAX_TEXT_LENGTH} characters"
-                return f"0 / {MAX_TEXT_LENGTH} characters"
-            
-            def update_duration_estimate(text, speed):
-                if text:
-                    duration = estimate_duration(text, speed)
-                    mins = int(duration // 60)
-                    secs = int(duration % 60)
-                    if mins > 0:
-                        return f"Estimated duration: {mins}m {secs}s"
-                    return f"Estimated duration: {secs}s"
-                return "Estimated duration: 0s"
-            
-            text_input.change(
-                update_char_count, 
-                inputs=[text_input], 
-                outputs=[char_count]
-            )
-            text_input.change(
-                update_duration_estimate,
-                inputs=[text_input, speed_slider],
-                outputs=[est_duration]
-            )
-            speed_slider.change(
-                update_duration_estimate,
-                inputs=[text_input, speed_slider],
-                outputs=[est_duration]
+    with gr.Row():
+        with gr.Column(scale=1):
+            text_input = gr.Textbox(
+                label="Text to Synthesize",
+                placeholder="Enter up to 2000 characters...",
+                lines=6,
+                max_length=MAX_TEXT_LENGTH
             )
             
-            synthesize_btn.click(
-                fn=synthesize,
-                inputs=[text_input, ref_audio, language, speed_slider],
-                outputs=[audio_output],
-                api_name="synthesize"
-            )
+            with gr.Row():
+                char_count = gr.Label(value=f"0 / {MAX_TEXT_LENGTH}")
+                est_duration = gr.Label(value="Est. 0s")
             
-            clear_btn.click(
-                fn=lambda: ("", None, "en", 1.0),
-                inputs=[],
-                outputs=[text_input, ref_audio, language, speed_slider]
+            ref_audio = gr.Audio(
+                label="Reference Voice (6-10 seconds, clear WAV)",
+                type="filepath",
+                sources=["upload", "microphone"]
             )
             
-            def update_status():
-                return get_model_status()
-            
-            clear_cache_btn.click(
-                fn=clear_cache,
-                inputs=[],
-                outputs=[clear_cache_output]
-            ).then(
-                fn=update_status,
-                inputs=[],
-                outputs=[model_status]
-            )
-        
-        # ========================================================
-        # TAB 2: BATCH SYNTHESIS (for long texts)
-        # ========================================================
-        with gr.TabItem("📚 Batch Synthesis (Long Text)"):
-            gr.Markdown(
-                """
-                ### 🔄 Long Text Synthesis
-                This mode automatically splits long texts (>2000 characters) into smaller chunks and concatenates them.
-                
-                **Note**: Processing may take several minutes for very long texts.
-                """
-            )
+            with gr.Row():
+                language = gr.Dropdown(
+                    choices=SUPPORTED_LANGUAGES,
+                    value="en",
+                    label="Language"
+                )
+                speed_slider = gr.Slider(
+                    0.5, 2.0, value=1.0, step=0.05, label="Speed"
+                )
             
             with gr.Row():
-                with gr.Column(scale=1):
-                    long_text = gr.Textbox(
-                        label="📝 Long Text",
-                        placeholder="Paste your long text here (up to 10000 characters)...\n\nThe system will automatically split it into chunks and synthesize them sequentially.",
-                        lines=12,
-                        max_length=10000
-                    )
-                    
-                    with gr.Row():
-                        chunk_size = gr.Slider(
-                            300, 800,
-                            value=500,
-                            step=50,
-                            label="📏 Chunk Size (characters)"
-                        )
-                    
-                    ref_audio_batch = gr.Audio(
-                        label="🎵 Reference Voice",
-                        type="filepath",
-                        sources=["upload", "microphone"]
-                    )
-                    
-                    with gr.Row():
-                        language_batch = gr.Dropdown(
-                            choices=SUPPORTED_LANGUAGES,
-                            value="en",
-                            label="🌐 Language"
-                        )
-                        speed_batch = gr.Slider(
-                            0.5, 2.0,
-                            value=1.0,
-                            step=0.05,
-                            label="⚡ Speech Speed"
-                        )
-                    
-                    synthesize_batch_btn = gr.Button(
-                        "🎵 Generate Long Speech",
-                        variant="primary",
-                        size="lg"
-                    )
-                
-                with gr.Column(scale=1):
-                    batch_audio_output = gr.Audio(
-                        label="🔊 Generated Speech (Combined)",
-                        type="filepath",
-                        interactive=False
-                    )
-                    
-                    gr.Markdown(
-                        """
-                        ### ℹ️ About Batch Mode
-                        
-                        - Automatically splits text at sentence boundaries
-                        - Synthesizes each chunk with the same voice
-                        - Combines all chunks into a single audio file
-                        - Useful for audiobooks, presentations, or long narrations
-                        
-                        **Limitation**: Quality may vary slightly between chunks
-                        """
-                    )
+                synthesize_btn = gr.Button("Generate Speech", variant="primary", size="lg")
+                clear_btn = gr.Button("Clear", variant="secondary", size="lg")
             
-            synthesize_batch_btn.click(
-                fn=synthesize_batch,
-                inputs=[long_text, ref_audio_batch, language_batch, speed_batch, chunk_size],
-                outputs=[batch_audio_output],
-                api_name="synthesize_batch"
-            )
+            with gr.Accordion("Advanced", open=False):
+                model_status = gr.Label(value=get_model_status())
+                clear_cache_btn = gr.Button("Clear Model Cache", size="sm")
         
-        # ========================================================
-        # TAB 3: HELP & TROUBLESHOOTING
-        # ========================================================
-        with gr.TabItem("❓ Help & Troubleshooting"):
+        with gr.Column(scale=1):
+            audio_output = gr.Audio(label="Generated Speech", type="filepath")
+            
             gr.Markdown(
                 """
-                # 📖 Help Guide
+                ### Tips
                 
-                ## 🎯 Quick Start
+                1. **Audio**: 6-10 seconds, clear speech, no background noise
+                2. **Format**: WAV, 22050Hz, mono (convert with ffmpeg if needed)
+                3. **Language**: Match the language of the reference voice
                 
-                1. **Prepare Reference Audio**
-                   - Record or upload a 6-10 second WAV file
-                   - Use 22050Hz sample rate, mono channel
-                   - Speak clearly without background noise
-                
-                2. **Enter Text**
-                   - Type or paste up to 2000 characters
-                   - Use proper punctuation for natural pauses
-                   - Match the language of your reference voice
-                
-                3. **Generate Speech**
-                   - Click "Generate Speech" button
-                   - **First time**: Wait 2-5 minutes for model download
-                   - **Subsequent times**: Wait 10-30 seconds for synthesis
-                   - Download or listen to the result
-                
-                ## ⏱️ Why is first synthesis so slow?
-                
-                The XTTS-v2 model is **4GB** and must be downloaded from Hugging Face.
-                - First synthesis: Downloads model (2-5 minutes) + synthesis (10-30 seconds)
-                - After that: Model is cached, synthesis only (10-30 seconds)
-                
-                **Pro tip**: Enable GPU in Space Settings → Hardware → T4 Small for faster performance!
-                
-                ## 🔧 Troubleshooting
-                
-                ### "Failed to load TTS model"
-                - Wait a few minutes for the model to download (first time only)
-                - Check if your Space has GPU enabled
-                - Try clearing the model cache in Advanced Options
-                
-                ### "CUDA out of memory"
-                - Reduce text length
-                - Use CPU mode (not recommended for long texts)
-                - Clear model cache and retry
-                
-                ### Poor voice quality
-                - Ensure reference audio is clean (no background noise)
-                - Use longer reference audio (8-10 seconds)
-                - Match speaking style of reference voice
-                
-                ### Synthesis is still slow after first time
-                - Enable GPU in Space settings
-                - Reduce text length
-                - Check your internet connection
-                
-                ## 📞 Support
-                
-                - Check container logs in Space settings
-                - Ensure all files (Dockerfile, requirements.txt) are present
-                - Restart the Space if issues persist
+                ### First time?
+                - Downloads 4GB model (2-5 minutes)
+                - Subsequent uses: 10-30 seconds
+                - Enable GPU in Space settings for faster performance
                 """
             )
     
-    # Footer
-    gr.Markdown(
-        """
-        ---
-        **Powered by Coqui XTTS-v2** | Non-commercial use only | [License](https://coqui.ai/cpml)
-        """
+    # Event handlers
+    def update_char_count(text):
+        return f"{len(text)} / {MAX_TEXT_LENGTH}" if text else f"0 / {MAX_TEXT_LENGTH}"
+    
+    def update_duration(text, speed):
+        if text:
+            dur = estimate_duration(text, speed)
+            return f"Est. {dur}s"
+        return "Est. 0s"
+    
+    text_input.change(update_char_count, [text_input], [char_count])
+    text_input.change(update_duration, [text_input, speed_slider], [est_duration])
+    speed_slider.change(update_duration, [text_input, speed_slider], [est_duration])
+    
+    synthesize_btn.click(
+        synthesize,
+        [text_input, ref_audio, language, speed_slider],
+        [audio_output]
+    )
+    
+    clear_btn.click(
+        lambda: ("", None, "en", 1.0),
+        None,
+        [text_input, ref_audio, language, speed_slider]
+    )
+    
+    clear_cache_btn.click(clear_cache, None, [model_status]).then(
+        lambda: get_model_status(), None, [model_status]
     )
 
-# ============================================================
-#  LAUNCH THE APP
-# ============================================================
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=int(os.environ.get("PORT", 7860)),
-        share=False,
-        show_error=True,
-        quiet=False
+        show_error=True
     )