Spaces:
Running
Running
| """ | |
| utils/tts_utils.py | |
| ────────────────── | |
| Hindi Text-to-Speech using gTTS (Google TTS via HTTP — free, no API key). | |
| Why gTTS over Coqui? | |
| - Coqui TTS Hindi models are large (1–2GB) and slow on CPU | |
| - gTTS is instant, free, and produces natural Hindi speech | |
| - No model download, no GPU needed | |
| - Works perfectly on Hugging Face Spaces | |
| Architecture: | |
| - Each translated segment → individual Hindi MP3 → WAV | |
| - Silence gaps are inserted between segments to match original timing | |
| - All segment WAVs are concatenated into one full dub track | |
| """ | |
| import os | |
| import gc | |
| import tempfile | |
| from typing import List, Dict, Callable, Optional | |
| from gtts import gTTS | |
| from pydub import AudioSegment | |
| # ── Available speaker "voices" ─────────────────────────────────────────────── | |
| # gTTS supports TLD variants which subtly affect the accent/voice | |
| SPEAKER_OPTIONS = { | |
| "Hindi (India — Standard)": "com", | |
| "Hindi (India — Alternate)": "co.in", | |
| } | |
| def _text_to_wav(text: str, tld: str, out_path: str, speed_factor: float = 1.0) -> str: | |
| """ | |
| Convert a Hindi text string to a WAV audio file. | |
| Parameters: | |
| text – Hindi text | |
| tld – gTTS top-level domain for voice accent | |
| out_path – where to save the WAV | |
| speed_factor – NOT used by gTTS directly; we use pydub speedup instead | |
| """ | |
| if not text.strip(): | |
| # Return a short silence for empty segments | |
| silence = AudioSegment.silent(duration=500) | |
| silence.export(out_path, format="wav") | |
| return out_path | |
| # Generate TTS (outputs MP3) | |
| mp3_path = out_path.replace(".wav", ".mp3") | |
| tts = gTTS(text=text, lang="hi", tld=tld, slow=False) | |
| tts.save(mp3_path) | |
| # Convert MP3 → WAV for consistent processing | |
| audio = AudioSegment.from_mp3(mp3_path) | |
| audio.export(out_path, format="wav") | |
| # Clean up MP3 | |
| try: | |
| os.remove(mp3_path) | |
| except Exception: | |
| pass | |
| return out_path | |
| def _fit_speech_to_duration(speech: AudioSegment, target_duration_ms: int) -> AudioSegment: | |
| """ | |
| Speed up or slow down speech to (roughly) fit the original segment duration. | |
| Strategy: | |
| - If speech is too long (> 130% of target), speed it up moderately | |
| - If speech is too short, pad with trailing silence | |
| - We don't slow down speech (sounds unnatural) — just pad instead | |
| This is the lightweight alternative to full lip-sync. | |
| """ | |
| speech_dur = len(speech) | |
| if speech_dur == 0 or target_duration_ms == 0: | |
| return speech | |
| ratio = speech_dur / target_duration_ms | |
| if ratio > 1.3: | |
| # Speed up: increase frame rate (pitch changes too, but acceptable) | |
| # pydub speedup: multiply frame_rate | |
| speed_multiplier = min(ratio, 1.8) # cap at 1.8× to stay intelligible | |
| sped = speech._spawn( | |
| speech.raw_data, | |
| overrides={"frame_rate": int(speech.frame_rate * speed_multiplier)}, | |
| ).set_frame_rate(speech.frame_rate) | |
| return sped | |
| elif speech_dur < target_duration_ms: | |
| # Pad with silence at end | |
| pad = AudioSegment.silent(duration=target_duration_ms - speech_dur) | |
| return speech + pad | |
| return speech | |
| def generate_hindi_speech( | |
| segments: List[Dict], | |
| speaker: str = "com", | |
| speech_volume: float = 1.2, | |
| progress_callback: Optional[Callable] = None, | |
| ) -> str: | |
| """ | |
| Generate a full Hindi dubbed audio track from translated segments. | |
| Process: | |
| 1. For each segment, generate Hindi TTS audio | |
| 2. Speed-fit to match original segment duration | |
| 3. Insert silence between segments to preserve original timing | |
| 4. Concatenate everything into one WAV file | |
| Returns path to the final dubbed WAV file. | |
| """ | |
| if not segments: | |
| raise ValueError("No segments to synthesise") | |
| # Figure out total audio duration from last segment end time | |
| total_duration_ms = int(max(s["end"] for s in segments) * 1000) + 2000 | |
| # Start with a silent base track (we'll fill it with speech) | |
| full_track = AudioSegment.silent(duration=total_duration_ms) | |
| temp_dir = tempfile.gettempdir() | |
| n = len(segments) | |
| for i, seg in enumerate(segments): | |
| if progress_callback: | |
| progress_callback( | |
| int((i + 1) / n * 90), | |
| f"Synthesising segment {i+1}/{n}…" | |
| ) | |
| hindi_text = seg.get("hindi_text", "").strip() | |
| if not hindi_text: | |
| continue # skip segments with no translation | |
| # Target duration in milliseconds | |
| seg_start_ms = int(seg["start"] * 1000) | |
| seg_end_ms = int(seg["end"] * 1000) | |
| target_ms = seg_end_ms - seg_start_ms | |
| # Generate speech WAV for this segment | |
| wav_path = os.path.join(temp_dir, f"seg_{i:04d}.wav") | |
| try: | |
| _text_to_wav(hindi_text, tld=speaker, out_path=wav_path) | |
| except Exception as e: | |
| # If TTS fails for a segment, just leave silence there | |
| continue | |
| # Load generated speech | |
| speech = AudioSegment.from_wav(wav_path) | |
| # Optionally boost volume | |
| if speech_volume != 1.0: | |
| import math | |
| db_boost = 20 * math.log10(speech_volume) | |
| speech = speech + db_boost | |
| # Fit speech duration to original segment duration | |
| speech = _fit_speech_to_duration(speech, target_ms) | |
| # Overlay speech onto the silent base track at the right position | |
| full_track = full_track.overlay(speech, position=seg_start_ms) | |
| # Clean up temp file | |
| try: | |
| os.remove(wav_path) | |
| except Exception: | |
| pass | |
| gc.collect() | |
| # Export final dubbed track | |
| output_path = os.path.join(temp_dir, "hindi_dubbed_audio.wav") | |
| full_track.export(output_path, format="wav") | |
| return output_path | |