SDK Quickstart

npm install @ai-coustics/aic-sdk

const { Model, Processor } = require("@ai-coustics/aic-sdk");

// Get your license key from the environment variable
const licenseKey = process.env.AIC_SDK_LICENSE;

// Download and load a model (or download manually at https://artifacts.ai-coustics.io/)
const modelPath = Model.download("quail-vf-2.1-l-16khz", "./models");
const model = Model.fromFile(modelPath);

// Get optimal configuration
const sampleRate = model.getOptimalSampleRate();
const numFrames = model.getOptimalNumFrames(sampleRate);
const numChannels = 2;

// Create and initialize processor
const processor = new Processor(model, licenseKey);
processor.initialize(sampleRate, numChannels, numFrames, false);

// Process audio (Float32Array, interleaved: [L0, R0, L1, R1, ...])
const audioBuffer = new Float32Array(numChannels * numFrames);
processor.processInterleaved(audioBuffer);

cargo add aic-sdk --features "download-lib"

use aic_sdk::{include_model, ProcessorConfig, Model, Processor};

// Embed model at compile time (or use Model::from_file to load at runtime)
static MODEL: &'static [u8] = include_model!("/path/to/model.aicmodel");

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get your license key from the environment variable
    let license_key = std::env::var("AIC_SDK_LICENSE")?;

    // Load the embedded model (or download manually at https://artifacts.ai-coustics.io/)
    let model = Model::from_buffer(MODEL)?;

    // Get optimal configuration based on the selected model
    let config = ProcessorConfig::optimal(&model).with_num_channels(2);

    // Create a processor and initialize it
    let mut processor = Processor::new(&model, &license_key)?.with_config(&config)?;

    // Process audio (interleaved: channels × frames)
    let mut audio_buffer = vec![0.0f32; config.num_channels as usize * config.num_frames];
    processor.process_interleaved(&mut audio_buffer)?;

    Ok(())
}

include(FetchContent)

set(AIC_SDK_ALLOW_DOWNLOAD ON CACHE BOOL "Allow C SDK download at configure time")

FetchContent_Declare(
    aic_sdk
    GIT_REPOSITORY https://github.com/ai-coustics/aic-sdk-cpp.git
    GIT_TAG        0.21.0
    GIT_SHALLOW    TRUE
)
FetchContent_MakeAvailable(aic_sdk)

target_link_libraries(my_app PRIVATE aic-sdk)

#include "aic.hpp"

#include <vector>
#include <cstdlib>

int main() {
    // Get your license key from the environment variable
    const char* license_key = std::getenv("AIC_SDK_LICENSE");

    // Load a model from file (download models at https://artifacts.ai-coustics.io/)
    auto model = aic::Model::create_from_file("./models/model.aicmodel").take();

    // Create configuration with model's optimal settings
    auto sample_rate = model.get_optimal_sample_rate();
    auto num_frames = model.get_optimal_num_frames(sample_rate);
    aic::ProcessorConfig config(sample_rate, num_frames, 2);  // 2 channels (stereo)

    // Create and initialize processor
    auto processor = aic::Processor::create(model, license_key).take();
    processor.initialize(config.sample_rate, config.num_channels, config.num_frames,
                         config.allow_variable_frames);

    // Process audio (planar layout: separate buffer per channel)
    std::vector<float> left(config.num_frames, 0.0f);
    std::vector<float> right(config.num_frames, 0.0f);
    std::vector<float*> audio = {left.data(), right.data()};
    processor.process_planar(audio.data(), config.num_channels, config.num_frames);

    return 0;
}

#include <stdlib.h>
#include "aic.h"

int main() {
    // Get your license key from the environment variable
    const char* license_key = getenv("AIC_SDK_LICENSE");

    // Download and load a model (or download manually at https://artifacts.ai-coustics.io/)
    struct AicModel* model = NULL;
    aic_model_create_from_file(&model, "path/to/model.aicmodel");

    // Create processor with license key
    struct AicProcessor* processor = NULL;
    aic_processor_create(&processor, model, license_key, NULL);

    // Get optimal configuration
    uint32_t sample_rate;
    size_t num_frames;
    aic_model_get_optimal_sample_rate(model, &sample_rate);
    aic_model_get_optimal_num_frames(model, sample_rate, &num_frames);

    // Initialize processor with optimal settings
    aic_processor_initialize(processor, sample_rate, 2, num_frames, false);

    // Process audio (planar layout: separate buffers per channel)
    float* audio_left = (float*) calloc(num_frames, sizeof(float));
    float* audio_right = (float*) calloc(num_frames, sizeof(float));
    float* audio_planar[2] = {audio_left, audio_right};
    aic_processor_process_planar(processor, audio_planar, 2, num_frames);

    // Cleanup
    free(audio_left);
    free(audio_right);
    aic_processor_destroy(processor);
    aic_model_destroy(model);
    return 0;
}