Update app.py

app.py

@@ -1,349 +1,515 @@
 import streamlit as st
+import torch
+import torchaudio
 import numpy as np
-import tempfile
-import os
 import librosa
 import soundfile as sf
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import plotly.express as px
+from scipy.signal import butter, filtfilt
+import tempfile
+import os
 import io
+import base64
 from datetime import datetime
+import requests
+import zipfile
+from pathlib import Path
+import pickle
+import json
+
+# Import voice cloning modules
+from voice_cloning_engine import VoiceCloningEngine
+from audio_processor import AudioProcessor
+from voice_analyzer import VoiceAnalyzer
 
 # Page configuration
 st.set_page_config(
-    page_title="VoiceClone Pro - Tamil AI Voice Cloning",
-    page_icon="🎤",
-    layout="wide"
+    page_title="AI Voice Clone Studio",
+    page_icon="🎭",
+    layout="wide",
+    initial_sidebar_state="expanded"
 )
 
 # Custom CSS
 st.markdown("""
 <style>
     .main-header {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        padding: 2rem;
-        border-radius: 15px;
+        font-size: 3rem;
+        font-weight: bold;
         text-align: center;
-        color: white;
         margin-bottom: 2rem;
-        box-shadow: 0 10px 30px rgba(102, 126, 234, 0.3);
+        background: linear-gradient(90deg, #ff6b6b, #4ecdc4, #45b7d1);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
     }
-    
-    .success-box {
-        background: linear-gradient(135deg, #e8f5e8 0%, #f0fff0 100%);
+    .clone-box {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
         padding: 2rem;
         border-radius: 15px;
-        border: 3px solid #4CAF50;
-        text-align: center;
-        margin: 1.5rem 0;
-        box-shadow: 0 5px 20px rgba(76, 175, 80, 0.2);
+        color: white;
+        margin: 1rem 0;
+    }
+    .reference-box {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin: 1rem 0;
+    }
+    .input-box {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin: 1rem 0;
+    }
+    .result-box {
+        background: linear-gradient(135deg, #43e97b 0%, #38f9d7 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin: 1rem 0;
+    }
+    .stAudio {
+        margin: 1rem 0;
     }
 </style>
 """, unsafe_allow_html=True)
 
 # Initialize session state
-if 'conversion_count' not in st.session_state:
-    st.session_state.conversion_count = 0
+if 'cloning_engine' not in st.session_state:
+    st.session_state.cloning_engine = None
+if 'reference_voice' not in st.session_state:
+    st.session_state.reference_voice = None
+if 'cloned_audio' not in st.session_state:
+    st.session_state.cloned_audio = None
+if 'voice_profiles' not in st.session_state:
+    st.session_state.voice_profiles = {}
 
-# Header
-st.markdown("""
-<div class="main-header">
-    <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)
+@st.cache_resource
+def load_cloning_engine():
+    """Initialize the voice cloning engine"""
+    return VoiceCloningEngine()
 
-# 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"
-}
+def save_uploaded_file(uploaded_file, directory="temp"):
+    """Save uploaded file to directory"""
+    if uploaded_file is not None:
+        os.makedirs(directory, exist_ok=True)
+        file_path = os.path.join(directory, uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        return file_path
+    return None
 
-selected_language = st.selectbox("Choose Language:", list(language_options.keys()))
-language_code = language_options[selected_language]
+def create_audio_comparison(original_audio, cloned_audio, sample_rate):
+    """Create side-by-side audio comparison"""
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
+    
+    # Original audio
+    time_original = np.linspace(0, len(original_audio) / sample_rate, len(original_audio))
+    ax1.plot(time_original, original_audio, color='blue', alpha=0.7)
+    ax1.set_title('Original Audio', fontsize=14, fontweight='bold')
+    ax1.set_xlabel('Time (seconds)')
+    ax1.set_ylabel('Amplitude')
+    ax1.grid(True, alpha=0.3)
+    
+    # Cloned audio
+    time_cloned = np.linspace(0, len(cloned_audio) / sample_rate, len(cloned_audio))
+    ax2.plot(time_cloned, cloned_audio, color='red', alpha=0.7)
+    ax2.set_title('Voice Cloned Audio', fontsize=14, fontweight='bold')
+    ax2.set_xlabel('Time (seconds)')
+    ax2.set_ylabel('Amplitude')
+    ax2.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    return fig
 
-st.info(f"🎯 **Selected Language:** {selected_language} ({language_code})")
+def create_spectrogram_comparison(original_audio, cloned_audio, sample_rate):
+    """Create spectrogram comparison"""
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
+    
+    # Original spectrogram
+    D1 = librosa.amplitude_to_db(np.abs(librosa.stft(original_audio)), ref=np.max)
+    librosa.display.specshow(D1, sr=sample_rate, x_axis='time', y_axis='hz', ax=ax1, cmap='viridis')
+    ax1.set_title('Original Audio Spectrogram')
+    
+    # Cloned spectrogram
+    D2 = librosa.amplitude_to_db(np.abs(librosa.stft(cloned_audio)), ref=np.max)
+    librosa.display.specshow(D2, sr=sample_rate, x_axis='time', y_axis='hz', ax=ax2, cmap='viridis')
+    ax2.set_title('Voice Cloned Audio Spectrogram')
+    
+    plt.tight_layout()
+    return fig
 
-# Advanced voice processing function
-def advanced_voice_processing(source_path, target_path):
-    """Advanced voice processing using librosa"""
-    try:
-        # Load audio files
-        source_audio, source_sr = librosa.load(source_path, sr=22050)
-        target_audio, target_sr = librosa.load(target_path, sr=22050)
+def main():
+    # Header
+    st.markdown('<div class="main-header">🎭 AI Voice Clone Studio</div>', unsafe_allow_html=True)
+    st.markdown("### Transform any voice into any other voice with advanced AI")
+    
+    # Initialize cloning engine
+    if st.session_state.cloning_engine is None:
+        with st.spinner("🚀 Loading Voice Cloning Engine..."):
+            st.session_state.cloning_engine = load_cloning_engine()
+    
+    # Sidebar Configuration
+    with st.sidebar:
+        st.header("⚙️ Voice Cloning Settings")
         
-        # 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]
+        # Model Selection
+        cloning_method = st.selectbox(
+            "Cloning Method:",
+            ["OpenVoice", "Real-Time VC", "SV2TTS", "Neural Voice Puppetry"],
+            help="Choose the voice cloning algorithm"
+        )
         
-        # 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)
+        # Quality Settings
+        st.subheader("🎛️ Quality Settings")
+        quality_level = st.select_slider(
+            "Quality Level:",
+            options=["Fast", "Balanced", "High Quality"],
+            value="Balanced"
+        )
         
-        # Remove NaN values
-        source_f0_clean = source_f0[~np.isnan(source_f0)]
-        target_f0_clean = target_f0[~np.isnan(target_f0)]
+        preserve_emotion = st.checkbox("Preserve Emotion", value=True)
+        preserve_accent = st.checkbox("Preserve Accent", value=True)
+        preserve_pace = st.checkbox("Preserve Speaking Pace", value=True)
         
-        # 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
+        # Advanced Settings
+        with st.expander("🔧 Advanced Settings"):
+            similarity_threshold = st.slider("Voice Similarity Threshold", 0.5, 1.0, 0.8)
+            noise_reduction = st.checkbox("Apply Noise Reduction", value=True)
+            auto_trim = st.checkbox("Auto-trim Silence", value=True)
+            enhance_quality = st.checkbox("Enhance Audio Quality", value=True)
+    
+    # Main Interface
+    col1, col2 = st.columns([1, 1])
+    
+    # Reference Voice Section
+    with col1:
+        st.markdown("""
+        <div class="reference-box">
+            <h3>🎤 Reference Voice (Target)</h3>
+            <p>Upload or record the voice you want to clone</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        reference_method = st.radio(
+            "Reference Voice Input:",
+            ["Upload Audio File", "Record Live", "Use Saved Profile"],
+            horizontal=True
+        )
+        
+        reference_audio_data = None
+        reference_sr = None
+        
+        if reference_method == "Upload Audio File":
+            reference_file = st.file_uploader(
+                "Upload Reference Voice:",
+                type=['wav', 'mp3', 'flac', 'm4a'],
+                help="Upload a clear audio sample of the target voice (10+ seconds recommended)"
+            )
             
-            # Convert to semitones
-            pitch_shift_semitones = 12 * np.log2(pitch_shift_ratio)
+            if reference_file:
+                file_path = save_uploaded_file(reference_file, "reference_voices")
+                reference_audio_data, reference_sr = librosa.load(file_path, sr=None)
+                st.audio(reference_file, format='audio/wav')
+                
+                # Voice Analysis
+                if st.button("🔍 Analyze Reference Voice"):
+                    with st.spinner("Analyzing voice characteristics..."):
+                        analyzer = VoiceAnalyzer()
+                        voice_features = analyzer.analyze_voice(reference_audio_data, reference_sr)
+                        
+                        st.json(voice_features)
+                        
+        elif reference_method == "Record Live":
+            st.info("🎙️ Use the record button below to capture reference voice")
+            # Audio recorder component would go here
+            # For now, showing placeholder
+            st.warning("Live recording feature requires additional setup")
             
-            # Limit pitch shift to reasonable range
-            pitch_shift_semitones = np.clip(pitch_shift_semitones, -12, 12)
-        else:
-            pitch_shift_semitones = 0
+        elif reference_method == "Use Saved Profile":
+            if st.session_state.voice_profiles:
+                selected_profile = st.selectbox(
+                    "Select Voice Profile:",
+                    list(st.session_state.voice_profiles.keys())
+                )
+                
+                if selected_profile:
+                    profile_data = st.session_state.voice_profiles[selected_profile]
+                    reference_audio_data = profile_data['audio_data']
+                    reference_sr = profile_data['sample_rate']
+                    st.success(f"✅ Loaded voice profile: {selected_profile}")
+            else:
+                st.info("No saved voice profiles available")
+    
+    # Input Audio Section
+    with col2:
+        st.markdown("""
+        <div class="input-box">
+            <h3>📢 Input Audio (Source)</h3>
+            <p>Upload the audio you want to transform</p>
+        </div>
+        """, unsafe_allow_html=True)
         
-        # Apply pitch shifting
-        cloned_audio = librosa.effects.pitch_shift(
-            source_audio, 
-            sr=source_sr, 
-            n_steps=pitch_shift_semitones
+        input_method = st.radio(
+            "Input Audio Method:",
+            ["Upload Audio File", "Record Live", "Text-to-Speech"],
+            horizontal=True
         )
         
-        # 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)
+        input_audio_data = None
+        input_sr = None
         
-        source_magnitude = np.abs(source_stft)
-        target_magnitude = np.abs(target_stft)
+        if input_method == "Upload Audio File":
+            input_file = st.file_uploader(
+                "Upload Input Audio:",
+                type=['wav', 'mp3', 'flac', 'm4a'],
+                help="Upload the audio you want to transform to the reference voice"
+            )
+            
+            if input_file:
+                file_path = save_uploaded_file(input_file, "temp")
+                input_audio_data, input_sr = librosa.load(file_path, sr=None)
+                st.audio(input_file, format='audio/wav')
+                
+        elif input_method == "Record Live":
+            st.info("🎙️ Use the record button below to capture input audio")
+            st.warning("Live recording feature requires additional setup")
+            
+        elif input_method == "Text-to-Speech":
+            tts_text = st.text_area(
+                "Enter text to convert:",
+                height=150,
+                placeholder="Type the text you want to speak in the cloned voice..."
+            )
+            
+            if tts_text and st.button("🗣️ Generate TTS"):
+                with st.spinner("Generating speech from text..."):
+                    # Generate TTS audio (placeholder)
+                    st.success("TTS generated! Now clone the voice.")
+    
+    # Voice Cloning Process
+    if reference_audio_data is not None and input_audio_data is not None:
+        st.markdown("---")
+        st.markdown("""
+        <div class="clone-box">
+            <h2>🎭 Voice Cloning Process</h2>
+            <p>Ready to clone the reference voice and apply it to your input audio!</p>
+        </div>
+        """, unsafe_allow_html=True)
         
-        # Calculate spectral envelope
-        source_envelope = np.mean(source_magnitude, axis=1, keepdims=True)
-        target_envelope = np.mean(target_magnitude, axis=1, keepdims=True)
+        col1, col2, col3 = st.columns([1, 2, 1])
         
-        # Apply envelope modification
-        if source_envelope.shape == target_envelope.shape:
-            envelope_ratio = target_envelope / (source_envelope + 1e-8)
-            
-            # 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)
+        with col2:
+            if st.button("🚀 Start Voice Cloning", type="primary", use_container_width=True):
+                try:
+                    with st.spinner("🎭 Cloning voice... This may take a few minutes"):
+                        progress_bar = st.progress(0)
+                        status_text = st.empty()
+                        
+                        # Step 1: Preprocess audio
+                        status_text.text("📊 Preprocessing audio...")
+                        progress_bar.progress(20)
+                        
+                        processor = AudioProcessor()
+                        ref_processed = processor.preprocess_audio(reference_audio_data, reference_sr)
+                        input_processed = processor.preprocess_audio(input_audio_data, input_sr)
+                        
+                        # Step 2: Extract voice features
+                        status_text.text("🔍 Extracting voice features...")
+                        progress_bar.progress(40)
+                        
+                        # Step 3: Voice cloning
+                        status_text.text("🎭 Performing voice cloning...")
+                        progress_bar.progress(60)
+                        
+                        cloned_audio = st.session_state.cloning_engine.clone_voice(
+                            reference_audio=ref_processed,
+                            input_audio=input_processed,
+                            method=cloning_method,
+                            preserve_emotion=preserve_emotion,
+                            preserve_accent=preserve_accent,
+                            preserve_pace=preserve_pace
+                        )
+                        
+                        # Step 4: Post-processing
+                        status_text.text("✨ Post-processing...")
+                        progress_bar.progress(80)
+                        
+                        if enhance_quality:
+                            cloned_audio = processor.enhance_audio(cloned_audio)
+                        
+                        progress_bar.progress(100)
+                        status_text.text("✅ Voice cloning completed!")
+                        
+                        # Store result
+                        st.session_state.cloned_audio = {
+                            'audio_data': cloned_audio,
+                            'sample_rate': input_sr,
+                            'original_input': input_audio_data,
+                            'reference_voice': reference_audio_data
+                        }
+                        
+                        st.success("🎉 Voice cloning successful!")
+                        
+                except Exception as e:
+                    st.error(f"❌ Error during voice cloning: {str(e)}")
+    
+    # Results Section
+    if st.session_state.cloned_audio:
+        st.markdown("---")
+        st.markdown("""
+        <div class="result-box">
+            <h2>🎵 Cloning Results</h2>
+            <p>Your voice has been successfully cloned!</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        cloned_data = st.session_state.cloned_audio
+        
+        # Audio Players
+        st.subheader("🔊 Audio Comparison")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.markdown("**📢 Original Input:**")
+            input_bytes = AudioProcessor.audio_to_bytes(cloned_data['original_input'], cloned_data['sample_rate'])
+            st.audio(input_bytes, format='audio/wav')
             
-            # Apply envelope modification
-            modified_magnitude = cloned_magnitude * envelope_ratio
-            modified_stft = modified_magnitude * np.exp(1j * cloned_phase)
+        with col2:
+            st.markdown("**🎤 Reference Voice:**")
+            ref_bytes = AudioProcessor.audio_to_bytes(cloned_data['reference_voice'], cloned_data['sample_rate'])
+            st.audio(ref_bytes, format='audio/wav')
             
-            cloned_audio = librosa.istft(modified_stft, hop_length=512)
+        with col3:
+            st.markdown("**🎭 Cloned Result:**")
+            cloned_bytes = AudioProcessor.audio_to_bytes(cloned_data['audio_data'], cloned_data['sample_rate'])
+            st.audio(cloned_bytes, format='audio/wav')
         
-        # Apply dynamic range adjustment
-        source_rms = np.sqrt(np.mean(source_audio**2))
-        target_rms = np.sqrt(np.mean(target_audio**2))
+        # Visualizations
+        st.subheader("📊 Audio Analysis")
         
-        if source_rms > 0:
-            volume_ratio = target_rms / source_rms
-            cloned_audio = cloned_audio * volume_ratio
+        tab1, tab2, tab3 = st.tabs(["Waveform Comparison", "Spectrogram Analysis", "Voice Similarity"])
         
-        # 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
+        with tab1:
+            fig_wave = create_audio_comparison(
+                cloned_data['original_input'],
+                cloned_data['audio_data'],
+                cloned_data['sample_rate']
+            )
+            st.pyplot(fig_wave)
         
-        # Final normalization
-        cloned_audio = cloned_audio / (np.max(np.abs(cloned_audio)) + 1e-8) * 0.8
+        with tab2:
+            fig_spec = create_spectrogram_comparison(
+                cloned_data['original_input'],
+                cloned_data['audio_data'],
+                cloned_data['sample_rate']
+            )
+            st.pyplot(fig_spec)
         
-        return cloned_audio, source_sr
+        with tab3:
+            # Voice similarity metrics
+            analyzer = VoiceAnalyzer()
+            similarity_score = analyzer.calculate_similarity(
+                cloned_data['reference_voice'],
+                cloned_data['audio_data'],
+                cloned_data['sample_rate']
+            )
+            
+            # Create similarity gauge
+            fig_gauge = go.Figure(go.Indicator(
+                mode = "gauge+number+delta",
+                value = similarity_score * 100,
+                domain = {'x': [0, 1], 'y': [0, 1]},
+                title = {'text': "Voice Similarity Score"},
+                delta = {'reference': 80},
+                gauge = {
+                    'axis': {'range': [None, 100]},
+                    'bar': {'color': "darkblue"},
+                    'steps': [
+                        {'range': [0, 50], 'color': "lightgray"},
+                        {'range': [50, 80], 'color': "gray"}
+                    ],
+                    'threshold': {
+                        'line': {'color': "red", 'width': 4},
+                        'thickness': 0.75,
+                        'value': 90
+                    }
+                }
+            ))
+            
+            st.plotly_chart(fig_gauge, use_container_width=True)
         
-    except Exception as e:
-        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
+        # Download Options
+        st.subheader("💾 Download Options")
         
-        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}")
+        col1, col2, col3 = st.columns(3)
         
-        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"
-    )
-
-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("---")
+        with col1:
+            st.download_button(
+                label="⬇️ Download WAV",
+                data=cloned_bytes,
+                file_name=f"voice_cloned_{datetime.now().strftime('%Y%m%d_%H%M%S')}.wav",
+                mime="audio/wav"
+            )
+        
+        with col2:
+            # Convert to MP3 and download
+            if st.button("⬇️ Download MP3"):
+                st.info("MP3 conversion feature coming soon!")
+        
+        with col3:
+            # Save as voice profile
+            profile_name = st.text_input("Voice Profile Name:", placeholder="My Voice Clone")
+            if st.button("💾 Save Profile") and profile_name:
+                st.session_state.voice_profiles[profile_name] = {
+                    'audio_data': cloned_data['reference_voice'],
+                    'sample_rate': cloned_data['sample_rate'],
+                    'created': datetime.now().isoformat()
+                }
+                st.success(f"✅ Voice profile '{profile_name}' saved!")
     
-    col1, col2, col3 = st.columns([1, 2, 1])
-    with col2:
-        if st.button("🚀 Start Advanced Voice Processing", type="primary", use_container_width=True):
-            
-            st.session_state.conversion_count += 1
+    # Voice Profile Manager
+    if st.session_state.voice_profiles:
+        st.markdown("---")
+        st.subheader("👤 Voice Profile Manager")
+        
+        for profile_name, profile_data in st.session_state.voice_profiles.items():
+            col1, col2, col3 = st.columns([2, 1, 1])
             
-            # 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 col1:
+                st.write(f"**{profile_name}**")
+                st.caption(f"Created: {profile_data['created']}")
             
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as target_tmp:
-                target_tmp.write(target_file.getvalue())
-                target_path = target_tmp.name
+            with col2:
+                audio_bytes = AudioProcessor.audio_to_bytes(
+                    profile_data['audio_data'], 
+                    profile_data['sample_rate']
+                )
+                st.audio(audio_bytes, format='audio/wav')
             
-            # Show processing status
-            with st.spinner("🤖 Processing with Advanced Voice Algorithms..."):
-                progress_bar = st.progress(0)
-                status_text = st.empty()
-                
-                # Processing steps
-                steps = [
-                    ("🔍 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:
-                    status_text.markdown(f"**{step_text}**")
-                    progress_bar.progress(progress)
-                    st.sleep(1)
-                
-                # 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;">✨ Voice Processing Complete! 🎉</h2>
-                        <p>Your AI-powered voice transformation is ready!</p>
-                    </div>
-                    """, unsafe_allow_html=True)
-                    
-                    # Display original vs processed
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        st.markdown("### 🎵 Original Source Audio")
-                        st.audio(source_file.getvalue())
-                    
-                    with col2:
-                        st.markdown("### 🎤 **Processed Voice Result**")
-                        st.audio(processed_audio, sample_rate=sample_rate)
-                    
-                    # Download section
-                    st.markdown("### 💾 Download Your Processed Audio")
-                    
-                    # Create downloadable file
-                    output_buffer = io.BytesIO()
-                    sf.write(output_buffer, processed_audio, sample_rate, format='WAV')
-                    
-                    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("### 📊 Processing Statistics")
-                    col1, col2, col3, col4 = st.columns(4)
-                    
-                    with col1:
-                        st.metric("Total Processed", st.session_state.conversion_count)
-                    with col2:
-                        st.metric("Sample Rate", f"{sample_rate} Hz")
-                    with col3:
-                        st.metric("Duration", f"{len(processed_audio)/sample_rate:.1f}s")
-                    with col4:
-                        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.")
-                
-                finally:
-                    # Cleanup
-                    try:
-                        os.unlink(source_path)
-                        os.unlink(target_path)
-                    except:
-                        pass
-
-else:
-    # 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 col3:
+                if st.button(f"🗑️ Delete", key=f"del_{profile_name}"):
+                    del st.session_state.voice_profiles[profile_name]
+                    st.rerun()
     
-    **💡 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; color: #666; padding: 2rem;">
+            🎭 <strong>AI Voice Clone Studio</strong> - Advanced Voice Cloning Technology<br>
+            Transform any voice into any other voice with state-of-the-art AI<br>
+            <small>⚠️ Use responsibly and with consent from voice owners</small>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
 
-# 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>🚀 Powered by Advanced Voice Processing</h3>
-    <p>Real voice transformation using librosa and advanced signal processing | Tamil optimized</p>
-</div>
-""", unsafe_allow_html=True)
+if __name__ == "__main__":
+    main()