Implement Silero TTS for Hindi - natural neural voice (v3_en_indic + hindi_female)

backend/app/multilingual_tts.py

@@ -110,26 +110,41 @@ class MultilingualTTSService:
             print("[MultilingualTTSService] ✓ English vocoder loaded")
     
     def _load_hindi_models(self):
-        """Load Hindi models - using Google Text-to-Speech (gTTS)."""
+        """Load Hindi Silero TTS model - natural neural voice."""
         if self._xtts_model is None:
-            print("[MultilingualTTSService] Loading Hindi support (gTTS)...")
+            print("[MultilingualTTSService] Loading Hindi Silero TTS model...")
             try:
-                from gtts import gTTS
-                print("[MultilingualTTSService] ✓ Hindi gTTS support loaded")
-                print("[MultilingualTTSService]   Engine: Google Text-to-Speech (gTTS)")
-                print("[MultilingualTTSService]   Language: Hindi (hin)")
-                print("[MultilingualTTSService]   TOS: No (Google Cloud)")
-                # Mark as loaded (gTTS doesn't require actual model loading)
-                self._xtts_model = True
+                import torch
+                
+                # Load Silero TTS v3_en_indic model for Indic languages (includes Hindi)
+                # Returns (model, example_text) tuple
+                result = torch.hub.load(
+                    repo_or_dir='snakers4/silero-models',
+                    model='silero_tts',
+                    language='en',
+                    speaker='v3_en_indic',
+                    trust_repo=True
+                )
+                
+                if isinstance(result, tuple):
+                    self._xtts_model, _ = result
+                else:
+                    self._xtts_model = result
+                
+                print("[MultilingualTTSService] ✓ Hindi Silero TTS loaded successfully")
+                print("[MultilingualTTSService]   Engine: Silero TTS (Neural v3_en_indic)")
+                print("[MultilingualTTSService]   Language: Hindi (hindi_female speaker)")
+                print("[MultilingualTTSService]   Voice: Natural female voice")
+                print("[MultilingualTTSService]   TOS: No (Open source)")
                     
-            except ImportError:
+            except ImportError as e:
                 raise ImportError(
-                    "gTTS library required for Hindi support. "
-                    "Install with: pip install gtts"
+                    "Torch required for Silero TTS. "
+                    "Install with: pip install torch"
                 )
             except Exception as e:
-                print(f"[MultilingualTTSService] Error loading Hindi support: {e}")
-                raise RuntimeError(f"Failed to load Hindi support: {e}")
+                print(f"[MultilingualTTSService] Error loading Silero TTS: {e}")
+                raise RuntimeError(f"Failed to load Hindi Silero model: {e}")
     
     def synthesize(self, text: str, voice_sample_path: Union[str, Path],
                   language: str = "english") -> np.ndarray:
@@ -188,41 +203,30 @@ class MultilingualTTSService:
         return np.clip(synthesized, -1.0, 1.0)
     
     def _synthesize_hindi(self, text: str, voice_sample_path: Union[str, Path]) -> np.ndarray:
-        """Synthesize Hindi speech using Google Text-to-Speech (gTTS)."""
+        """Synthesize Hindi speech using Silero TTS neural model."""
         self._load_hindi_models()
         
         print(f"[MultilingualTTSService] Synthesizing Hindi: {text[:50]}...")
         
         try:
-            from gtts import gTTS
-            import io
-            from pydub import AudioSegment
-            
-            # Generate speech using Google TTS
-            tts = gTTS(text=text, lang='hi', slow=False)
-            
-            # Save to BytesIO buffer
-            buffer = io.BytesIO()
-            tts.write_to_fp(buffer)
-            buffer.seek(0)
-            
-            # Load audio from buffer
-            audio_segment = AudioSegment.from_mp3(buffer)
+            # Silero TTS returns Tensor directly
+            audio = self._xtts_model.apply_tts(
+                text=text,
+                speaker='hindi_female'
+            )
             
-            # Convert to numpy array (mono, float32)
-            samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+            # Convert Tensor to numpy
+            if isinstance(audio, torch.Tensor):
+                audio = audio.numpy()
             
-            # Handle stereo to mono conversion
-            if audio_segment.channels == 2:
-                # Convert stereo to mono by averaging channels
-                samples = samples.reshape((-1, 2)).mean(axis=1)
+            audio = np.asarray(audio, dtype=np.float32)
             
-            # Normalize to [-1, 1] range
-            max_val = np.max(np.abs(samples))
-            if max_val > 0:
-                samples = samples / (32767.0 if audio_segment.sample_width == 2 else 128.0)
+            # Normalize to [-1, 1] range (audio is in [-1, 1] from Silero already)
+            max_val = np.max(np.abs(audio))
+            if max_val > 1.0:
+                audio = audio / max_val
             
-            return np.clip(samples, -1.0, 1.0)
+            return np.clip(audio, -1.0, 1.0)
             
         except Exception as e:
             print(f"[MultilingualTTSService] Error during Hindi synthesis: {e}")

backend/requirements.txt

@@ -15,4 +15,4 @@ inflect==7.0.0
 unidecode>=1.3.2
 webrtcvad==2.0.10
 demucs==4.0.1
-gtts==2.4.0
+omegaconf==2.3.0