Struct StreamingPipeline 

pub struct StreamingPipeline<V, E> { /* private fields */ }

Stateful streaming diarization pipeline.

Generic over a VoiceActivityDetector V and an Embedder E. Speaker assignment uses an AOSC-style ArrivalOrderSpeakerCache (bounded, arrival-order IDs, provisional→stable labels, prefer-current hysteresis).

Implementations

impl<V, E> StreamingPipeline<V, E>

where V: VoiceActivityDetector, E: Embedder,

pub fn new( vad: V, extractor: E, config: DiarizationConfig, vad_config: VadConfig, ) -> Result<Self, StreamingError>

Create a new streaming pipeline with explicit diarization + VAD config.

Uses balanced-equivalent cache defaults derived from config.cluster (max_speakers as cache cap, threshold as match threshold) and the balanced stability knobs (min_hits_to_stable = 3, prefer-current margin 0.08). Prefer Self::with_latency_preset for named latency modes.

Errors

Returns VadError::InvalidChunkSize if the VAD frame_size is zero and StreamingError::InvalidParams if the config’s window geometry is not positive and ordered (0 < hop_secs <= window_secs).

pub fn with_latency_preset( vad: V, extractor: E, preset: LatencyPreset, vad_config: VadConfig, ) -> Result<Self, StreamingError>

Construct a pipeline from a named LatencyPreset.

Applies the preset’s window geometry onto a default DiarizationConfig and installs the matching cache / stability parameters.

pub fn with_params( vad: V, extractor: E, config: DiarizationConfig, vad_config: VadConfig, params: StreamingParams, ) -> Result<Self, StreamingError>

Construct with full control over diarization config and streaming params.

params.speaker_cache_cap == 0 is clamped to 1, matching the max_speakers.max(1) policy of Self::new.

Errors

Returns VadError::InvalidChunkSize if the VAD frame_size is zero and StreamingError::InvalidParams if the window geometry is not positive and ordered (0 < hop_secs <= window_secs, yielding at least one sample each at the configured sample rate).

pub fn params(&self) -> StreamingParams

Active streaming parameters (window, cache cap, stability knobs).

pub fn latency_preset(&self) -> Option<LatencyPreset>

Named preset if the pipeline was built via Self::with_latency_preset.

pub fn speaker_cache_cap(&self) -> usize

Hard cap on the speaker cache (params.speaker_cache_cap).

pub fn cache_len(&self) -> usize

Current number of cache entries (always <= speaker_cache_cap()).

pub fn feed( &mut self, samples: &[f32], ) -> Result<Vec<SpeakerTurn>, StreamingError>

Feed a chunk of audio samples and return any newly finalized speaker turns.

The pipeline internally buffers samples until a full VAD frame is available, then runs the frame through VAD, speech detection, and — during active speech — extracts embeddings and assigns speakers incrementally.

Callers should feed chunks as they arrive from the audio source (e.g. microphone). There is no minimum chunk size; sub-frame chunks are buffered transparently.

Returned turns may have stable: false (provisional); see module docs.

VAD frame contract

The detector’s native frame size must equal VadConfig::frame_size, so each buffered frame yields exactly one probability (see the trait’s frame contract). A mismatch is rejected with StreamingError::VadFrameMismatch on the first frame instead of silently shifting every derived timestamp.

pub fn flush(&mut self) -> Result<Vec<SpeakerTurn>, StreamingError>

Flush any pending audio and return final speaker turns.

This finalizes an in-flight speech region (if any), extracts the last embedding window, and clears all internal buffers. After flush the pipeline is ready to process a new stream (or the same stream after a gap) via subsequent feed calls.

pub fn num_speakers(&self) -> usize

Return the number of distinct speakers observed so far.

pub fn turns(&self) -> &[SpeakerTurn]

Return all turns emitted so far (including those from prior feed calls).

History is cumulative across feed/flush; flush does not reset it. Construct a new pipeline for a fresh history.