Rust voice activity detection

Crate: aic-sdk = "=0.25.0". Core SDK: 0.25.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)

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) -> f32

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)

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.

EnergyVadContext

pub struct EnergyVadContext { /* private fields */ }

Created by Processor::energy_vad_context or awaited ProcessorAsync::energy_vad_context. Implements Drop; no public constructor. It detects speech from the processor’s enhanced signal before output mixing, without running a separate model, and advances with Processor::process rather than its own call. All handles from one processor reference the same energy VAD, and every method maps to a native call usable from any thread, so a context can be moved to another thread while audio is processed elsewhere. Creating one keeps inference active even when the processor is bypassed or fully dry. Dropping the backing processor stops new predictions; dropping the context destroys neither the processor nor its detection.

EnergyVadContext::is_speech_detected

pub fn is_speech_detected(&self) -> bool

Returns the energy VAD’s prediction. It lags its input by prediction_delay samples; align speech decisions to the input timeline using that value. The prediction stops updating if the backing processor stops being processed.

EnergyVadContext::set_parameter

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

Stores a parameter for the energy VAD. VadParameter::Sensitivity takes the energy range, 1.0 through 15.0. Out-of-range values return ParameterOutOfRange. All parameters can be changed during processing, from any thread.

EnergyVadContext::parameter

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

Returns the stored parameter value.

EnergyVadContext::prediction_delay

pub fn prediction_delay(&self) -> usize

Returns prediction lag in samples, covering input reblocking, STFT and enhancement model processing. It equals ProcessorContext::audio_delay for the backing processor; energy detection adds no audio delay. Speech hold and minimum speech duration affect decision timing and are not included.

EnergyVadContext::reset

pub fn reset(&self)

Clears the energy VAD state and the published prediction. Parameters are retained and the backing processor is not reset; ProcessorContext::reset also resets this VAD.

VadParameter

pub enum VadParameter { SpeechHoldDuration, Sensitivity, MinimumSpeechDuration }

Named parameter selectors, used by both VadContext and EnergyVadContext. 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

Its meaning depends on the detector. On a VadContext, a probability threshold, 0.0 through 1.0: a probability strictly greater than this value contributes a positive frame, so a lower threshold is more permissive. On an EnergyVadContext, the energy threshold of the enhanced signal, computed as 10 ^ (-sensitivity) over 1.0 through 15.0, so higher values detect quieter speech.

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)

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())
}

​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

​EnergyVadContext

​EnergyVadContext::is_speech_detected

​EnergyVadContext::set_parameter

​EnergyVadContext::parameter

​EnergyVadContext::prediction_delay

​EnergyVadContext::reset

​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