Check point 4

app.py

@@ -8,6 +8,7 @@ import os
 import urllib.request
 import torchaudio
 from scipy.spatial.distance import cosine
+from scipy.signal import resample
 from RealtimeSTT import AudioToTextRecorder
 from fastapi import FastAPI, APIRouter
 from fastrtc import Stream, AsyncStreamHandler
@@ -419,7 +420,7 @@ class RealtimeSpeakerDiarization:
             # Setup recorder configuration
             recorder_config = {
                 'spinner': False,
-                'use_microphone': False,  # Explicitly set to False - we'll feed audio via FastRTC
+                'use_microphone': False,  # Using FastRTC for audio input
                 'model': FINAL_TRANSCRIPTION_MODEL,
                 'language': TRANSCRIPTION_LANGUAGE,
                 'silero_sensitivity': SILERO_SENSITIVITY,
@@ -456,8 +457,11 @@ class RealtimeSpeakerDiarization:
     def run_transcription(self):
         """Run the transcription loop"""
         try:
+            logger.info("Starting transcription thread")
             while self.is_running:
-                self.recorder.text(self.process_final_text)
+                # Just check for final text from recorder, audio is fed externally via FastRTC
+                text = self.recorder.text(self.process_final_text)
+                time.sleep(0.01)  # Small sleep to prevent CPU hogging
         except Exception as e:
             logger.error(f"Transcription error: {e}")
     
@@ -559,14 +563,30 @@ class RealtimeSpeakerDiarization:
                 if embedding is not None:
                     self.speaker_detector.add_embedding(embedding)
             
-            # Feed audio to the RealtimeSTT recorder
-            if self.recorder:
-                # Convert float32 audio to int16 bytes format for RealtimeSTT
-                audio_bytes = (audio_data * 32768.0).astype(np.int16).tobytes()
-                self.recorder.feed_audio(audio_bytes)
+            # Feed audio to RealtimeSTT recorder
+            if self.recorder and self.is_running:
+                # Convert float32 [-1.0, 1.0] to int16 for RealtimeSTT
+                int16_data = (audio_data * 32768.0).astype(np.int16).tobytes()
+                if sample_rate != 16000:
+                    int16_data = self.resample_audio(int16_data, sample_rate, 16000)
+                self.recorder.feed_audio(int16_data)
                     
         except Exception as e:
             logger.error(f"Error processing audio chunk: {e}")
+    
+    def resample_audio(self, audio_bytes, from_rate, to_rate):
+        """Resample audio to target sample rate"""
+        try:
+            audio_np = np.frombuffer(audio_bytes, dtype=np.int16)
+            num_samples = len(audio_np)
+            num_target_samples = int(num_samples * to_rate / from_rate)
+            
+            resampled = resample(audio_np, num_target_samples)
+            
+            return resampled.astype(np.int16).tobytes()
+        except Exception as e:
+            logger.error(f"Error resampling audio: {e}")
+            return audio_bytes
 
 
 # FastRTC Audio Handler
@@ -598,7 +618,9 @@ class DiarizationHandler(AsyncStreamHandler):
             if isinstance(audio_data, bytes):
                 audio_array = np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
             elif isinstance(audio_data, (list, tuple)):
-                audio_array = np.array(audio_data, dtype=np.float32)
+                sample_rate, audio_array = audio_data
+                if isinstance(audio_array, (list, tuple)):
+                    audio_array = np.array(audio_array, dtype=np.float32)
             else:
                 audio_array = np.array(audio_data, dtype=np.float32)
             
@@ -636,18 +658,7 @@ class DiarizationHandler(AsyncStreamHandler):
 
 # Global instances
 diarization_system = RealtimeSpeakerDiarization()
-
-# FastAPI setup for FastRTC integration
-app = FastAPI()
-
-# Initialize an empty handler (will be set properly in initialize_system function)
-audio_handler = DiarizationHandler(diarization_system)
-
-# Create FastRTC stream
-stream = Stream(handler=audio_handler)
-
-# Include FastRTC router in FastAPI app
-app.include_router(stream.router, prefix="/stream")
+audio_handler = None
 
 def initialize_system():
     """Initialize the diarization system"""
@@ -656,8 +667,6 @@ def initialize_system():
         success = diarization_system.initialize_models()
         if success:
             audio_handler = DiarizationHandler(diarization_system)
-            # Update the stream's handler
-            stream.handler = audio_handler
             return "✅ System initialized successfully!"
         else:
             return "❌ Failed to initialize system. Check logs for details."
@@ -665,13 +674,6 @@ def initialize_system():
         logger.error(f"Initialization error: {e}")
         return f"❌ Initialization error: {str(e)}"
 
-# Add startup event to initialize the system
-@app.on_event("startup")
-async def startup_event():
-    logger.info("Initializing diarization system on startup...")
-    result = initialize_system()
-    logger.info(f"Initialization result: {result}")
-
 def start_recording():
     """Start recording and transcription"""
     try:
@@ -857,6 +859,9 @@ def create_interface():
     return interface
 
 
+# FastAPI setup for FastRTC integration
+app = FastAPI()
+
 @app.get("/")
 async def root():
     return {"message": "Real-time Speaker Diarization API"}
@@ -898,6 +903,12 @@ async def api_update_settings(threshold: float, max_speakers: int):
     result = update_settings(threshold, max_speakers)
     return {"result": result}
 
+# FastRTC Stream setup
+if audio_handler:
+    stream = Stream(handler=audio_handler)
+    app.include_router(stream.router, prefix="/stream")
+
+
 # Main execution
 if __name__ == "__main__":
     import argparse