SDK quickstart

const fs = require("node:fs");
const { WaveFile } = require("wavefile");
const { Model, ProcessorAsync, getVersion } = require("@ai-coustics/aic-sdk");

async function main() {
  const licenseKey = process.env.AIC_SDK_LICENSE;
  if (!licenseKey || licenseKey === "YOUR_SDK_KEY") {
    throw new Error("Set AIC_SDK_LICENSE to your SDK key, then retry.");
  }
  const input = new WaveFile(fs.readFileSync("input.wav"));
  if (input.fmt.numChannels !== 1 || input.fmt.sampleRate !== 16000 || input.bitDepth !== "16") {
    throw new Error("Export input.wav as mono, 16 kHz, 16-bit PCM WAV, then retry.");
  }
  if (input.data.samples.length !== input.data.chunkSize) {
    throw new Error("input.wav is truncated. Export the complete recording, then retry.");
  }
  input.toBitDepth("32f");
  const audio = input.getSamples(false, Float32Array);
  if (audio.length === 0) {
    throw new Error("input.wav is empty. Record speech, then retry.");
  }

  const modelPath = await Model.download("quail-vf-2.2-l-16khz", "./models");
  const model = Model.fromFile(modelPath);
  let processor;
  try {
    const blockSize = model.getOptimalBlockSize(16000);
    processor = new ProcessorAsync(model, licenseKey);
    await processor.initialize(16000, blockSize, false);
    const context = await processor.getContext();
    const delay = context.getAudioDelay();
    // Pad the last block and flush the delayed tail with silence.
    const paddedSize = Math.ceil((audio.length + delay) / blockSize) * blockSize;
    const padded = new Float32Array(paddedSize);
    padded.set(audio);
    const output = new Float32Array(paddedSize);
    for (let start = 0; start < paddedSize; start += blockSize) {
      // Await each block to preserve stream order. Async processing returns a new array.
      const enhanced = await processor.process(padded.subarray(start, start + blockSize));
      output.set(enhanced, start);
    }
    const enhanced = output.subarray(delay, delay + audio.length);
    if (!enhanced.every(Number.isFinite)) {
      throw new Error("Processing returned non-finite samples; no output was written.");
    }
    const pcm = Int16Array.from(enhanced, (sample) =>
      Math.trunc(Math.max(-1, Math.min(32767 / 32768, sample)) * 32768)
    );
    const result = new WaveFile();
    result.fromScratch(1, 16000, "16", pcm);
    fs.writeFileSync("enhanced.wav", result.toBuffer());
    console.log(`SDK ${getVersion()}, model ${model.getId()}`);
    console.log(`Processed ${audio.length} samples at 16000 Hz; wrote enhanced.wav`);
  } finally {
    // All processing promises above have settled before native resources are released.
    if (processor) processor.dispose();
    model.dispose();
  }
}

main().catch((error) => {
  console.error(`Error: ${error.message}`);
  process.exitCode = 1;
});

[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);
    }
}

import http from 'node:http';
import { readFile } from 'node:fs/promises';

const origin = 'http://127.0.0.1:4173';
const sdkKey = process.env.AIC_SDK_LICENSE;
if (!sdkKey) throw new Error('Set AIC_SDK_LICENSE in the server environment.');
const files = new Map([
  ['/', ['index.html', 'text/html']],
  ['/sdk.js', ['node_modules/@ai-coustics/aic-sdk-wasm/aic_sdk_wasm.js', 'text/javascript']],
  ['/aic_sdk_wasm_bg.wasm', ['node_modules/@ai-coustics/aic-sdk-wasm/aic_sdk_wasm_bg.wasm', 'application/wasm']],
  ['/model.aicmodel', ['model.aicmodel', 'application/octet-stream']],
]);
const server = http.createServer(async (req, res) => {
  res.setHeader('Cache-Control', 'no-store');
  res.setHeader('X-Content-Type-Options', 'nosniff');
  if (req.headers.host !== '127.0.0.1:4173') {
    res.writeHead(403).end('Use the loopback URL printed by the server.');
    return;
  }
  if (req.url === '/session-token' && req.method === 'POST') {
    // This is a local-only demo. Production needs authenticated users and quotas.
    if (req.headers.origin !== origin || req.headers['x-aic-demo'] !== '1') {
      res.writeHead(403).end('Same-origin demo request required.');
      return;
    }
    try {
      const payload = JSON.parse(Buffer.from(sdkKey.split('.')[0], 'base64').toString());
      if (typeof payload.api_key !== 'string') throw new Error('Invalid SDK key');
      const basic = Buffer.from(`${payload.api_key}:`).toString('base64');
      const response = await fetch('https://api.ai-coustics.io/v1/sdk/tokens', {
        method: 'POST', headers: { Authorization: `Basic ${basic}` },
        signal: AbortSignal.timeout(10000),
      });
      if (!response.ok) throw new Error('Token request rejected');
      const { token } = await response.json();
      if (typeof token !== 'string') throw new Error('Missing token');
      const { exp } = JSON.parse(Buffer.from(token.split('.')[1], 'base64url').toString());
      if (!Number.isFinite(exp) || exp * 1000 <= Date.now() + 120000) {
        throw new Error('Token lifetime is too short for this demo');
      }
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ token }));
    } catch {
      // Do not log credentials or return upstream response bodies.
      res.writeHead(502).end('Token request failed. Check the server key and connectivity.');
    }
    return;
  }
  const file = files.get(req.url);
  if (req.method !== 'GET' || !file) {
    res.writeHead(404).end('Not found');
    return;
  }
  try {
    const bytes = await readFile(new URL(file[0], import.meta.url));
    res.writeHead(200, { 'Content-Type': file[1] }).end(bytes);
  } catch {
    res.writeHead(404).end('File missing. Check installation and model download.');
  }
});
server.listen(4173, '127.0.0.1', () => console.log(`Open ${origin}`));

<!doctype html>
<html lang="en">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>ai-coustics WASM file example</title>
<h1>Enhance a short recording</h1>
<p>Select a mono, 16 kHz, PCM16 WAV with speech (up to 60 seconds).</p>
<label>Recording <input id="input" type="file" accept=".wav"></label>
<button id="run">Enhance</button>
<p id="status" role="status">Ready.</p>
<a id="download" hidden download="enhanced.wav">Download enhanced.wav</a>
<script type="module">
import init, { Model, Processor, getVersion } from '/sdk.js';
const input = document.querySelector('#input');
const run = document.querySelector('#run');
const status = document.querySelector('#status');
const download = document.querySelector('#download');
let outputUrl;

function readWav(bytes) {
  const view = new DataView(bytes);
  const text = (offset, length) => String.fromCharCode(...new Uint8Array(bytes, offset, length));
  if (bytes.byteLength < 44 || text(0, 4) !== 'RIFF' || text(8, 4) !== 'WAVE') {
    throw new Error('Select a RIFF WAV file.');
  }
  let format, data;
  for (let pos = 12; pos + 8 <= bytes.byteLength;) {
    const size = view.getUint32(pos + 4, true), start = pos + 8;
    if (start + size > bytes.byteLength) throw new Error('Truncated WAV chunk.');
    if (text(pos, 4) === 'fmt ' && size >= 16) {
      format = [view.getUint16(start, true), view.getUint16(start + 2, true),
        view.getUint32(start + 4, true), view.getUint16(start + 14, true)];
    }
    if (text(pos, 4) === 'data') data = [start, size];
    pos = start + size + (size % 2);
  }
  if (String(format) !== '1,1,16000,16' || !data || data[1] % 2) {
    throw new Error('Export mono PCM16 WAV at 16 kHz, then retry.');
  }
  const samples = new Float32Array(data[1] / 2);
  if (!samples.length || samples.length > 16000 * 60) {
    throw new Error('Use a nonempty recording of up to 60 seconds.');
  }
  for (let i = 0; i < samples.length; i++) samples[i] = view.getInt16(data[0] + i * 2, true) / 32768;
  return samples;
}

function wavBlob(samples) {
  const bytes = new ArrayBuffer(44 + samples.length * 2), view = new DataView(bytes);
  const text = (offset, value) => [...value].forEach((c, i) => view.setUint8(offset + i, c.charCodeAt(0)));
  text(0, 'RIFF'); view.setUint32(4, bytes.byteLength - 8, true); text(8, 'WAVE');
  text(12, 'fmt '); view.setUint32(16, 16, true); view.setUint16(20, 1, true);
  view.setUint16(22, 1, true); view.setUint32(24, 16000, true); view.setUint32(28, 32000, true);
  view.setUint16(32, 2, true); view.setUint16(34, 16, true); text(36, 'data');
  view.setUint32(40, samples.length * 2, true);
  samples.forEach((x, i) => view.setInt16(44 + i * 2, Math.round(Math.max(-1, Math.min(32767 / 32768, x)) * 32768), true));
  return new Blob([bytes], { type: 'audio/wav' });
}

run.onclick = async () => {
  let model, processor, context;
  run.disabled = true; download.hidden = true;
  if (outputUrl) { URL.revokeObjectURL(outputUrl); outputUrl = undefined; }
  try {
    if (!input.files.length) throw new Error('Select a recording first.');
    if (input.files[0].size > 3_000_000) throw new Error('Select a WAV file smaller than 3 MB.');
    const samples = readWav(await input.files[0].arrayBuffer());
    status.textContent = 'Loading the WASM module and model...';
    await init();
    const response = await fetch('/model.aicmodel', { signal: AbortSignal.timeout(30000) });
    if (!response.ok) throw new Error('Model unavailable. Check the model download.');
    model = Model.fromBytes(new Uint8Array(await response.arrayBuffer()));
    const tokenResponse = await fetch('/session-token', {
      method: 'POST', headers: { 'X-Aic-Demo': '1' }, signal: AbortSignal.timeout(15000),
    });
    if (!tokenResponse.ok) throw new Error('Token unavailable. Check the server key and connectivity.');
    let { token } = await tokenResponse.json();
    processor = new Processor(model, token);
    token = undefined; // No URL, storage, console or source-code credential.
    const size = model.getOptimalBlockSize(16000);
    processor.initialize(16000, size, false);
    context = processor.getProcessorContext();
    const delay = context.getAudioDelay();
    const count = Math.ceil((samples.length + delay) / size);
    const processed = new Float32Array(count * size);
    const deadline = performance.now() + 60000;
    status.textContent = 'Processing...';
    for (let block = 0; block < count; block++) {
      if (performance.now() > deadline) throw new Error('Processing timed out. Use a shorter recording.');
      const frame = new Float32Array(size), offset = block * size;
      frame.set(samples.subarray(offset, offset + size));
      processor.process(frame);
      processed.set(frame, offset);
      // Allow browser I/O and UI tasks to run between synchronous calls.
      if (block % 10 === 0) await new Promise(resolve => setTimeout(resolve, 0));
    }
    const output = processed.slice(delay, delay + samples.length);
    if (!output.every(Number.isFinite)) throw new Error('Non-finite output; stop and check the model.');
    outputUrl = URL.createObjectURL(wavBlob(output));
    download.href = outputUrl; download.hidden = false;
    status.textContent = `Processed ${output.length} samples at 16000 Hz with SDK ${getVersion()}.`;
  } catch (error) {
    status.textContent = `Stopped: ${error.message.replace(/[.!?]+$/, '')}. Correct the problem and select Enhance to retry.`;
  } finally {
    context?.free();
    if (processor) { processor.terminateSession(); processor.free(); }
    model?.free(); run.disabled = false;
  }
};
</script>
</html>

#ifndef AUDIO_FILE_H
#define AUDIO_FILE_H
#define DR_WAV_IMPLEMENTATION
#include "dr_wav.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

/* A short-file helper for this tutorial, independent of the SDK. */
static float* read_input(size_t* count) {
    drwav wav;
    if (!drwav_init_file(&wav, "input.wav", NULL)) {
        fprintf(stderr, "Cannot open input.wav as a WAV file.\n");
        return NULL;
    }
    if (wav.channels != 1 || wav.sampleRate != 16000 ||
        wav.translatedFormatTag != DR_WAVE_FORMAT_PCM || wav.bitsPerSample != 16 ||
        wav.totalPCMFrameCount == 0 || wav.totalPCMFrameCount > 960000) {
        fprintf(stderr, "Use a nonempty mono, 16 kHz, PCM16 input.wav, at most 60 seconds.\n");
        drwav_uninit(&wav);
        return NULL;
    }
    *count = (size_t)wav.totalPCMFrameCount;
    float* audio = (float*)malloc(*count * sizeof(float));
    if (!audio || drwav_read_pcm_frames_f32(&wav, *count, audio) != *count) {
        fprintf(stderr, "Cannot read all input samples.\n");
        free(audio);
        audio = NULL;
    }
    drwav_uninit(&wav);
    return audio;
}

static int write_output(const float* audio, size_t count) {
    drwav wav;
    drwav_data_format format = {drwav_container_riff, DR_WAVE_FORMAT_IEEE_FLOAT, 1, 16000, 32};
    for (size_t i = 0; i < count; ++i) {
        if (!isfinite(audio[i])) {
            fprintf(stderr, "Non-finite output sample; no output written.\n");
            return 0;
        }
    }
    if (!drwav_init_file_write(&wav, "enhanced.wav", &format, NULL)) {
        fprintf(stderr, "Cannot create enhanced.wav.\n");
        return 0;
    }
    drwav_uint64 written = drwav_write_pcm_frames(&wav, count, audio);
    drwav_result closed = drwav_uninit(&wav);
    if (written != count || closed != DRWAV_SUCCESS) {
        fprintf(stderr, "Cannot finish enhanced.wav; discard the incomplete file.\n");
        return 0;
    }
    return 1;
}
#endif

#include "aic.hpp"
#include "audio_file.h"
#include <algorithm>
#include <cstring>
#include <iostream>
#include <limits>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

static void check(aic::ErrorCode error, const char* operation) {
    if (error != aic::ErrorCode::Success) {
        throw std::runtime_error(std::string(operation) + " failed (SDK error " +
                                 std::to_string(static_cast<int>(error)) + ").");
    }
}

int main() {
    try {
        const char* key = std::getenv("AIC_SDK_LICENSE");
        if (!key || !*key || std::strcmp(key, "YOUR_SDK_KEY") == 0)
            throw std::runtime_error("Set AIC_SDK_LICENSE to your SDK key, then retry.");
        size_t count = 0;
        std::unique_ptr<float, decltype(&std::free)> input(read_input(&count), &std::free);
        if (!input) return 1;
        auto model_result = aic::Model::create_from_file("model.aicmodel");
        check(model_result.error, "Model loading");
        auto model = model_result.take();
        auto processor_result = aic::Processor::create(model, key);
        check(processor_result.error, "Processor creation");
        auto processor = processor_result.take();
        const size_t block_size = model.get_optimal_block_size(16000);
        check(processor.initialize(16000, block_size, false), "Initialization");
        auto context_result = processor.create_context();
        check(context_result.error, "Context creation");
        auto context = context_result.take();
        const size_t delay = context.get_audio_delay();
        const size_t limit = std::numeric_limits<size_t>::max();
        if (block_size == 0 || count > limit - delay || count + delay > limit - (block_size - 1))
            throw std::runtime_error("Audio buffer size overflow.");
        const size_t padded_count = ((count + delay + block_size - 1) / block_size) * block_size;
        std::vector<float> output(padded_count, 0.0f);
        std::copy(input.get(), input.get() + count, output.begin());
        for (size_t start = 0; start < padded_count; start += block_size)
            check(processor.process(output.data() + start, block_size), "Processing");
        // Flush with silence, then omit the initial delay to align the files.
        if (!write_output(output.data() + delay, count)) return 1;
        std::cout << "SDK " << aic::get_sdk_version() << ", model " << model.get_id() << '\n';
        std::cout << "Processed " << count << " samples at 16000 Hz; wrote enhanced.wav\n";
        // Destructors release the context, processor and model on success or error.
        return 0;
    } catch (const std::exception& error) {
        std::cerr << error.what() << '\n';
        return 1;
    }
}

cmake_minimum_required(VERSION 3.24)
project(aic_cpp_quickstart LANGUAGES C CXX)
include(FetchContent)
set(AIC_SDK_ALLOW_DOWNLOAD ON CACHE BOOL "Download the matching C SDK")
FetchContent_Declare(aic_sdk
  GIT_REPOSITORY https://github.com/ai-coustics/aic-sdk-cpp.git
  GIT_TAG 0.24.0
  GIT_SHALLOW TRUE)
FetchContent_MakeAvailable(aic_sdk)
add_executable(quickstart quickstart.cpp)
target_compile_features(quickstart PRIVATE cxx_std_11)
target_link_libraries(quickstart PRIVATE aic-sdk)

#ifndef AUDIO_FILE_H
#define AUDIO_FILE_H
#define DR_WAV_IMPLEMENTATION
#include "dr_wav.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

/* A short-file helper for this tutorial, independent of the SDK. */
static float* read_input(size_t* count) {
    drwav wav;
    if (!drwav_init_file(&wav, "input.wav", NULL)) {
        fprintf(stderr, "Cannot open input.wav as a WAV file.\n");
        return NULL;
    }
    if (wav.channels != 1 || wav.sampleRate != 16000 ||
        wav.translatedFormatTag != DR_WAVE_FORMAT_PCM || wav.bitsPerSample != 16 ||
        wav.totalPCMFrameCount == 0 || wav.totalPCMFrameCount > 960000) {
        fprintf(stderr, "Use a nonempty mono, 16 kHz, PCM16 input.wav, at most 60 seconds.\n");
        drwav_uninit(&wav);
        return NULL;
    }
    *count = (size_t)wav.totalPCMFrameCount;
    float* audio = (float*)malloc(*count * sizeof(float));
    if (!audio || drwav_read_pcm_frames_f32(&wav, *count, audio) != *count) {
        fprintf(stderr, "Cannot read all input samples.\n");
        free(audio);
        audio = NULL;
    }
    drwav_uninit(&wav);
    return audio;
}

static int write_output(const float* audio, size_t count) {
    drwav wav;
    drwav_data_format format = {drwav_container_riff, DR_WAVE_FORMAT_IEEE_FLOAT, 1, 16000, 32};
    for (size_t i = 0; i < count; ++i) {
        if (!isfinite(audio[i])) {
            fprintf(stderr, "Non-finite output sample; no output written.\n");
            return 0;
        }
    }
    if (!drwav_init_file_write(&wav, "enhanced.wav", &format, NULL)) {
        fprintf(stderr, "Cannot create enhanced.wav.\n");
        return 0;
    }
    drwav_uint64 written = drwav_write_pcm_frames(&wav, count, audio);
    drwav_result closed = drwav_uninit(&wav);
    if (written != count || closed != DRWAV_SUCCESS) {
        fprintf(stderr, "Cannot finish enhanced.wav; discard the incomplete file.\n");
        return 0;
    }
    return 1;
}
#endif

#include "aic.h"
#include "audio_file.h"
#include <string.h>

#define CHECK(call) do { \
    enum AicErrorCode error = (call); \
    if (error != AIC_ERROR_CODE_SUCCESS) { \
        fprintf(stderr, "%s failed (SDK error %d).\n", #call, (int)error); \
        goto cleanup; \
    } \
} while (0)

int main(void) {
    const char* key = getenv("AIC_SDK_LICENSE");
    if (!key || !*key || strcmp(key, "YOUR_SDK_KEY") == 0) {
        fprintf(stderr, "Set AIC_SDK_LICENSE to your SDK key, then retry.\n");
        return 1;
    }
    int status = 1;
    size_t count = 0, block_size = 0, delay = 0, padded_count = 0;
    float* input = read_input(&count);
    float* output = NULL;
    struct AicModel* model = NULL;
    struct AicProcessor* processor = NULL;
    struct AicProcessorContext* context = NULL;
    if (!input) goto cleanup;
    CHECK(aic_model_create_from_file(&model, "model.aicmodel"));
    CHECK(aic_model_get_optimal_block_size(model, 16000, &block_size));
    CHECK(aic_processor_create(&processor, model, key, NULL));
    CHECK(aic_processor_initialize(processor, 16000, block_size, false));
    CHECK(aic_processor_context_create(&context, processor));
    CHECK(aic_processor_context_get_audio_delay(context, &delay));
    if (block_size == 0 || count > SIZE_MAX - delay ||
        count + delay > SIZE_MAX - (block_size - 1)) {
        fprintf(stderr, "Audio buffer size overflow.\n");
        goto cleanup;
    }
    padded_count = ((count + delay + block_size - 1) / block_size) * block_size;
    if (padded_count > SIZE_MAX / sizeof(float)) {
        fprintf(stderr, "Audio buffer size overflow.\n");
        goto cleanup;
    }
    output = (float*)calloc(padded_count, sizeof(float));
    if (!output) {
        fprintf(stderr, "Cannot allocate the processing buffer.\n");
        goto cleanup;
    }
    memcpy(output, input, count * sizeof(float));
    for (size_t start = 0; start < padded_count; start += block_size) {
        CHECK(aic_processor_process(processor, output + start, block_size));
    }
    /* Flush with silence, then omit the initial delay to align the files. */
    if (!write_output(output + delay, count)) goto cleanup;
    printf("SDK %s, model %s\n", aic_get_sdk_version(), aic_model_get_id(model));
    printf("Processed %zu samples at 16000 Hz; wrote enhanced.wav\n", count);
    status = 0;
cleanup:
    aic_processor_context_destroy(context);
    aic_processor_destroy(processor);
    aic_model_destroy(model);
    free(output);
    free(input);
    return status;
}

cmake_minimum_required(VERSION 3.24)
project(aic_c_quickstart LANGUAGES C)
set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
add_library(aic SHARED IMPORTED)
set(AIC_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/sdk")
if(WIN32)
  set_target_properties(aic PROPERTIES
    IMPORTED_LOCATION "${AIC_ROOT}/lib/aic.dll"
    IMPORTED_IMPLIB "${AIC_ROOT}/lib/aic.dll.lib")
elseif(APPLE)
  set_target_properties(aic PROPERTIES IMPORTED_LOCATION "${AIC_ROOT}/lib/libaic.dylib")
else()
  set_target_properties(aic PROPERTIES IMPORTED_LOCATION "${AIC_ROOT}/lib/libaic.so")
endif()
set_target_properties(aic PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${AIC_ROOT}/include")
add_executable(quickstart quickstart.c)
target_link_libraries(quickstart PRIVATE aic)
if(UNIX AND NOT APPLE)
  target_link_libraries(quickstart PRIVATE m)
endif()
if(WIN32)
  add_custom_command(TARGET quickstart POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different
    "$<TARGET_FILE:aic>" "$<TARGET_FILE_DIR:quickstart>")
endif()