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.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()