Update core/silero_vad.py

core/silero_vad.py

@@ -17,8 +17,8 @@ class SileroVAD:
         self.is_streaming = False
         self.speech_callback = None
         self.audio_buffer = []
-        self.speech_buffer = []  # Buffer cho speech đang diễn ra
-        self.state = "silence"  # silence, speech, processing
+        self.speech_buffer = []
+        self.state = "silence"
         self.speech_start_time = 0
         self.last_voice_time = 0
         
@@ -32,7 +32,11 @@ class SileroVAD:
         
         # Buffer cho pre-speech
         self.pre_speech_samples = int(self.pre_speech_buffer * self.sample_rate)
-        self.pre_speech_buffer = []
+        self.pre_speech_buffer_data = []
+        
+        # Double buffer system để tránh mất dữ liệu
+        self.active_speech_buffer = []
+        self.backup_speech_buffer = []
         
         self._initialize_model()
 
@@ -61,11 +65,13 @@ class SileroVAD:
         self.speech_callback = speech_callback
         self.audio_buffer = []
         self.speech_buffer = []
-        self.pre_speech_buffer = []
+        self.pre_speech_buffer_data = []
+        self.active_speech_buffer = []
+        self.backup_speech_buffer = []
         self.state = "silence"
         self.speech_start_time = 0
         self.last_voice_time = 0
-        print("🎙️ Bắt đầu VAD streaming với cấu hình tối ưu...")
+        print("🎙️ Bắt đầu VAD streaming với double buffer system...")
         return True
 
     def stop_stream(self):
@@ -74,23 +80,30 @@ class SileroVAD:
         self.speech_callback = None
         self.audio_buffer = []
         self.speech_buffer = []
-        self.pre_speech_buffer = []
+        self.pre_speech_buffer_data = []
+        self.active_speech_buffer = []
+        self.backup_speech_buffer = []
         self.state = "silence"
         print("🛑 Đã dừng VAD streaming")
 
     def process_stream(self, audio_chunk: np.ndarray, sample_rate: int):
-        """Xử lý audio chunk với VAD tối ưu"""
+        """Xử lý audio chunk với VAD và double buffer"""
         if not self.is_streaming or self.model is None:
             return
 
         try:
-   
+            # Resample nếu cần
             if sample_rate != self.sample_rate:
                 audio_chunk = self._resample_audio(audio_chunk, sample_rate, self.sample_rate)
 
+            # Thêm vào audio buffer
             self.audio_buffer.extend(audio_chunk)
+            
+            # Đồng thời thêm vào backup buffer để tránh mất dữ liệu
+            if self.state == "speech":
+                self.backup_speech_buffer.extend(audio_chunk)
 
-
+            # Xử lý VAD theo chunks
             while len(self.audio_buffer) >= self.chunk_size:
                 chunk = self.audio_buffer[:self.chunk_size]
                 self._process_vad_chunk(np.array(chunk))
@@ -100,7 +113,7 @@ class SileroVAD:
             print(f"❌ Lỗi xử lý VAD: {e}")
 
     def _process_vad_chunk(self, audio_chunk: np.ndarray):
-        """Xử lý VAD cho một chunk - TỐI ƯU HÓA"""
+        """Xử lý VAD cho một chunk với double buffer"""
         current_time = time.time()
         
         # Chuẩn hóa audio
@@ -109,25 +122,28 @@ class SileroVAD:
         # Lấy xác suất speech
         speech_prob = self._get_speech_probability(audio_chunk)
         
-        # Logic state machine cải tiến
         if self.state == "silence":
             if speech_prob > self.speech_threshold:
                 print("🎤 Bắt đầu phát hiện speech")
                 self.state = "speech"
                 self.speech_start_time = current_time
                 self.last_voice_time = current_time
-                # Khởi tạo speech buffer với pre-speech data
-                self.speech_buffer = self.pre_speech_buffer.copy()
-                self.speech_buffer.extend(audio_chunk)
+                
+                # Khởi tạo cả active và backup buffer
+                self.active_speech_buffer = self.pre_speech_buffer_data.copy()
+                self.active_speech_buffer.extend(audio_chunk)
+                self.backup_speech_buffer = self.active_speech_buffer.copy()
+                
             else:
-                # Lưu pre-speech buffer (giới hạn kích thước)
-                self.pre_speech_buffer.extend(audio_chunk)
-                if len(self.pre_speech_buffer) > self.pre_speech_samples:
-                    self.pre_speech_buffer = self.pre_speech_buffer[-self.pre_speech_samples:]
+                # Lưu pre-speech buffer
+                self.pre_speech_buffer_data.extend(audio_chunk)
+                if len(self.pre_speech_buffer_data) > self.pre_speech_samples:
+                    self.pre_speech_buffer_data = self.pre_speech_buffer_data[-self.pre_speech_samples:]
                 
         elif self.state == "speech":
-            # Luôn thêm vào speech buffer
-            self.speech_buffer.extend(audio_chunk)
+            # Thêm vào cả hai buffers
+            self.active_speech_buffer.extend(audio_chunk)
+            self.backup_speech_buffer.extend(audio_chunk)
             
             # Cập nhật thời gian voice cuối cùng
             if speech_prob > self.speech_threshold:
@@ -137,9 +153,7 @@ class SileroVAD:
             silence_duration = current_time - self.last_voice_time
             speech_duration = current_time - self.speech_start_time
             
-            # 🎯 LOGIC KẾT THÚC THÔNG MINH - 3 TRƯỜNG HỢP:
-            
-            # 1. User nói ngắn (dưới min_speech) nhưng đã im lặng đủ lâu -> XỬ LÝ NGAY
+            # Logic kết thúc thông minh
             is_short_response = speech_duration < self.min_speech_duration
             is_long_silence_after_short = silence_duration >= self.min_silence_duration
             
@@ -147,31 +161,30 @@ class SileroVAD:
                 print(f"🎯 Phát hiện phản hồi ngắn: {speech_duration:.2f}s, im lặng: {silence_duration:.2f}s")
                 self._finalize_speech()
                 
-            # 2. User nói đủ dài VÀ im lặng đủ lâu -> XỬ LÝ BÌNH THƯỜNG
             elif (speech_duration >= self.min_speech_duration and 
                   silence_duration >= self.min_silence_duration):
                 print(f"🎯 Kết thúc speech dài: {speech_duration:.2f}s")
                 self._finalize_speech()
                 
-            # 3. Speech quá dài (timeout) -> XỬ LÝ DÙ ĐANG NÓI
             elif speech_duration > settings.MAX_AUDIO_DURATION:
                 print(f"⏰ Speech timeout ({speech_duration:.2f}s) - xử lý dù đang nói")
                 self._finalize_speech()
                 
         elif self.state == "processing":
-            # Đang xử lý, không nhận thêm audio
-            pass
+            # Trong khi đang xử lý, vẫn tiếp tục ghi vào backup buffer
+            self.backup_speech_buffer.extend(audio_chunk)
+
     def _finalize_speech(self):
-        """Hoàn thành xử lý speech segment"""
-        if not self.speech_buffer or len(self.speech_buffer) == 0:
-            self.state = "silence"
+        """Hoàn thành xử lý speech segment với buffer switching"""
+        if not self.active_speech_buffer:
+            self._reset_buffers()
             return
             
-        # Chuyển sang state processing để tránh nhận thêm audio
+        # Chuyển sang state processing
         self.state = "processing"
         
-        # Tạo audio array từ buffer
-        speech_audio = np.array(self.speech_buffer, dtype=np.float32)
+        # Sử dụng active buffer cho xử lý hiện tại
+        speech_audio = np.array(self.active_speech_buffer, dtype=np.float32)
         
         # Gọi callback trong thread riêng
         if self.speech_callback:
@@ -181,11 +194,19 @@ class SileroVAD:
                 daemon=True
             ).start()
         
-        # Reset buffers nhưng giữ pre-speech
-        self.speech_buffer = []
-        self.audio_buffer = []
+        # Chuẩn bị cho lần tiếp theo: chuyển backup buffer thành active buffer
+        self.active_speech_buffer = self.backup_speech_buffer.copy()
+        self.backup_speech_buffer = []
         
-        # Quay lại state silence sau khi xử lý
+        # Quay lại state speech để tiếp tục nhận dữ liệu
+        self.state = "speech"
+        self.last_voice_time = time.time()
+
+    def _reset_buffers(self):
+        """Reset tất cả buffers"""
+        self.active_speech_buffer = []
+        self.backup_speech_buffer = []
+        self.audio_buffer = []
         self.state = "silence"
 
     def _normalize_audio(self, audio: np.ndarray) -> np.ndarray:
@@ -232,7 +253,6 @@ class SileroVAD:
                 audio_chunk = self._resample_audio(audio_chunk, sample_rate, self.sample_rate)
             audio_chunk = self._normalize_audio(audio_chunk)
             
-            # Kiểm tra multiple chunks
             chunk_size = 512
             speech_probs = []