| """Causal bounded PCM speech gate; no ASR weights or transcript decisions.""" |
| import hashlib |
| from pathlib import Path |
| import time |
| import numpy as np |
| from .stream import PCMReader, StreamProfile, require |
|
|
| MODEL_SHA256='1a153a22f4509e292a94e67d6f9b85e8deb25b4988682b7e174c65279d8788e3' |
| POLICY='silero_v5_threshold0.5_silence2000ms_preroll400ms_v1' |
|
|
| class Silero: |
| def __init__(self,path): |
| import onnxruntime as ort |
| require(hashlib.sha256(Path(path).read_bytes()).hexdigest()==MODEL_SHA256,'Silero model identity') |
| options=ort.SessionOptions(); options.intra_op_num_threads=1; options.inter_op_num_threads=1 |
| options.execution_mode=ort.ExecutionMode.ORT_SEQUENTIAL |
| options.graph_optimization_level=ort.GraphOptimizationLevel.ORT_DISABLE_ALL |
| self.session=ort.InferenceSession(str(path),sess_options=options,providers=['CPUExecutionProvider']) |
| self.session.disable_fallback() |
| require(self.session.get_providers()==['CPUExecutionProvider'],'Silero CPU execution required') |
| self.state=np.zeros((2,1,128),np.float32); self.context=np.zeros(64,np.float32) |
| self.sr=np.array(16000,dtype=np.int64); self.version=ort.__version__ |
| def probability(self,frame): |
| require(frame.shape==(512,) and frame.dtype==np.float32 and np.isfinite(frame).all(),'VAD new512 finite samples') |
| window=np.concatenate((self.context,frame))[None,:] |
| probability,state=self.session.run(['output','stateN'],{'input':window,'state':self.state,'sr':self.sr}) |
| require(probability.shape==(1,1) and probability.dtype==np.float32 and np.isfinite(probability).all(),'VAD probability shape/type') |
| require(state.shape==(2,1,128) and state.dtype==np.float32 and np.isfinite(state).all(),'VAD state shape/type') |
| p=float(probability[0,0]); require(0<=p<=1,'VAD probability range') |
| self.state=state; self.context=frame[-64:].copy(); return p |
|
|
| class GatedPCM: |
| def __init__(self,stream,detector,pace_start=None): |
| self.reader=PCMReader(stream); self.detector=detector; self.pace_start=pace_start |
| self.profile=StreamProfile('realtime18',3) |
| self.read_seconds=self.sleep_seconds=self.vad_seconds=0. |
| self.vad_frames=self.segment_count=self.selected_samples=self.unconsumed_samples=0 |
| self.finished=False |
| def __iter__(self): |
| require(not self.finished,'gated source already consumed') |
| self.finished=True |
| reader=self.reader; active=None; previous_end=0; next_index=0; closing=False |
| while True: |
| if active is not None: |
| start,end=self.profile.bounds(next_index) |
| source_start=active['start_sample']+max(0,start-self.profile.left_samples) |
| source_end=active['start_sample']+end-self.profile.left_samples |
| terminal=self.profile.emissions_at_eof(reader.samples-active['start_sample']) |
| eligible=(next_index<terminal) if reader.eof else source_end<=reader.samples |
| if eligible: |
| output=np.zeros(end-start,np.float32) |
| stop=min(source_end,reader.samples) |
| if stop>source_start: |
| require(source_start>=reader.base,'gated source overlap discarded') |
| offset=source_start-reader.base; count=stop-source_start |
| require(offset+count<=len(reader.buffer),'gated overlap unavailable') |
| dst=self.profile.left_samples+source_start-active['start_sample']-start |
| output[dst:dst+count]=reader.buffer[offset:offset+count] |
| consumed=max(consumed,stop) |
| event=dict(kind='window',segment=dict(active),index=next_index,audio=output, |
| nominal_source_end_sample=source_end,available_sample=reader.samples,eof_drain=source_end>reader.samples) |
| next_index+=1; yield event; continue |
| if closing or reader.eof: |
| unconsumed=reader.samples-consumed |
| self.selected_samples+=reader.samples-active['start_sample']; self.unconsumed_samples+=unconsumed |
| yield dict(kind='end',segment=dict(active),end_sample=reader.samples,final_eof=reader.eof, |
| unconsumed_samples=unconsumed,windows=next_index) |
| previous_end=reader.samples; active=None |
| if reader.eof: break |
| keep=max(0,reader.samples-6400) |
| if active is not None: |
| next_start=self.profile.bounds(next_index)[0] |
| keep=min(keep,active['start_sample']+max(0,next_start-self.profile.left_samples)) |
| keep=max(reader.base,min(keep,reader.samples)) |
| reader.buffer=reader.buffer[keep-reader.base:].copy(); reader.base=keep |
| before=reader.samples; began=time.monotonic(); reader.ensure(before+512) |
| self.read_seconds+=time.monotonic()-began |
| require(len(reader.buffer)<=6912,'gated bounded PCM retention') |
| if self.pace_start is not None: |
| duration=max(0.,self.pace_start+reader.samples/16000-time.monotonic()) |
| began=time.monotonic() |
| if duration:time.sleep(duration) |
| self.sleep_seconds+=time.monotonic()-began |
| if reader.samples-before<512:continue |
| frame=reader.buffer[before-reader.base:before-reader.base+512] |
| began=time.monotonic(); p=self.detector(frame); self.vad_seconds+=time.monotonic()-began |
| require(type(p) is not bool and np.isfinite(p) and 0<=p<=1,'VAD finite probability') |
| self.vad_frames+=1 |
| if p>=.5: |
| last_voice=reader.samples |
| if active is None: |
| active=dict(id=self.segment_count,start_sample=max(previous_end,reader.samples-6400),decision_sample=reader.samples) |
| self.segment_count+=1; next_index=0; closing=False; consumed=active['start_sample'] |
| yield dict(kind='start',segment=dict(active)) |
| elif active is not None and reader.samples-last_voice>=32000:closing=True |
| yield dict(kind='complete') |
|
|
