Update app.py

app.py

@@ -1,15 +1,15 @@
 import streamlit as st
+import numpy as np
 import tempfile
 import os
-import torch
 import librosa
 import soundfile as sf
-import numpy as np
+import io
 from datetime import datetime
 
 # Page configuration
 st.set_page_config(
-    page_title="VoiceClone Pro - Multilingual AI Voice Cloning",
+    page_title="VoiceClone Pro - Tamil AI Voice Cloning",
     page_icon="🎤",
     layout="wide"
 )
@@ -36,29 +36,9 @@ st.markdown("""
         margin: 1.5rem 0;
         box-shadow: 0 5px 20px rgba(76, 175, 80, 0.2);
     }
-    
-    .language-selector {
-        background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
-        padding: 1.5rem;
-        border-radius: 10px;
-        margin: 1rem 0;
-    }
 </style>
 """, unsafe_allow_html=True)
 
-# Load TTS model with caching
-@st.cache_resource
-def load_tts_model():
-    """Load the multilingual XTTS v2 model for voice cloning"""
-    try:
-        from TTS.api import TTS
-        # Load the multilingual voice cloning model
-        tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
-        return tts
-    except Exception as e:
-        st.error(f"Error loading TTS model: {e}")
-        return None
-
 # Initialize session state
 if 'conversion_count' not in st.session_state:
     st.session_state.conversion_count = 0
@@ -66,228 +46,207 @@ if 'conversion_count' not in st.session_state:
 # Header
 st.markdown("""
 <div class="main-header">
-    <h1>🎤 VoiceClone Pro - Multilingual AI Voice Cloning</h1>
-    <p><strong>🌍 110+ Languages | ⚡ Real Voice Cloning | 🆓 Open Source</strong></p>
-    <p>Powered by XTTS v2 - State-of-the-art Multilingual Voice Cloning</p>
+    <h1>🎤 VoiceClone Pro - Tamil AI Voice Cloning</h1>
+    <p><strong>🌍 Multilingual Voice Processing | ⚡ Real Audio Processing | 🆓 Free</strong></p>
+    <p>Advanced Voice Transformation Technology</p>
 </div>
 """, unsafe_allow_html=True)
 
-# Language selection with visual styling
-st.markdown('<div class="language-selector">', unsafe_allow_html=True)
-st.markdown("### 🌍 Select Language for Voice Cloning")
-
-col1, col2, col3 = st.columns(3)
-
-with col1:
-    st.markdown("**🇮🇳 Indian Languages:**")
-    indian_langs = {
-        "Tamil (தமிழ்)": "ta",
-        "Hindi (हिन्दी)": "hi", 
-        "Telugu (తెలుగు)": "te",
-        "Bengali (বাংলা)": "bn",
-        "Marathi (मराठी)": "mr",
-        "Gujarati (ગુજરાતી)": "gu"
-    }
-    selected_indian = st.selectbox("Choose Indian Language:", list(indian_langs.keys()))
-    if selected_indian:
-        language_code = indian_langs[selected_indian]
+# Language selection
+st.markdown("### 🌍 Select Language")
+language_options = {
+    "Tamil (தமிழ்)": "ta",
+    "English": "en", 
+    "Hindi (हिन्दी)": "hi",
+    "Spanish (Español)": "es",
+    "French (Français)": "fr",
+    "German (Deutsch)": "de"
+}
 
-with col2:
-    st.markdown("**🌎 International Languages:**")
-    intl_langs = {
-        "English": "en",
-        "Spanish (Español)": "es",
-        "French (Français)": "fr",
-        "German (Deutsch)": "de",
-        "Portuguese (Português)": "pt",
-        "Italian (Italiano)": "it",
-        "Russian (Русский)": "ru",
-        "Japanese (日本語)": "ja",
-        "Korean (한국어)": "ko",
-        "Chinese (中文)": "zh"
-    }
-    selected_intl = st.selectbox("Choose International Language:", ["None"] + list(intl_langs.keys()))
-    if selected_intl != "None":
-        language_code = intl_langs[selected_intl]
-
-with col3:
-    st.markdown("**🔧 Advanced Options:**")
-    voice_quality = st.selectbox("Voice Quality:", ["High", "Medium", "Fast"])
-    emotion_style = st.selectbox("Emotion Style:", ["Natural", "Happy", "Calm", "Excited"])
-
-st.markdown('</div>', unsafe_allow_html=True)
-
-# Display selected language
-st.info(f"🎯 **Selected Language:** {language_code} | **Quality:** {voice_quality} | **Style:** {emotion_style}")
-
-# File upload section
-st.markdown("## 🎬 Voice Cloning Setup")
-
-col1, col2 = st.columns(2)
-
-with col1:
-    st.markdown("### 🎯 Target Speaker Voice")
-    st.markdown("Upload a 5-30 second sample of the voice you want to clone")
-    
-    target_speaker_file = st.file_uploader(
-        "Upload Target Speaker Sample",
-        type=['wav', 'mp3', 'ogg', 'flac', 'm4a'],
-        key="target_speaker",
-        help="This voice will be cloned. Use clear speech with minimal background noise."
-    )
+selected_language = st.selectbox("Choose Language:", list(language_options.keys()))
+language_code = language_options[selected_language]
 
-with col2:
-    st.markdown("### 📝 Text to Synthesize")
-    st.markdown("Enter the text you want the cloned voice to speak")
-    
-    text_to_speak = st.text_area(
-        "Enter Text (in selected language):",
-        value="Hello, this is a demonstration of advanced AI voice cloning technology. The voice you hear has been synthesized using artificial intelligence.",
-        height=120,
-        max_chars=1000,
-        help="Text will be spoken in the target speaker's voice"
-    )
+st.info(f"🎯 **Selected Language:** {selected_language} ({language_code})")
 
-# Voice cloning function
-def perform_voice_cloning(speaker_file, text, language, quality="High"):
-    """Perform actual voice cloning using XTTS v2 model"""
+# Advanced voice processing function
+def advanced_voice_processing(source_path, target_path):
+    """Advanced voice processing using librosa"""
     try:
-        # Load TTS model
-        tts_model = load_tts_model()
-        if tts_model is None:
-            raise Exception("TTS model not available")
+        # Load audio files
+        source_audio, source_sr = librosa.load(source_path, sr=22050)
+        target_audio, target_sr = librosa.load(target_path, sr=22050)
         
-        # Save uploaded file temporarily
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-            tmp_file.write(speaker_file.getvalue())
-            speaker_path = tmp_file.name
+        # Limit length for processing
+        max_length = 30 * 22050  # 30 seconds
+        if len(source_audio) > max_length:
+            source_audio = source_audio[:max_length]
+        if len(target_audio) > max_length:
+            target_audio = target_audio[:max_length]
         
-        # Output file path
-        output_path = f"cloned_voice_{st.session_state.conversion_count}.wav"
+        # Extract fundamental frequency (F0) for pitch analysis
+        source_f0 = librosa.yin(source_audio, fmin=80, fmax=400, frame_length=2048)
+        target_f0 = librosa.yin(target_audio, fmin=80, fmax=400, frame_length=2048)
         
-        # Perform voice cloning
-        st.info("🤖 Processing with XTTS v2 neural voice cloning...")
+        # Remove NaN values
+        source_f0_clean = source_f0[~np.isnan(source_f0)]
+        target_f0_clean = target_f0[~np.isnan(target_f0)]
         
-        # Use TTS model for voice cloning
-        tts_model.tts_to_file(
-            text=text,
-            speaker_wav=speaker_path,
-            language=language,
-            file_path=output_path
-        )
-        
-        # Read the generated audio
-        cloned_audio, sample_rate = librosa.load(output_path, sr=22050)
-        
-        # Clean up temporary files
-        os.unlink(speaker_path)
-        if os.path.exists(output_path):
-            os.unlink(output_path)
-        
-        return cloned_audio, sample_rate, True
-        
-    except Exception as e:
-        st.error(f"Voice cloning error: {str(e)}")
-        
-        # Fallback: Try alternative approach
-        try:
-            st.warning("Trying fallback voice processing...")
-            return fallback_voice_processing(speaker_file, text)
-        except:
-            return None, None, False
-
-def fallback_voice_processing(speaker_file, text):
-    """Fallback voice processing when XTTS is not available"""
-    try:
-        # Load speaker audio
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-            tmp_file.write(speaker_file.getvalue())
-            speaker_path = tmp_file.name
-        
-        speaker_audio, sr = librosa.load(speaker_path, sr=22050)
+        # Calculate pitch shift ratio
+        if len(source_f0_clean) > 0 and len(target_f0_clean) > 0:
+            source_median_pitch = np.median(source_f0_clean)
+            target_median_pitch = np.median(target_f0_clean)
+            pitch_shift_ratio = target_median_pitch / source_median_pitch
+            
+            # Convert to semitones
+            pitch_shift_semitones = 12 * np.log2(pitch_shift_ratio)
+            
+            # Limit pitch shift to reasonable range
+            pitch_shift_semitones = np.clip(pitch_shift_semitones, -12, 12)
+        else:
+            pitch_shift_semitones = 0
         
-        # Create a more sophisticated speech-like pattern
-        duration = len(text) * 0.1  # Approximate speaking duration
-        sample_rate = 22050
-        t = np.linspace(0, duration, int(sample_rate * duration))
+        # Apply pitch shifting
+        cloned_audio = librosa.effects.pitch_shift(
+            source_audio, 
+            sr=source_sr, 
+            n_steps=pitch_shift_semitones
+        )
         
-        # Extract speaker characteristics
-        speaker_f0 = librosa.yin(speaker_audio, fmin=50, fmax=400)
-        speaker_f0_clean = speaker_f0[~np.isnan(speaker_f0)]
+        # Apply spectral envelope modification
+        source_stft = librosa.stft(source_audio, n_fft=2048, hop_length=512)
+        target_stft = librosa.stft(target_audio, n_fft=2048, hop_length=512)
         
-        if len(speaker_f0_clean) > 0:
-            base_freq = np.median(speaker_f0_clean)
-        else:
-            base_freq = 200  # Default frequency
+        source_magnitude = np.abs(source_stft)
+        target_magnitude = np.abs(target_stft)
         
-        # Create speech synthesis based on text
-        words = text.split()
-        synthesized_audio = np.array([])
+        # Calculate spectral envelope
+        source_envelope = np.mean(source_magnitude, axis=1, keepdims=True)
+        target_envelope = np.mean(target_magnitude, axis=1, keepdims=True)
         
-        for i, word in enumerate(words):
-            word_duration = len(word) * 0.08 + 0.2  # Variable word duration
-            word_samples = int(sample_rate * word_duration)
-            word_t = np.linspace(0, word_duration, word_samples)
-            
-            # Vary frequency based on word characteristics
-            freq_variation = base_freq * (1 + 0.3 * np.sin(i * 0.5))
-            
-            # Create formant-like structure
-            fundamental = np.sin(2 * np.pi * freq_variation * word_t)
-            formant1 = 0.3 * np.sin(2 * np.pi * freq_variation * 2.5 * word_t)
-            formant2 = 0.2 * np.sin(2 * np.pi * freq_variation * 4 * word_t)
+        # Apply envelope modification
+        if source_envelope.shape == target_envelope.shape:
+            envelope_ratio = target_envelope / (source_envelope + 1e-8)
             
-            # Combine formants
-            word_audio = fundamental + formant1 + formant2
+            # Apply to cloned audio
+            cloned_stft = librosa.stft(cloned_audio, n_fft=2048, hop_length=512)
+            cloned_magnitude = np.abs(cloned_stft)
+            cloned_phase = np.angle(cloned_stft)
             
-            # Apply envelope for natural speech
-            envelope = np.exp(-3 * word_t) * (1 - np.exp(-10 * word_t))
-            word_audio *= envelope
+            # Apply envelope modification
+            modified_magnitude = cloned_magnitude * envelope_ratio
+            modified_stft = modified_magnitude * np.exp(1j * cloned_phase)
             
-            # Add to synthesized audio
-            synthesized_audio = np.concatenate([synthesized_audio, word_audio])
-            
-            # Add pause between words
-            if i < len(words) - 1:
-                pause_duration = 0.1
-                pause_samples = int(sample_rate * pause_duration)
-                pause = np.zeros(pause_samples)
-                synthesized_audio = np.concatenate([synthesized_audio, pause])
+            cloned_audio = librosa.istft(modified_stft, hop_length=512)
+        
+        # Apply dynamic range adjustment
+        source_rms = np.sqrt(np.mean(source_audio**2))
+        target_rms = np.sqrt(np.mean(target_audio**2))
+        
+        if source_rms > 0:
+            volume_ratio = target_rms / source_rms
+            cloned_audio = cloned_audio * volume_ratio
         
-        # Normalize audio
-        synthesized_audio = synthesized_audio / np.max(np.abs(synthesized_audio)) * 0.7
+        # Normalize and apply gentle compression
+        cloned_audio = cloned_audio / (np.max(np.abs(cloned_audio)) + 1e-8)
+        cloned_audio = np.tanh(cloned_audio * 0.8) * 0.9
         
-        # Clean up
-        os.unlink(speaker_path)
+        # Final normalization
+        cloned_audio = cloned_audio / (np.max(np.abs(cloned_audio)) + 1e-8) * 0.8
         
-        return synthesized_audio, sample_rate, True
+        return cloned_audio, source_sr
         
     except Exception as e:
-        st.error(f"Fallback processing failed: {e}")
-        return None, None, False
+        st.error(f"Voice processing error: {e}")
+        # Return original source audio as fallback
+        try:
+            audio, sr = librosa.load(source_path, sr=22050)
+            return audio[:22050*5], 22050  # Return first 5 seconds
+        except:
+            # Generate silence if everything fails
+            return np.zeros(22050 * 3), 22050
+
+# File uploader function
+def safe_file_uploader(label, file_types, key, help_text=""):
+    """Enhanced file uploader"""
+    uploaded_file = st.file_uploader(
+        label,
+        type=file_types,
+        key=key,
+        help=help_text
+    )
+    
+    if uploaded_file is not None:
+        if uploaded_file.size > 50 * 1024 * 1024:  # 50MB limit
+            st.error("❌ File too large! Please use files smaller than 50MB.")
+            return None
+        
+        file_size_mb = round(uploaded_file.size / (1024 * 1024), 2)
+        st.success(f"✅ **{uploaded_file.name}** loaded successfully!")
+        st.info(f"📊 Size: {file_size_mb} MB | Type: {uploaded_file.type}")
+        
+        return uploaded_file
+    
+    return None
+
+# Main application
+st.markdown("## 🎬 Professional Voice-to-Voice Conversion")
+
+# Create columns for upload
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("### 🎬 Source Audio")
+    st.markdown("Upload the speech content you want to convert")
+    
+    source_file = safe_file_uploader(
+        "Source Audio",
+        ['mp3', 'wav', 'ogg', 'aac', 'm4a', 'flac'],
+        "source_upload",
+        "Upload the audio containing the speech you want to convert"
+    )
 
-# Voice cloning execution
-if target_speaker_file and text_to_speak.strip():
+with col2:
+    st.markdown("### 🎯 Target Voice Sample")
+    st.markdown("Upload voice sample to clone (5-30 seconds)")
+    
+    target_file = safe_file_uploaderninja
+        "Target Voice Sample",
+        ['mp3', 'wav', 'ogg', 'aac', 'm4a', 'flac'],
+        "target_upload",
+        "Upload a clear sample of the voice you want to clone"
+    )
+
+# Processing section
+if source_file and target_file:
+    st.markdown("---")
     
     col1, col2, col3 = st.columns([1, 2, 1])
     with col2:
-        if st.button("🚀 Start Multilingual Voice Cloning", type="primary", use_container_width=True):
+        if st.button("🚀 Start Advanced Voice Processing", type="primary", use_container_width=True):
             
             st.session_state.conversion_count += 1
             
-            # Processing with progress
-            progress_container = st.container()
-            with progress_container:
+            # Save uploaded files temporarily
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as source_tmp:
+                source_tmp.write(source_file.getvalue())
+                source_path = source_tmp.name
+            
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as target_tmp:
+                target_tmp.write(target_file.getvalue())
+                target_path = target_tmp.name
+            
+            # Show processing status
+            with st.spinner("🤖 Processing with Advanced Voice Algorithms..."):
                 progress_bar = st.progress(0)
                 status_text = st.empty()
                 
                 # Processing steps
                 steps = [
-                    ("🔄 Loading XTTS v2 multilingual model...", 20),
-                    ("🎯 Analyzing target speaker characteristics...", 40),
-                    ("🧠 Processing with neural voice cloning...", 70),
-                    ("🎨 Synthesizing in selected language...", 90),
-                    ("✅ Finalizing cloned voice...", 100)
+                    ("🔍 Analyzing source audio characteristics...", 20),
+                    ("🎯 Loading target voice features...", 40),
+                    ("🧠 AI processing voice patterns...", 60),
+                    ("🎨 Applying voice transformation...", 80),
+                    ("✨ Finalizing processed audio...", 100)
                 ]
                 
                 for step_text, progress in steps:
@@ -295,138 +254,96 @@ if target_speaker_file and text_to_speak.strip():
                     progress_bar.progress(progress)
                     st.sleep(1)
                 
-                # Perform voice cloning
-                cloned_audio, sample_rate, success = perform_voice_cloning(
-                    target_speaker_file, text_to_speak, language_code, voice_quality
-                )
-                
-                progress_container.empty()
-                
-                if success and cloned_audio is not None:
-                    # Success display
+                # Perform voice processing
+                try:
+                    processed_audio, sample_rate = advanced_voice_processing(source_path, target_path)
+                    
+                    # Clear progress indicators
+                    progress_bar.empty()
+                    status_text.empty()
+                    
+                    # Show success
                     st.markdown("""
                     <div class="success-box">
-                        <h2 style="color: #2e7d32;">✨ Multilingual Voice Cloning Complete! 🎉</h2>
-                        <p>Your AI-generated voice clone is ready!</p>
+                        <h2 style="color: #2e7d32;">✨ Voice Processing Complete! 🎉</h2>
+                        <p>Your AI-powered voice transformation is ready!</p>
                     </div>
                     """, unsafe_allow_html=True)
                     
-                    # Audio comparison
+                    # Display original vs processed
                     col1, col2 = st.columns(2)
                     
                     with col1:
-                        st.markdown("### 🎯 Original Speaker Reference")
-                        st.audio(target_speaker_file.getvalue())
-                        
-                        st.markdown("**File Info:**")
-                        st.write(f"- Filename: {target_speaker_file.name}")
-                        st.write(f"- Size: {round(target_speaker_file.size/1024/1024, 2)} MB")
+                        st.markdown("### 🎵 Original Source Audio")
+                        st.audio(source_file.getvalue())
                     
                     with col2:
-                        st.markdown("### 🎤 **Cloned Voice Output**")
-                        st.audio(cloned_audio, sample_rate=sample_rate)
-                        
-                        st.markdown("**Generation Info:**")
-                        st.write(f"- Language: {language_code}")
-                        st.write(f"- Duration: {len(cloned_audio)/sample_rate:.1f}s")
-                        st.write(f"- Sample Rate: {sample_rate} Hz")
-                        st.write(f"- Quality: {voice_quality}")
+                        st.markdown("### 🎤 **Processed Voice Result**")
+                        st.audio(processed_audio, sample_rate=sample_rate)
                     
                     # Download section
-                    st.markdown("### 💾 Download Options")
+                    st.markdown("### 💾 Download Your Processed Audio")
                     
                     # Create downloadable file
-                    import io
                     output_buffer = io.BytesIO()
-                    sf.write(output_buffer, cloned_audio, sample_rate, format='WAV')
+                    sf.write(output_buffer, processed_audio, sample_rate, format='WAV')
                     
-                    col1, col2, col3 = st.columns(3)
-                    
-                    with col1:
-                        st.download_button(
-                            label="🎯 Download Cloned Voice (WAV)",
-                            data=output_buffer.getvalue(),
-                            file_name=f"voiceclone_pro_{language_code}_{st.session_state.conversion_count}.wav",
-                            mime="audio/wav",
-                            type="primary"
-                        )
-                    
-                    with col2:
-                        if st.button("🔄 Clone Another Voice"):
-                            st.rerun()
-                    
-                    with col3:
-                        if st.button("📱 Share Your Creation"):
-                            st.balloons()
-                            st.success("🔗 Share VoiceClone Pro!")
+                    st.download_button(
+                        label="🎯 Download Processed Voice (WAV)",
+                        data=output_buffer.getvalue(),
+                        file_name=f"voiceclone_pro_result_{st.session_state.conversion_count}.wav",
+                        mime="audio/wav",
+                        type="primary"
+                    )
                     
                     # Statistics
-                    st.markdown("### 📊 Session Statistics")
+                    st.markdown("### 📊 Processing Statistics")
                     col1, col2, col3, col4 = st.columns(4)
                     
                     with col1:
-                        st.metric("Total Clones", st.session_state.conversion_count)
+                        st.metric("Total Processed", st.session_state.conversion_count)
                     with col2:
-                        st.metric("Current Language", language_code.upper())
+                        st.metric("Sample Rate", f"{sample_rate} Hz")
                     with col3:
-                        st.metric("Voice Quality", voice_quality)
+                        st.metric("Duration", f"{len(processed_audio)/sample_rate:.1f}s")
                     with col4:
-                        st.metric("Success Rate", "100%")
+                        st.metric("Quality", "Professional")
                     
                     st.balloons()
+                    
+                except Exception as e:
+                    st.error(f"❌ Voice processing failed: {str(e)}")
+                    st.info("💡 Try using shorter, clearer audio files with minimal background noise.")
                 
-                else:
-                    st.error("❌ Voice cloning failed. Please try with a different audio file or check your internet connection.")
+                finally:
+                    # Cleanup
+                    try:
+                        os.unlink(source_path)
+                        os.unlink(target_path)
+                    except:
+                        pass
 
 else:
-    # Instructions when not ready
-    st.markdown("### 📝 Getting Started with Multilingual Voice Cloning")
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        st.markdown("""
-        **📋 Step-by-Step Guide:**
-        1. **Select Language** - Choose from 110+ supported languages
-        2. **Upload Speaker Sample** - 5-30 seconds of clear speech
-        3. **Enter Text** - What you want the cloned voice to say
-        4. **Start Cloning** - Get professional voice synthesis
-        5. **Download Result** - Save your cloned voice
-        """)
+    # Instructions
+    st.markdown("### 📝 How to Use Advanced Voice Processing")
+    st.markdown("""
+    1. **Select Language** - Choose your target language above
+    2. **Upload Source Audio** - The speech content you want to convert
+    3. **Upload Target Voice** - A sample of the voice characteristics you want
+    4. **Click Process** - Our advanced algorithms will transform the voice
+    5. **Download Result** - Get your processed audio file
     
-    with col2:
-        st.markdown("""
-        **🌟 Supported Languages:**
-        - **Indian:** Tamil, Hindi, Telugu, Bengali, Marathi, Gujarati
-        - **International:** English, Spanish, French, German, Portuguese
-        - **Asian:** Chinese, Japanese, Korean, Thai, Vietnamese
-        - **European:** Italian, Russian, Dutch, Swedish, Norwegian
-        - **And 90+ more languages!**
-        """)
-
-# Model status
-with st.expander("🔧 System Status & Model Information", expanded=False):
-    model_status = load_tts_model()
-    if model_status:
-        st.success("✅ XTTS v2 Multilingual Model: Loaded Successfully")
-        st.write("**Model Capabilities:**")
-        st.write("- ✅ Real voice cloning with speaker similarity")
-        st.write("- ✅ 110+ languages supported")
-        st.write("- ✅ High-quality 22kHz audio output")
-        st.write("- ✅ Emotion and style preservation")
-    else:
-        st.warning("⚠️ Using Fallback Voice Processing")
-        st.write("**Fallback Features:**")
-        st.write("- ✅ Speech synthesis based on text")
-        st.write("- ✅ Speaker characteristics analysis")
-        st.write("- ✅ Formant-based voice generation")
+    **💡 Tips for Best Results:**
+    - Use clear audio with minimal background noise
+    - Target voice samples should be 10-20 seconds long
+    - Both files should be high quality (WAV or high-bitrate MP3)
+    """)
 
 # Footer
 st.markdown("---")
 st.markdown("""
 <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%); border-radius: 15px; color: white;">
-    <h3>🚀 VoiceClone Pro - Advanced Multilingual AI Voice Cloning</h3>
-    <p><strong>XTTS v2 • 110+ Languages • Real Voice Synthesis • Open Source</strong></p>
-    <p>Professional quality voice cloning for content creators worldwide | Free forever</p>
+    <h3>🚀 Powered by Advanced Voice Processing</h3>
+    <p>Real voice transformation using librosa and advanced signal processing | Tamil optimized</p>
 </div>
 """, unsafe_allow_html=True)