Update app.py

app.py

@@ -11,6 +11,7 @@ import string
 import re
 import urllib.request
 import gzip
+import tempfile
 
 # Set cache environment
 os.environ['HF_HOME'] = '/tmp/hf'
@@ -1020,7 +1021,7 @@ def get_expected_phonemes(words: List[str]) -> List[str]:
     return results
 
 async def generate_tts_audio(word: str) -> str:
-    """Generate TTS audio for a word"""
+    """Generate TTS audio for a word with silence padding"""
     if word in tts_cache:
         return tts_cache[word]
     
@@ -1032,17 +1033,81 @@ async def generate_tts_audio(word: str) -> str:
                 audio_data += chunk["data"]
         
         if audio_data:
-            audio_b64 = base64.b64encode(audio_data).decode('utf-8')
-            tts_cache[word] = audio_b64
-            return audio_b64
+            # Add silence padding to TTS audio as well
+            # First decode the MP3 to get raw audio
+            import tempfile
+            with tempfile.NamedTemporaryFile(suffix='.mp3', delete=False) as tmp_mp3:
+                tmp_mp3.write(audio_data)
+                tmp_mp3_path = tmp_mp3.name
+            
+            try:
+                # Load the TTS audio
+                tts_waveform, tts_sample_rate = torchaudio.load(tmp_mp3_path)
+                
+                # Resample if needed to match our standard rate
+                if tts_sample_rate != 16000:
+                    tts_waveform = torchaudio.transforms.Resample(tts_sample_rate, 16000)(tts_waveform)
+                    tts_sample_rate = 16000
+                
+                # Add 0.25s silence padding on each end
+                padding_samples = int(0.25 * tts_sample_rate)
+                silence_shape = list(tts_waveform.shape)
+                silence_shape[-1] = padding_samples
+                silence_padding = torch.zeros(silence_shape)
+                
+                # Concatenate: silence + audio + silence
+                padded_waveform = torch.cat([silence_padding, tts_waveform, silence_padding], dim=-1)
+                
+                # Convert back to base64
+                buffer = io.BytesIO()
+                torchaudio.save(buffer, padded_waveform, tts_sample_rate, format="wav")
+                buffer.seek(0)
+                audio_b64 = base64.b64encode(buffer.read()).decode('utf-8')
+                
+                tts_cache[word] = audio_b64
+                log(f"🔇 TTS for '{word}': Added 0.25s silence padding on each end")
+                return audio_b64
+                
+            finally:
+                # Clean up temp file
+                if os.path.exists(tmp_mp3_path):
+                    os.remove(tmp_mp3_path)
+                    
     except Exception as e:
         log(f"TTS failed for '{word}': {e}")
     
     return ""
 
-def audio_to_base64(audio_segment: torch.Tensor, sample_rate: int) -> str:
-    """Convert audio tensor to base64 string"""
+def audio_to_base64(audio_segment: torch.Tensor, sample_rate: int, add_padding: bool = True) -> str:
+    """
+    Convert audio tensor to base64 string.
+    
+    Args:
+        audio_segment: The audio tensor to convert
+        sample_rate: Sample rate of the audio
+        add_padding: If True, adds 0.25s of silence on each end to prevent audio processor lag
+    
+    Returns:
+        Base64 encoded audio string
+    """
     try:
+        if add_padding:
+            # Add 0.25 seconds of silence on each end
+            padding_samples = int(0.25 * sample_rate)  # 0.25 seconds worth of samples
+            
+            # Create silence padding (zeros with same shape as audio segment)
+            silence_shape = list(audio_segment.shape)
+            silence_shape[-1] = padding_samples
+            silence_padding = torch.zeros(silence_shape)
+            
+            # Concatenate: silence + audio + silence
+            padded_segment = torch.cat([silence_padding, audio_segment, silence_padding], dim=-1)
+            
+            log(f"🔇 Added silence padding: {padding_samples} samples (0.25s) on each end")
+            log(f"   Original: {audio_segment.shape[-1]} samples → Padded: {padded_segment.shape[-1]} samples")
+            
+            audio_segment = padded_segment
+        
         buffer = io.BytesIO()
         torchaudio.save(buffer, audio_segment, sample_rate, format="wav")
         buffer.seek(0)
@@ -1399,15 +1464,16 @@ async def transcribe(audio: UploadFile = File(...), similarity_threshold: float
             })
             
             # Prepare audio data with all three segments (use ORIGINAL word for display)
-            user_audio_b64 = audio_to_base64(final_audio_segment, sample_rate)
-            whisperx_audio_b64 = audio_to_base64(whisperx_audio_segment, sample_rate)
-            expected_audio_b64 = tts_results[i]
+            # All three audio segments will have 0.25s silence padding added automatically
+            user_audio_b64 = audio_to_base64(final_audio_segment, sample_rate)  # Padded
+            whisperx_audio_b64 = audio_to_base64(whisperx_audio_segment, sample_rate)  # Padded
+            expected_audio_b64 = tts_results[i]  # Already padded in generate_tts_audio
             
             audio_data_list.append({
                 "word": word_original,  # Original with punctuation for display
-                "expected_audio": expected_audio_b64,
-                "user_audio": user_audio_b64,
-                "whisperx_audio": whisperx_audio_b64,  # NEW: Original WhisperX timing
+                "expected_audio": expected_audio_b64,  # TTS with padding
+                "user_audio": user_audio_b64,  # User's pronunciation with padding
+                "whisperx_audio": whisperx_audio_b64,  # WhisperX original with padding
                 "start_time": float(start_time),
                 "end_time": float(end_time),
                 "similarity_score": float(similarity_score),