C++

#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)