Update app.py

app.py

@@ -1,79 +1,112 @@
-from flask import Flask, request, jsonify, send_file
-from flask_cors import CORS
+import gradio as gr
 from encoder import inference as encoder_inference
 from synthesizer.inference import Synthesizer
 from vocoder import inference as vocoder_inference
 import librosa
 import soundfile as sf
+import numpy as np
 from io import BytesIO
 import os
 
-app = Flask(__name__)
-CORS(app)
-
-# Load models once at startup
+# Load models at startup
 print("Loading models...")
 encoder_inference.load_model("saved_models/encoder.pt")
 synthesizer = Synthesizer("saved_models/synthesizer.pt")
 vocoder_inference.load_model("saved_models/vocoder.pt")
 print("✓ Models loaded!")
 
-@app.route('/health', methods=['GET'])
-def health():
-    return jsonify({"status": "ok"}), 200
-
-@app.route('/clone', methods=['POST'])
-def clone_voice():
-    """Clone voice and synthesize speech"""
+def clone_voice(voice_sample, text):
+    """Clone voice and generate speech"""
     try:
-        # Get text and voice sample
-        text = request.form.get('text')
-        voice_sample = request.files.get('voice_sample')
+        if voice_sample is None:
+            return None, "Error: No voice sample provided"
+        
+        if not text or len(text.strip()) == 0:
+            return None, "Error: No text provided"
         
-        if not text or not voice_sample:
-            return jsonify({"error": "Missing 'text' or 'voice_sample'"}), 400
+        # Extract audio data and sample rate
+        if isinstance(voice_sample, tuple):
+            sr, audio_data = voice_sample
+            wav = audio_data.astype(np.float32) / 32768.0
+        else:
+            wav, sr = librosa.load(voice_sample, sr=16000)
         
-        # Save uploaded file temporarily
-        temp_path = f"/tmp/{voice_sample.filename}"
-        voice_sample.save(temp_path)
+        print(f"Audio loaded: sr={sr}, shape={wav.shape}")
         
-        # Load and preprocess audio
-        wav, sr = librosa.load(temp_path, sr=16000)
+        # Resample if needed
+        if sr != 16000:
+            wav = librosa.resample(wav, orig_sr=sr, target_sr=16000)
+        
+        # Preprocess audio
         wav = encoder_inference.preprocess_wav(wav)
+        print(f"Preprocessed audio: {wav.shape}")
         
         # Generate speaker embedding
         embed = encoder_inference.embed_utterance(wav)
+        print(f"Speaker embedding: {embed.shape}")
         
-        # Synthesize speech
+        # Synthesize
         mels = synthesizer.synthesize_spectrograms([text], [embed])
+        print(f"Mel-spectrogram: {mels[0].shape}")
         
         # Vocode to audio
-        audio = vocoder_inference.vocoder(mels[0])
-        
-        # Save to bytes
-        audio_io = BytesIO()
-        sf.write(audio_io, audio, 22050, format='WAV')
-        audio_io.seek(0)
-        
-        # Cleanup
-        os.remove(temp_path)
+        wav_generated = vocoder_inference.vocoder(mels[0])
+        print(f"Generated audio: {wav_generated.shape}")
         
-        return send_file(audio_io, mimetype='audio/wav', as_attachment=True, download_name='cloned_voice.wav')
+        return (22050, (wav_generated * 32768).astype(np.int16)), "✓ Success!"
     
     except Exception as e:
-        return jsonify({"error": str(e)}), 400
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return None, f"Error: {str(e)}"
 
-@app.route('/', methods=['GET'])
-def index():
-    return '''
-    <h1>Voice Cloning API</h1>
-    <p>POST to /clone with:</p>
-    <ul>
-        <li>text: Hindi/Kannada text to synthesize</li>
-        <li>voice_sample: WAV/OGG audio file (5-10 seconds)</li>
-    </ul>
-    <p>Returns: WAV audio with cloned voice</p>
-    '''
+# Create Gradio interface
+with gr.Blocks(title="Voice Cloning - Real-Time Test") as demo:
+    gr.Markdown("# 🎤 Voice Cloning Test")
+    gr.Markdown("Record your voice, enter text, and hear it synthesized in your voice!")
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Step 1: Record Your Voice")
+            voice_input = gr.Audio(
+                label="Record or Upload Voice Sample (5-10 seconds)",
+                type="numpy",
+                sources=["microphone", "upload"]
+            )
+            
+            gr.Markdown("### Step 2: Enter Text")
+            text_input = gr.Textbox(
+                label="Text to Synthesize (Hindi or Kannada)",
+                placeholder="नमस्ते, यह एक परीक्षण है",
+                lines=3
+            )
+        
+        with gr.Column():
+            gr.Markdown("### Step 3: Generated Speech")
+            audio_output = gr.Audio(label="Cloned Voice Output", type="numpy")
+            status_output = gr.Textbox(label="Status", interactive=False)
+    
+    clone_button = gr.Button("🎯 Clone Voice & Generate Speech", variant="primary", size="lg")
+    clone_button.click(
+        clone_voice,
+        inputs=[voice_input, text_input],
+        outputs=[audio_output, status_output]
+    )
+    
+    gr.Markdown("""
+    ### Instructions:
+    1. **Record your voice** using the microphone (5-10 seconds in Hindi/Kannada) OR upload a WAV/OGG file
+    2. **Enter text** you want to generate in your voice (Hindi or Kannada)
+    3. **Click "Clone Voice & Generate Speech"**
+    4. **Wait** (10-30 seconds on CPU) and hear the result!
+    
+    ### Tips:
+    - Clearer voice samples = better results
+    - Longer samples (10 seconds) = better voice cloning
+    - Same language as input voice works best
+    - Be patient - CPU processing takes time!
+    """)
 
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, debug=False)
+if __name__ == "__main__":
+    demo.launch(share=True)