Rust voice activity detection

Crate: aic-sdk = "=0.24.0". Core SDK: 0.24.0. Source: released crate. Signatures are declarations; import the named types from aic_sdk. See the Rust guide for a complete runnable program.

Vad

pub struct Vad<'a> { /* private fields */ }

Stateful dedicated VAD. Feed original mono audio, independently of enhancement; processing leaves input unchanged. Use one instance per stream and read predictions from its context. Implements Drop, Send and Sync; borrowed model bytes must outlive the detector. Mutable access serializes processing and initialization.

Vad::new

pub fn new(model: &Model<'a>, license_key: &str) -> Result<Self, AicError>

Creates an uninitialized detector. The model must be a dedicated VAD model; an enhancement model returns ModelTypeUnsupported. Credentials are an SDK key or JWT.

Vad::with_otel_config

pub fn with_otel_config(
    model: &Model<'a>,
    license_key: &str,
    otel_config: &OtelConfig,
) -> Result<Self, AicError>

Creates an uninitialized detector with explicit copied telemetry settings. Invalid credentials return license errors; a NUL-containing session ID returns Internal.

Vad::with_config

pub fn with_config(self, config: &ProcessorConfig) -> Result<Self, AicError>

Consumes the detector, initializes it and returns it on success. A failure drops the consumed detector.

Vad::initialize

pub fn initialize(&mut self, config: &ProcessorConfig) -> Result<(), AicError>

Copies and validates the audio configuration. Unsupported settings return AudioConfigUnsupported. This allocates; run it outside the audio callback. Reinitialize successfully after any failed reconfiguration.

Vad::process

pub fn process(&mut self, audio: &[f32]) -> Result<(), AicError>

Reads normalized mono samples and updates detector state; returns no audio. Use exactly the configured block length, or a slice up to that length when variable blocks are enabled. Errors include NotInitialized, AudioConfigMismatch and ProcessingNotAllowed. Read predictions after successful processing.

Vad::context

pub fn context(&self) -> VadContext

Creates a shared prediction/control handle. Multiple handles refer to the same detector. Native failure is asserted and can panic.

Vad::terminate_session

pub fn terminate_session(&mut self) -> Result<(), AicError>

Requests permanent session termination for this detector. Stop processing first and use a new object for another session. This may block and is unsuitable for the audio callback. Native work becomes disallowed when the lifecycle task handles the signal; with other sessions alive that can occur after return.

VadContext

pub struct VadContext { /* private fields */ }

Created by Vad::context or awaited VadAsync::context. Implements Drop, Send and Sync; no public constructor. It permits cross-thread prediction reads and parameter control while the detector processes elsewhere. Predictions stop updating when audio is no longer processed.

VadContext::is_speech_detected

pub fn is_speech_detected(&self) -> bool

Returns the latest post-processed decision. It lags the input by prediction_delay() samples; do not treat a stale decision as a new inference.

VadContext::raw_vad_probability

pub fn raw_vad_probability(&self) -> f32

Returns the latest model probability without SDK hold/threshold post-processing. It has the same input alignment delay.

VadContext::set_parameter

pub fn set_parameter(&self, parameter: VadParameter, value: f32) -> Result<(), AicError>

Stores a parameter for the detector. Out-of-range or NaN values return ParameterOutOfRange. Effective transitions are quantized to model frames.

VadContext::parameter

pub fn parameter(&self, parameter: VadParameter) -> Result<f32, AicError>

Returns the stored parameter value. Duration readback is the requested value; it is not a promise of exact transition timing. Defaults are model-specific.

VadContext::prediction_delay

pub fn prediction_delay(&self) -> usize

Returns prediction lag in samples at the configured input rate, including reblocking and model buffering. This delay is not applied to the input audio and is independent of enhancement audio delay. Value-returning native queries assert success and can panic on internal failures.

VadContext::reset

pub fn reset(&self) -> Result<(), AicError>

Immediately clears the published decision to false and raw probability to 0.0, and requests processing-state reset on the next block. Audio configuration remains initialized. A terminated session is not reopened.

VadContext::update_bearer_token

pub fn update_bearer_token(&self, token: &str) -> Result<(), AicError>

Updates a JWT only when the original and new credentials are JWTs; otherwise returns TokenUpdateUnsupported. Embedded NUL returns LicenseFormatInvalid. Local success does not prove backend acceptance; keep handling processing errors.

VadParameter

pub enum VadParameter { SpeechHoldDuration, Sensitivity, MinimumSpeechDuration }

Named parameter selectors. Implements Debug, Clone, Copy, PartialEq, Eq and Hash, plus native parameter conversion. Read defaults from the active context.

VadParameter::SpeechHoldDuration

VadParameter::SpeechHoldDuration

Duration in seconds controlling the speech-to-silence transition. Range: 0.0 through 300 times the model frame duration. The effective duration is rounded to model frames. When the current probability is at or below threshold, speech remains detected while at least half the approximately 2 * duration history was above threshold.

VadParameter::Sensitivity

VadParameter::Sensitivity

Probability threshold, 0.0 through 1.0. A probability strictly greater than this value contributes a positive frame. A lower threshold is more permissive.

VadParameter::MinimumSpeechDuration

VadParameter::MinimumSpeechDuration

Duration in seconds required for consecutive above-threshold frames to turn speech detection on. Range: 0.0 through 1.0. Effective timing is rounded to model frames; the stored value can differ from the effective duration.

VadAsync

pub struct VadAsync { /* private fields */ }

Requires feature: async. Uses the same shared worker pool and per-instance mutex as async enhancement. Constructors are synchronous, model data must be static, and async operations should be awaited in stream order. The type is Send and Sync; share through Arc when needed.

VadAsync::new

pub fn new(model: &Model<'static>, license_key: &str) -> Result<Self, AicError>

Creates an uninitialized dedicated detector. Model and credential errors match Vad::new.

VadAsync::with_otel_config

pub fn with_otel_config(
    model: &Model<'static>,
    license_key: &str,
    otel_config: &OtelConfig,
) -> Result<Self, AicError>

Creates an uninitialized detector with copied telemetry settings.

VadAsync::with_config

pub async fn with_config(self, config: &ProcessorConfig) -> Result<Self, AicError>

Consumes the detector and awaits initialization. Failure drops the consumed object.

VadAsync::initialize

pub async fn initialize(&self, config: &ProcessorConfig) -> Result<(), AicError>

Copies settings and initializes on the shared worker pool. Errors match Vad::initialize.

VadAsync::process

pub async fn process(&self, audio: Vec<f32>) -> Result<Vec<f32>, AicError>

Consumes the vector, reads it on the processing pool and returns it unchanged on success. Updates the prediction. On failure the vector is dropped. This Rust return value differs from Python VAD’s None result; input length and errors match Vad::process.

VadAsync::terminate_session

pub async fn terminate_session(&self) -> Result<(), AicError>

Waits for exclusive access and requests termination. Stop submitting audio first; use a new object for another session. Await the method, but do not treat completion as proof that native signal handling or remote usage acknowledgment has finished when other sessions remain alive.

VadAsync::context

pub async fn context(&self) -> VadContext

Waits for exclusive access and returns a context. Internal native context creation failure can panic. See configuration, errors and the symbol index.

Read a prediction

The caller supplies an initialized dedicated detector and a normalized mono block. Prediction is read only after successful processing:

use aic_sdk::{AicError, Vad};

fn detect_block(vad: &mut Vad<'_>, audio: &[f32]) -> Result<bool, AicError> {
    let context = vad.context();
    vad.process(audio)?;
    Ok(context.is_speech_detected())
}

SDK

API reference

Upgrades

LiveKit

AI tools

Historical migrations

Rust voice activity detection

Vad

Vad::new

Vad::with_otel_config

Vad::with_config

Vad::initialize

Vad::process

Vad::context

Vad::terminate_session

VadContext

VadContext::is_speech_detected

VadContext::raw_vad_probability

VadContext::set_parameter

VadContext::parameter

VadContext::prediction_delay

VadContext::reset

VadContext::update_bearer_token

VadParameter

VadParameter::SpeechHoldDuration

VadParameter::Sensitivity

VadParameter::MinimumSpeechDuration

VadAsync

VadAsync::new

VadAsync::with_otel_config

VadAsync::with_config

VadAsync::initialize

VadAsync::process

VadAsync::terminate_session

VadAsync::context

Read a prediction

​Vad

​Vad::new

​Vad::with_otel_config

​Vad::with_config

​Vad::initialize

​Vad::process

​Vad::context

​Vad::terminate_session

​VadContext

​VadContext::is_speech_detected

​VadContext::raw_vad_probability

​VadContext::set_parameter

​VadContext::parameter

​VadContext::prediction_delay

​VadContext::reset

​VadContext::update_bearer_token

​VadParameter

​VadParameter::SpeechHoldDuration

​VadParameter::Sensitivity

​VadParameter::MinimumSpeechDuration

​VadAsync

​VadAsync::new

​VadAsync::with_otel_config

​VadAsync::with_config

​VadAsync::initialize

​VadAsync::process

​VadAsync::terminate_session

​VadAsync::context

​Read a prediction

Vad

Vad::new

Vad::with_otel_config

Vad::with_config

Vad::initialize

Vad::process

Vad::context

Vad::terminate_session

VadContext

VadContext::is_speech_detected

VadContext::raw_vad_probability

VadContext::set_parameter

VadContext::parameter

VadContext::prediction_delay

VadContext::reset

VadContext::update_bearer_token

VadParameter

VadParameter::SpeechHoldDuration

VadParameter::Sensitivity

VadParameter::MinimumSpeechDuration

VadAsync

VadAsync::new

VadAsync::with_otel_config

VadAsync::with_config

VadAsync::initialize

VadAsync::process

VadAsync::terminate_session

VadAsync::context

Read a prediction