Struct VadAsync 

pub struct VadAsync { /* private fields */ }

Available on crate feature async only.

A wrapper around Vad for use in async contexts.

Threading

Processing runs on the same background thread pool as ProcessorAsync, shared across all instances. The pool defaults to one thread per logical CPU. Override with the AIC_NUM_THREADS environment variable, which is read once on first use.

Example

use aic_sdk::{Model, ProcessorConfig, VadAsync};
#[tokio::main]
async fn main() -> Result<(), aic_sdk::AicError> {
    let license_key = std::env::var("AIC_SDK_LICENSE").unwrap();
    let model = Model::from_file("/path/to/vad_model.aicmodel")?;
    let config = ProcessorConfig::optimal(&model);

    let vad = VadAsync::new(&model, &license_key)?.with_config(&config).await?;
    let vad_ctx = vad.context().await;

    let mut audio = vec![0.0f32; config.block_size];
    for _ in 0..2 {
        // `process` hands the block back, so the same allocation can be reused.
        audio = vad.process(audio).await?;
        println!("Speech detected: {}", vad_ctx.is_speech_detected());
    }
    Ok(())
}

Implementations

impl VadAsync

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

Creates a new async voice activity detector instance.

See Vad::new for details.

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

Creates a new async voice activity detector instance with explicit OpenTelemetry configuration.

See Vad::with_otel_config for details.

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

Initializes the async VAD with the given configuration.

This is a convenience method that calls VadAsync::initialize internally and returns self.

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

Initializes the VAD with the given configuration.

See Vad::initialize for details.

Warning

This allocates memory internally. Do not call from latency-sensitive paths.

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

Processes mono audio and updates the VAD prediction.

This method takes ownership of audio, moves it to a background processing thread, and returns the audio block unmodified. Ownership is required because the background thread outlives the borrow if this future is cancelled; handing the block back lets a streaming loop reuse the same allocation for every block.

See Vad::process for details.

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

Terminates the telemetry session associated with this VAD.

See Vad::terminate_session for details.

Warning

This may block until the session is terminated, so it runs on the background thread pool rather than the calling task.

pub async fn context(&self) -> VadContext

Returns a VadContext to read the prediction and control parameters.

See Vad::context for details.