Struct VadProcessor 

pub struct VadProcessor<V: VadAnalyzer> { /* private fields */ }

A FrameProcessor that runs a VadAnalyzer over inbound audio and emits the VAD edge + lifecycle frames.

On each Frame::InputAudio it buffers PCM into analyzer-sized windows, runs the analyzer, and translates QUIET↔SPEAKING transitions into:

• rising edge → Frame::VadUserStartedSpeaking + Frame::UserStartedSpeaking, and (if the bot is speaking) a broadcast Frame::Interruption (barge-in);
• falling edge → Frame::VadUserStoppedSpeaking + Frame::UserStoppedSpeaking.

The original InputAudio frame is always forwarded downstream (STT/turn stages still need the raw audio). Tracks bot-speaking state from Frame::BotStartedSpeaking/Frame::BotStoppedSpeaking so interruption is only broadcast while the bot holds the floor (pipecat barge-in semantics).

Implementations

impl<V: VadAnalyzer> VadProcessor<V>

pub fn new(analyzer: V, window_samples: usize) -> Self

Wrap analyzer, consuming window_samples-sample windows. Barge-in interruption is enabled by default.

pub fn without_barge_in_interruption(self) -> Self

Disable broadcasting Interruption on barge-in (the turn controller may own interruption via an InterruptionStrategy).

Trait Implementations

impl<V: VadAnalyzer + 'static> FrameProcessor for VadProcessor<V>

fn name(&self) -> &str

Stable, human-readable name (observer events, error attribution, tracing).

fn start<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _setup: &'life1 ProcessorSetup, params: &'life2 StartParams, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Called once when the Frame::Start frame reaches this processor, before any data frame. Open sockets / spawn provider readers here. Default: no-op.

fn process_frame<'life0, 'life1, 'async_trait>( &'life0 mut self, env: Envelope, link: &'life1 Link, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle one frame. Push results via link. Must not block: long work (a provider round-trip) is driven by an internally-spawned task that feeds results back as frames. The default impl forwards the frame unchanged in its direction — so a pure observer/no-op processor is process_frame = default.

fn stop<'life0, 'async_trait>( &'life0 mut self, _reason: StopReason, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Called on End/Stop/Cancel after the terminal frame is forwarded. Flush + close. Default: no-op.

fn can_generate_metrics(&self) -> bool

Whether this processor produces metrics (pipecat can_generate_metrics, :395). Services override to true.