Rust audio analysis

Crate: aic-sdk = "=0.24.0". Core SDK: 0.24.0. Source: released crate. These APIs do not require the async feature. Import types from aic_sdk; signatures below are declarations.

analyzer_pair

pub fn analyzer_pair<'a>(
    model: &Model<'a>,
    license_key: &str,
) -> Result<(Collector, Analyzer<'a>), AicError>

Creates a collector and analyzer for a Tyto analysis model and an SDK key or JWT. The collector buffers a model-defined span of audio; new audio replaces older samples. Run expensive analysis separately from collection. Invalid credentials, incompatible model types and native creation failures return AicError. The pair shares native audio state. Retained model storage keeps weights available after dropping the model handle; borrowed model bytes must still outlive the analyzer. There are no public Collector::new or Analyzer::new constructors. This function accepts no OtelConfig. Its native creation path disables optional OpenTelemetry export; SDK authorization and session reporting requirements remain separate.

Collector

pub struct Collector { /* private fields */ }

A buffering handle created by analyzer_pair. Implements Drop, Send and Sync; it is not Clone. Collection uses mutable access and can run on a separate thread from the paired analyzer. Dropping it releases its native handle.

Collector::initialize

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

Configures the actual input rate and sample count. Use ProcessorConfig::optimal(model) as a starting point. The configuration is copied; unsupported combinations return AudioConfigUnsupported. This allocates and must run outside the audio callback.

Collector::buffer

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

Reads normalized mono samples without modifying the slice. Requires initialization and the configured length, or a length up to block_size with variable blocks enabled. Returns NotInitialized or AudioConfigMismatch when applicable. The call buffers audio; it does not return a score or perform the expensive analysis forward pass.

Analyzer

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

Analyzes audio buffered by the paired collector. Implements Drop, Send and Sync; it is not Clone. Mutable access serializes analysis and termination. The lifetime keeps borrowed model bytes alive; native handles retain model storage. Dropping the analyzer releases its handle and requests session shutdown.

Analyzer::reset

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

Requests reset of the shared collector state. The next collection pass clears buffered/delayed state while preserving configuration. Until then, analysis uses a zero-filled snapshot instead of the previously published audio. Use this at an application stream boundary; reset does not restore authorization or reopen a terminated session.

Analyzer::analyze_buffered

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

Runs the model over the latest buffered span and returns a score snapshot. Incomplete initial input is padded with silence. This is blocking computation and must run outside the audio callback. Authorization failures return ProcessingNotAllowed with no result. Repeated calls without fresh audio are not fresh independent observations.

Analyzer::terminate_session

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

Requests session termination. Stop analysis and treat the session as closed. Native work becomes disallowed when the lifecycle task handles the signal; with other sessions alive this can happen after the method returns. It may block for final-session shutdown. Success is not a universal remote usage acknowledgment. Create a new pair for another session.

Analyzer::update_bearer_token

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

Updates a JWT in a session originally created with a JWT. Returns TokenUpdateUnsupported for unsupported credential types and LicenseFormatInvalid for embedded NUL characters. Local replacement does not prove backend acceptance; keep checking analysis errors.

FileAnalyzer

pub struct FileAnalyzer<'model, 'a> { /* private fields */ }

Convenience analysis for a mono buffer already decoded into memory. It does not open or decode an audio file. It owns a collector/analyzer pair and borrows the Model itself for 'model; keep that model handle alive, as well as any bytes borrowed for 'a. This is stricter than using analyzer_pair directly. Its owned fields release native resources on drop. There is no public token-update, reset or session-termination method on this type. Use Analyzer directly when those lifecycle controls are required. Calls require mutable access and must be serialized.

FileAnalyzer::new

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

Creates the internal pair for a Tyto model. The collector is initialized by each analyze call, allowing different input rates on subsequent calls. Credential and model errors match analyzer_pair.

FileAnalyzer::analyze

pub fn analyze(
    &mut self,
    audio: &[f32],
    sample_rate: u32,
    step_samples: Option<usize>,
) -> Result<Vec<AnalysisResult>, AicError>

Reads normalized mono samples at their actual sample_rate, leaving the slice unchanged. The native collector handles supported non-native rates; this method does not mix channels. It initializes the collector at the model’s preferred block size and analyzes independent five-second windows. step_samples is the advance between window starts. None uses 5 * sample_rate; smaller positive values overlap windows and larger values leave gaps. Rate zero or step zero returns AudioConfigUnsupported, as does an unsupported native configuration. Other initialization, buffering or analysis errors propagate as AicError without a partial result vector. Empty input and buffers up to five seconds produce one silence-padded result. Longer buffers produce only complete windows on the step grid starting at zero; partial trailing windows are omitted. Each window resets the analysis/collection state. The operation allocates and performs blocking computation; run it outside the audio callback.

AnalysisResult

pub struct AnalysisResult {
    pub risk_score: f32,
    pub speaker_reverb: f32,
    pub speaker_loudness: f32,
    pub interfering_speech: f32,
    pub noise: f32,
    pub codec_degradation: f32,
    pub packet_loss: f32,
}

An owned score snapshot. Its public fields are writable Rust values; changing them does not change the analyzer. Implements Debug, Clone and PartialEq, plus conversion from the native result struct. Values returned by the model lie between 0.0 and 1.0. They are not calibrated failure probabilities for your downstream system.

Field	Interpretation
`risk_score: f32`	Overall audio risk for downstream speech processing; lower is less problematic
`speaker_reverb: f32`	Speaker distance/reverberance; lower is less problematic
`speaker_loudness: f32`	Relative loudness dimension; lower is not universally better
`interfering_speech: f32`	Interference from other speakers; lower is less problematic
`noise: f32`	Ambient/environmental noise; lower is less problematic
`codec_degradation: f32`	Lossy codec artifacts; lower is less problematic
`packet_loss: f32`	Dropouts/discontinuities; lower is less problematic

Borrowing example

This reference function accepts a loaded Tyto model, decoded mono audio and a credential from its caller. Use the Rust guide for project setup.

use aic_sdk::{AicError, AnalysisResult, FileAnalyzer, Model};

fn analyze_audio(
    model: &Model<'_>,
    sdk_key: &str,
    audio: &[f32],
    sample_rate: u32,
) -> Result<Vec<AnalysisResult>, AicError> {
    let mut analyzer = FileAnalyzer::new(model, sdk_key)?;
    analyzer.analyze(audio, sample_rate, None)
}

See Tyto analysis, errors and features and the symbol index.

SDK

API reference

Upgrades

LiveKit

AI tools

Historical migrations

analyzer_pair

Collector

Collector::initialize

Collector::buffer

Analyzer

Analyzer::reset

Analyzer::analyze_buffered

Analyzer::terminate_session

Analyzer::update_bearer_token

FileAnalyzer

FileAnalyzer::new

FileAnalyzer::analyze

AnalysisResult

Borrowing example

​analyzer_pair

​Collector

​Collector::initialize

​Collector::buffer

​Analyzer

​Analyzer::reset

​Analyzer::analyze_buffered

​Analyzer::terminate_session

​Analyzer::update_bearer_token

​FileAnalyzer

​FileAnalyzer::new

​FileAnalyzer::analyze

​AnalysisResult

​Borrowing example

analyzer_pair

Collector

Collector::initialize

Collector::buffer

Analyzer

Analyzer::reset

Analyzer::analyze_buffered

Analyzer::terminate_session

Analyzer::update_bearer_token

FileAnalyzer

FileAnalyzer::new

FileAnalyzer::analyze

AnalysisResult

Borrowing example