add vad update_silence_ms adapter

transcribe/helpers/vadprocessor.py

@@ -9,6 +9,38 @@ import logging
 from datetime import timedelta
 import gc
 from pydub import AudioSegment
+from collections import deque
+
+class AdaptiveSilenceController:
+    def __init__(self, base_silence_ms=120, min_ms=50, max_ms=600):
+        self.base = base_silence_ms
+        self.min = min_ms
+        self.max = max_ms
+        self.recent_silences = deque(maxlen=20)
+        self.recent_speeches = deque(maxlen=20)
+
+    def update_silence(self, duration_ms):
+        self.recent_silences.append(duration_ms)
+
+    def update_speech(self, duration_ms):
+        self.recent_speeches.append(duration_ms)
+
+    def get_adaptive_silence_ms(self):
+        # 1. 快速说话特征：平均语音段长度短（如 < 250ms）
+        avg_speech = np.mean(self.recent_speeches) if self.recent_speeches else self.base
+        avg_silence = np.mean(self.recent_silences) if self.recent_silences else self.base
+
+        # 2. 快速语音则缩短 silence 阈值
+        speed_factor = 1.0
+        if avg_speech < 300:
+            speed_factor = 0.5
+        elif avg_speech < 600:
+            speed_factor = 0.8
+
+        # 3. silence 的变化趋势也考虑进去
+        adaptive = self.base * speed_factor + 0.3 * avg_silence
+
+        return int(max(self.min, min(self.max, adaptive)))
 
     
 class OnnxWrapper():

transcribe/pipelines/pipe_vad.py

@@ -1,12 +1,12 @@
 
 from .base import MetaItem, BasePipe
-from ..helpers.vadprocessor import FixedVADIterator, SileroVADProcessor
+from ..helpers.vadprocessor import FixedVADIterator, AdaptiveSilenceController
 
 import numpy as np
 from silero_vad import get_speech_timestamps
 from typing import List
 import logging
-
+import time
 # import noisereduce as nr
 
 
@@ -18,11 +18,16 @@ class VadPipe(BasePipe):
         super().__init__(in_queue, out_queue)
         self._offset = 0 # 处理的frame size offset
         self._status = 'END'
-
+        self.last_state_change_offset = 0
+        self.adaptive_ctrl = AdaptiveSilenceController()
+    
 
     def reset(self):
         self._offset = 0
         self._status = 'END'
+        self.last_state_change_offset = 0
+        self.adaptive_ctrl = AdaptiveSilenceController()
+        self.vac.reset_states()
 
     @classmethod
     def init(cls):
@@ -48,32 +53,53 @@ class VadPipe(BasePipe):
             relative_end_frame = None
             start_frame, end_frame = speech_dict.get("start"), speech_dict.get("end")
             if start_frame:
-                relative_start_frame = start_frame - self._offset
+                relative_start_frame =start_frame - self._offset
             if end_frame:
                 relative_end_frame = max(0, end_frame - self._offset)
             return relative_start_frame, relative_end_frame
-
+        
+    def update_silence_ms(self):
+        min_silence = self.adaptive_ctrl.get_adaptive_silence_ms()
+        logging.debug(f"🫠 update_silence_ms :{min_silence} ")
+        self.vac.min_silence_duration_ms = min_silence
+    
     def process(self, in_data: MetaItem) -> MetaItem:
         if self._offset == 0:
             self.vac.reset_states()
+       
         # silence_audio_100ms = np.zeros(int(0.1*self.sample_rate))
         source_audio = np.frombuffer(in_data.source_audio, dtype=np.float32)
         speech_data  = self._process_speech_chunk(source_audio)
 
         if speech_data: # 表示有音频的变化点出现
-            rel_start_frame, rel_end_frame = speech_data
+            self.update_silence_ms()
+            rel_start_frame, rel_end_frame = speech_data 
             if rel_start_frame is not None and rel_end_frame is None:
                 self._status = "START" # 语音开始
                 target_audio = source_audio[rel_start_frame:]
+
+                 # 计算上一段静音长度
+                silence_len = (self._offset + rel_start_frame - self.last_state_change_offset) / self.sample_rate * 1000
+                self.adaptive_ctrl.update_silence(silence_len)
+                self.last_state_change_offset = self._offset + rel_start_frame
+                
                 logging.debug("🫸 Speech start frame: {}".format(rel_start_frame))
             elif rel_start_frame is None and rel_end_frame is not None:
                 self._status = "END" # 音频结束
                 target_audio = source_audio[:rel_end_frame]
+
+                speech_len = (rel_end_frame) / self.sample_rate * 1000
+                self.adaptive_ctrl.update_speech(speech_len)
+                self.last_state_change_offset = self._offset + rel_end_frame
                 logging.debug(" 🫷Speech ended, capturing audio up to frame: {}".format(rel_end_frame))
             else:
                 self._status = 'END'
                 target_audio = source_audio[rel_start_frame:rel_end_frame]
                 logging.debug(" 🔄 Speech segment captured from frame {} to frame {}".format(rel_start_frame, rel_end_frame))
+
+                seg_len = (rel_end_frame - rel_start_frame) / self.sample_rate * 1000
+                self.adaptive_ctrl.update_speech(seg_len)
+                self.last_state_change_offset = self._offset + rel_end_frame
                 # logging.debug("❌ No valid speech segment detected, setting status to END")
         else:
             if self._status == 'START':