Rust

[package]
name = "aic-rust-quickstart"
version = "0.1.0"
edition = "2024"

[dependencies]
aic-sdk = { version = "=0.24.0", features = ["download-lib"] }
aic-sdk-sys = "=0.24.0"
hound = "=3.5.1"

use aic_sdk::{Model, Processor, ProcessorConfig};
use hound::{SampleFormat, WavReader, WavSpec, WavWriter};
use std::error::Error;

fn run() -> Result<(), Box<dyn Error>> {
    let key = std::env::var("AIC_SDK_LICENSE")
        .map_err(|_| "Set AIC_SDK_LICENSE to your SDK key, then retry.")?;
    if key.is_empty() || key == "YOUR_SDK_KEY" {
        return Err("Set AIC_SDK_LICENSE to your SDK key, then retry.".into());
    }
    let mut reader = WavReader::open("input.wav")?;
    let spec = reader.spec();
    if spec.channels != 1 || spec.sample_rate != 16000 || spec.bits_per_sample != 16 ||
        spec.sample_format != SampleFormat::Int || reader.duration() == 0 || reader.duration() > 960000 {
        return Err("Use a nonempty mono, 16 kHz, PCM16 input.wav, at most 60 seconds.".into());
    }
    let input: Vec<f32> = reader.samples::<i16>()
        .map(|sample| sample.map(|value| value as f32 / 32768.0))
        .collect::<Result<_, _>>()?;
    let model = Model::from_file("model.aicmodel")?;
    let config = ProcessorConfig {
        sample_rate: 16000,
        block_size: model.optimal_block_size(16000),
        variable_block_size: false,
    };
    let mut processor = Processor::new(&model, &key)?.with_config(&config)?;
    let delay = processor.context().audio_delay();
    let padded_count = input.len().checked_add(delay)
        .and_then(|n| n.checked_add(config.block_size - 1))
        .ok_or("Audio buffer size overflow")? / config.block_size * config.block_size;
    let mut output = vec![0.0_f32; padded_count];
    output[..input.len()].copy_from_slice(&input);
    for block in output.chunks_exact_mut(config.block_size) {
        processor.process(block)?;
    }
    // Flush with silence, then omit the initial delay to align the files.
    let enhanced = &output[delay..delay + input.len()];
    if enhanced.iter().any(|sample| !sample.is_finite()) {
        return Err("Non-finite output sample; no output written.".into());
    }
    let mut writer = WavWriter::create("enhanced.wav", WavSpec {
        channels: 1, sample_rate: 16000, bits_per_sample: 32, sample_format: SampleFormat::Float,
    })?;
    for &sample in enhanced { writer.write_sample(sample)?; }
    writer.finalize()?;
    println!("SDK {}, model {}", aic_sdk::get_sdk_version(), model.id());
    println!("Processed {} samples at 16000 Hz; wrote enhanced.wav", input.len());
    // Drop releases the processor and ends its session, including on an error return.
    Ok(())
}

fn main() {
    if let Err(error) = run() {
        eprintln!("{error}");
        std::process::exit(1);
    }
}