How to Implement Cross-Platform Noise Suppression in C

🎯 Voice AI Consulting

Get dedicated support and consultation to ensure your specific needs are met.

Real-time noise suppression (or noise cancellation) in C enables developers to build high-quality audio applications that work across Linux, Windows, macOS, and Raspberry Pi. By implementing on-device processing, you can deliver clear speech output for voice assistants, video conferencing, and speech-to-text systems without requiring cloud connectivity.

Background noise degrades speech clarity and reduces the accuracy of voice interfaces. This is especially problematic for real-time applications where users expect immediate, reliable responses. Noise cancellation solutions like Krisp, NVIDIA RTX Voice, and Koala Noise Suppression solve this by cleaning audio, enhancing speech intelligibility and recognition accuracy, which benefits use cases such as meeting transcriptions and voice-enabled smart fitness apps.

However, Krisp and NVIDIA RTX Voice are typically end-user tools, leaving adoption up to the user. In contrast, Koala Noise Suppression can be integrated directly into your application, delivering consistent, built-in noise cancellation that works across all major platforms.

This tutorial demonstrates how to implement production-ready noise suppression with Koala Noise Suppression, a cross-platform, on-device C library optimized for real-time performance. You'll learn how to load an audio file, process it through the noise suppression pipeline, and output the processed clean audio. By the end, you'll have a working application that delivers reliably cleaner speech audio across all supported platforms.

Prerequisites

C99-compatible compiler
Windows: MinGW
Noisy WAV audio file(s) for testing

Supported Platforms

Linux (x86_64)
macOS (x86_64, arm64)
Windows (x86_64, arm64)
Raspberry Pi (3, 4, 5)

Part 1. Set Up Your C Noise Suppression Project

This is the folder structure used in this tutorial. You can organize your files differently if you like, but make sure to update the paths in the examples accordingly:

project_root/
├── koala_tutorial.c
├── input.wav          # Your noisy audio file
├── output.wav         # Will be created by the application
├── dr_libs/           # clone from https://github.com/mackron/dr_libs
└── koala/             # This folder will be created in the next step.
    ├── koala_params.pv
    ├── libpv_koala.{so|dylib|dll}
    └── include/
        ├── picovoice.h 
        └── pv_koala.h

Clone the dr_libs repo:

git clone https://github.com/mackron/dr_libs.git

Add Koala library files

Create a folder named koala/.
Download the Koala header files from GitHub and place them in:

koala/include/

Download a Koala model file and the correct library file for your platform and place them in:

koala/

Part 2. Cross-Platform Dynamic Library Loading

Koala Noise Suppression distributes pre-built platform libraries, meaning:

the shared library (.so, .dylib, .dll) is not linked at compile time
the program loads it at runtime
functions must be retrieved by name

So, we need to write small helper functions to:

open the shared library
look up function pointers
close the shared library

Include platform-specific headers

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#define UTF8_COMPOSITION_FLAG (0)
#define NULL_TERMINATED       (-1)
#else
#include <dlfcn.h>
#endif

#include <getopt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#define DR_WAV_IMPLEMENTATION
#include "dr_wav.h"
#include "pv_koala.h"

Understanding the headers:

Windows-specific: windows.h provides LoadLibrary to load a shared library and GetProcAddress to retrieve individual function pointers
Unix-specific: dlfcn.h provides dlopen and dlsym, which provide the same functionality as LoadLibrary and GetProcAddress
UTF8_COMPOSITION_FLAG and NULL_TERMINATED: Constants for reading and writing audio files on Windows

Define dynamic loading helper functions

Open the shared library

static void *open_dl(const char *dl_path) {
#if defined(_WIN32) || defined(_WIN64)
    return LoadLibrary(dl_path);
#else
    return dlopen(dl_path, RTLD_NOW);
#endif
}

Load function symbols

static void *load_symbol(void *handle, const char *symbol) {
#if defined(_WIN32) || defined(_WIN64)
    return GetProcAddress((HMODULE) handle, symbol);
#else
    return dlsym(handle, symbol);
#endif
}

Close the dynamic library

static void close_dl(void *handle) {
#if defined(_WIN32) || defined(_WIN64)
    FreeLibrary((HMODULE) handle);
#else
    dlclose(handle);
#endif
}

Print platform-correct errors

static void print_dl_error(const char *message) {
#if defined(_WIN32) || defined(_WIN64)
    fprintf(stderr, "%s with code '%lu'.\n", message, GetLastError());
#else
    fprintf(stderr, "%s with `%s`.\n", message, dlerror());
#endif
}

Load the library file

Downloaded the correct library file for your platform and point library_path to the file:

const char *library_path = "./koala/libpv_koala.so"; // adjust per platform
void *dl_handle = open_dl(library_path);

Load dynamic library functions

Load all required function symbols for Koala Noise Suppression:

// The audio sample rate the Koala accepts
int32_t (*pv_sample_rate_func)() = load_symbol(dl_handle, "pv_sample_rate");

// Load Koala initialization function
pv_status_t (*pv_koala_init_func)(const char *, const char *, const char *, pv_koala_t **) =
    load_symbol(dl_handle, "pv_koala_init");

// Load Koala delete function
void (*pv_koala_delete_func)(pv_koala_t *) = load_symbol(dl_handle, "pv_koala_delete");

// Load Koala process function
pv_status_t (*pv_koala_process_func)(pv_koala_t *, const int16_t *, int16_t *) =
    load_symbol(dl_handle, "pv_koala_process");

// Delay in samples (specifies the time shift between the input and output stream)
pv_status_t (*pv_koala_delay_sample_func)(pv_koala_t *, int32_t *) =
    load_symbol(dl_handle, "pv_koala_delay_sample");

// The number of audio samples per frame that Koala accepts
int32_t(*pv_koala_frame_length_func)() = load_symbol(dl_handle, "pv_koala_frame_length");

Part 3. Build Real-Time Noise Cancellation: Complete C Implementation Guide

Now that we've set up dynamic loading, we can actually use the Koala Noise Suppression API.

Initialize Koala Noise Suppression

Sign up for an account on Picovoice Console for free and obtain your AccessKey
Replace ${ACCESS_KEY} with your AccessKey
Point model_path to your downloaded Koala model file.

Call pv_koala_init to create a Koala Noise Suppression instance:

static const char* access_key = "${ACCESS_KEY}"; // replace with your AccessKey
const char *model_path = "./koala/koala_params.pv"; // update path as needed
const char *device = "best"; // or "cpu", "gpu", "cpu:0", "gpu:1", etc.

pv_koala_t *koala;
pv_status_t status = pv_koala_init_func(
    access_key,
    model_path,
    device,
    &koala);

The device parameter lets you choose what hardware the engine runs on.

Load input file (noisy)

Initialize and open your noisy audio file using the dr_wav library:

// Load noisy file via dr_wav
    const char *input_path = "${INPUT_WAV_PATH}";
    drwav input_file;

#if defined(_WIN32) || defined(_WIN64)

    int input_path_wchars_num = MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, input_path, NULL_TERMINATED, NULL, 0);
    wchar_t input_path_w[input_path_wchars_num];
    MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, input_path, NULL_TERMINATED, input_path_w, input_path_wchars_num);
    int drwav_init_file_status = drwav_init_file_w(&input_file, input_path_w, NULL);

#else

    int drwav_init_file_status = drwav_init_file(&input_file, input_path, NULL);

#endif

On Windows, the file path must be converted from UTF-8 to wide characters (UTF-16) before opening.

Prepare output file (cleaned audio)

Configure and create the output WAV file with specific audio parameters (16-bit PCM, mono channel, 16kHz sample rate):

// Create output file via dr_wav
    const char *output_path = "${OUTPUT_WAV_PATH}";
    drwav output_file;
    drwav_data_format format;
    format.container = drwav_container_riff;
    format.format = DR_WAVE_FORMAT_PCM;
    format.channels = 1;
    format.sampleRate = 16000;
    format.bitsPerSample = 16;

#if defined(_WIN32) || defined(_WIN64)

    int output_path_wchars_num = MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, output_path, NULL_TERMINATED, NULL, 0);
    wchar_t output_path_w[output_path_wchars_num];
    MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, output_path, NULL_TERMINATED, output_path_w, output_path_wchars_num);
    drwav_init_file_status = (int) drwav_init_file_write_w(&output_file, output_path_w, &format, NULL);

#else

    drwav_init_file_status = (int) drwav_init_file_write(&output_file, output_path, &format, NULL);

#endif

This step only prepares the output WAV file. It creates and configures a file with the correct format. In the next steps, we'll write the noise-suppressed (cleaned) audio frames to it as they are processed.

Prepare for audio processing

Determine the delay in samples (between input and output) and allocate memory buffers for the input and output frames:

int32_t delay_samples = 0;
status = pv_koala_delay_sample_func(koala, &delay_samples);

const int32_t frame_length = pv_koala_frame_length_func();
int16_t *pcm = (int16_t *) malloc(frame_length * sizeof(int16_t));
int16_t *enhanced_pcm = (int16_t *) malloc(frame_length * sizeof(int16_t));

Key components:

pv_koala_delay_sample_func: Returns the number of samples of latency between input and output (delay due to processing time).
pv_koala_frame_length_func: Returns the exact number of audio samples required per processing frame.

Process noisy audio

Read the input audio in fixed-size frames, apply Koala's noise suppression to each frame, and write the enhanced output while correctly handling the delay to ensure proper alignment:

int16_t *pcm_to_write = NULL;
size_t pcm_to_write_length = 0;

fprintf(stdout, "Processing audio... ");

size_t total_samples = input_file.totalPCMFrameCount;

int32_t start_sample = 0;
while (start_sample < total_samples + delay_samples) {
    int32_t end_sample = start_sample + frame_length;

    memset(pcm, 0, frame_length * sizeof(int16_t));
    drwav_read_pcm_frames_s16(&input_file, frame_length, pcm);

    status = pv_koala_process_func(koala, pcm, enhanced_pcm);

    pcm_to_write = enhanced_pcm;
    pcm_to_write_length = frame_length;
    if (end_sample > delay_samples) {
        if (end_sample > total_samples + delay_samples) {
            pcm_to_write_length = (total_samples + delay_samples - start_sample);
        }
        if (start_sample < delay_samples) {
            pcm_to_write += (delay_samples - start_sample);
            pcm_to_write_length -= (delay_samples - start_sample);
        }
        
        drwav_write_pcm_frames(&output_file, pcm_to_write_length, pcm_to_write);
    }

    start_sample = end_sample;
}

Processing flow:

Frame reading: Audio is read in chunks matching Koala's required frame size, with zero-padding applied when needed.
Noise suppression: Each frame is processed through pv_koala_process, which returns the enhanced audio with noise removed.
Delay compensation: The output is carefully aligned by skipping the initial delay_samples and ensuring the final output matches the original audio's duration, accounting for both the delay and any partial frames at the end.

Cleanup Resources

free(pcm);
free(enhanced_pcm);
drwav_uninit(&output_file);
drwav_uninit(&input_file);
pv_koala_delete_func(koala);
close_dl(dl_handle);

Full Working Example: C Noise Suppression Application Code

Below is the complete koala_tutorial.c file you can copy, build, and run:

koala_tutorial.c

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#define UTF8_COMPOSITION_FLAG (0)
#define NULL_TERMINATED       (-1)
#else
#include <dlfcn.h>
#endif

#include <getopt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#define DR_WAV_IMPLEMENTATION
#include "dr_wav.h"
#include "pv_koala.h"

// Update as needed
#define INPUT_WAV_PATH "./noisy.wav"
#define OUTPUT_WAV_PATH "./clean.wav"
#define KOALA_MODEL_PATH "./koala/koala_params.pv"
#define KOALA_LIB_PATH "./koala/libpv_koala.so" // adjust per platform
#define PICOVOICE_ACCESS_KEY "YOUR_ACCESS_KEY_HERE"

static void *open_dl(const char *dl_path) {
#if defined(_WIN32) || defined(_WIN64)
    return LoadLibrary(dl_path);
#else
    return dlopen(dl_path, RTLD_NOW);
#endif
}

static void *load_symbol(void *handle, const char *symbol) {
#if defined(_WIN32) || defined(_WIN64)
    return GetProcAddress((HMODULE) handle, symbol);
#else
    return dlsym(handle, symbol);
#endif
}

static void close_dl(void *handle) {
#if defined(_WIN32) || defined(_WIN64)
    FreeLibrary((HMODULE) handle);
#else
    dlclose(handle);
#endif
}

static void print_dl_error(const char *message) {
#if defined(_WIN32) || defined(_WIN64)
    fprintf(stderr, "%s with code '%lu'.\n", message, GetLastError());
#else
    fprintf(stderr, "%s with `%s`.\n", message, dlerror());
#endif
}

int main(void) {
    // Koala dynamic loading
    void *dl_handle = open_dl(KOALA_LIB_PATH);
    if (!dl_handle) {
        fprintf(stderr, "failed to load dynamic library at `%s`.\n", KOALA_LIB_PATH);
        exit(1);
    }

    const char *(*pv_status_to_string_func)(pv_status_t) = load_symbol(dl_handle, "pv_status_to_string");
    if (!pv_status_to_string_func) {
        print_dl_error("failed to load `pv_status_to_string`");
        exit(1);
    }

    int32_t (*pv_sample_rate_func)() = load_symbol(dl_handle, "pv_sample_rate");
    if (!pv_sample_rate_func) {
        print_dl_error("Failed to load 'pv_sample_rate'");
        exit(1);
    }

    pv_status_t (*pv_koala_init_func)(const char *, const char *, const char *, pv_koala_t **) =
        load_symbol(dl_handle, "pv_koala_init");
    if (!pv_koala_init_func) {
        print_dl_error("failed to load `pv_koala_init`");
        exit(1);
    }

    void (*pv_koala_delete_func)(pv_koala_t *) = load_symbol(dl_handle, "pv_koala_delete");
    if (!pv_koala_delete_func) {
        print_dl_error("failed to load `pv_koala_delete`");
        exit(1);
    }

    pv_status_t (*pv_koala_process_func)(pv_koala_t *, const int16_t *, int16_t *) =
        load_symbol(dl_handle, "pv_koala_process");
    if (!pv_koala_process_func) {
        print_dl_error("failed to load `pv_koala_process`");
        exit(1);
    }

    pv_status_t (*pv_koala_delay_sample_func)(pv_koala_t *, int32_t *) =
        load_symbol(dl_handle, "pv_koala_delay_sample");
    if (!pv_koala_delay_sample_func) {
        print_dl_error("Failed to load 'pv_koala_delay_sample'");
        exit(1);
    }

    int32_t(*pv_koala_frame_length_func)() = load_symbol(dl_handle, "pv_koala_frame_length");
    if (!pv_koala_frame_length_func) {
        print_dl_error("failed to load `pv_koala_frame_length`");
        exit(1);
    }

    const char *device = "best"; // update as needed

    pv_koala_t *koala = NULL;
    pv_status_t status = pv_koala_init_func(
        PICOVOICE_ACCESS_KEY,
        KOALA_MODEL_PATH,
        device,
        &koala);
    if (status != PV_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to init with `%s`", pv_status_to_string_func(status));
    }

    const char *input_path = INPUT_WAV_PATH;
    drwav input_file;

#if defined(_WIN32) || defined(_WIN64)

    int input_path_wchars_num = MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, input_path, NULL_TERMINATED, NULL, 0);
    wchar_t input_path_w[input_path_wchars_num];
    MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, input_path, NULL_TERMINATED, input_path_w, input_path_wchars_num);
    int drwav_init_file_status = drwav_init_file_w(&input_file, input_path_w, NULL);

#else

    int drwav_init_file_status = drwav_init_file(&input_file, input_path, NULL);

#endif

    if (!drwav_init_file_status) {
        fprintf(stderr, "Failed to open wav file at '%s'.", input_path);
        exit(1);
    }

    if (input_file.sampleRate != (uint32_t) pv_sample_rate_func()) {
        fprintf(stderr, "audio sample rate should be %d\n.", pv_sample_rate_func());
        exit(1);
    }

    if (input_file.bitsPerSample != 16) {
        fprintf(stderr, "audio format should be 16-bit\n.");
        exit(1);
    }

    if (input_file.channels != 1) {
        fprintf(stderr, "audio should be single-channel.\n");
        exit(1);
    }

    const char *output_path = OUTPUT_WAV_PATH;
    drwav output_file;
    drwav_data_format format;
    format.container = drwav_container_riff;
    format.format = DR_WAVE_FORMAT_PCM;
    format.channels = 1;
    format.sampleRate = 16000;
    format.bitsPerSample = 16;

#if defined(_WIN32) || defined(_WIN64)

    int output_path_wchars_num = MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, output_path, NULL_TERMINATED, NULL, 0);
    wchar_t output_path_w[output_path_wchars_num];
    MultiByteToWideChar(CP_UTF8, UTF8_COMPOSITION_FLAG, output_path, NULL_TERMINATED, output_path_w, output_path_wchars_num);
    drwav_init_file_status = (int) drwav_init_file_write_w(&output_file, output_path_w, &format, NULL);

#else

    drwav_init_file_status = (int) drwav_init_file_write(&output_file, output_path, &format, NULL);

#endif

    if (!drwav_init_file_status) {
        fprintf(stderr, "Failed to open the output file at '%s'.", output_path);
        exit(1);
    }

    int32_t delay_samples = 0;
    status = pv_koala_delay_sample_func(koala, &delay_samples);
    if (status != PV_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to get delay sample with '%s'", pv_status_to_string_func(status));
        exit(1);
    }

    const int32_t frame_length = pv_koala_frame_length_func();
    int16_t *pcm = (int16_t *) malloc(frame_length * sizeof(int16_t));
    if (!pcm) {
        fprintf(stderr, "Failed to allocate pcm memory.\n");
        exit(1);
    }

    int16_t *enhanced_pcm = (int16_t *) malloc(frame_length * sizeof(int16_t));
    if (!enhanced_pcm) {
        fprintf(stderr, "Failed to allocate enhanced_pcm memory.\n");
        exit(1);
    }
    int16_t *pcm_to_write = NULL;
    size_t pcm_to_write_length = 0;

    fprintf(stdout, "Processing audio... ");

    size_t total_samples = input_file.totalPCMFrameCount;

    int32_t start_sample = 0;
    while (start_sample < total_samples + delay_samples) {
        int32_t end_sample = start_sample + frame_length;

        memset(pcm, 0, frame_length * sizeof(int16_t));
        drwav_read_pcm_frames_s16(&input_file, frame_length, pcm);

        status = pv_koala_process_func(koala, pcm, enhanced_pcm);
        if (status != PV_STATUS_SUCCESS) {
            fprintf(stderr, "'pv_koala_process' failed with '%s'\n", pv_status_to_string_func(status));
            exit(1);
        }

        pcm_to_write = enhanced_pcm;
        pcm_to_write_length = frame_length;
        if (end_sample > delay_samples) {
            if (end_sample > total_samples + delay_samples) {
                pcm_to_write_length = (total_samples + delay_samples - start_sample);
            }
            if (start_sample < delay_samples) {
                pcm_to_write += (delay_samples - start_sample);
                pcm_to_write_length -= (delay_samples - start_sample);
            }

            if ((int32_t) drwav_write_pcm_frames(&output_file, pcm_to_write_length, pcm_to_write) != pcm_to_write_length) {
                fprintf(stderr, "Failed to write to output file.\n");
                exit(1);
            }
        }

        start_sample = end_sample;
    }

    fprintf(stdout, "complete!\n");

    free(pcm);
    free(enhanced_pcm);
    drwav_uninit(&output_file);
    drwav_uninit(&input_file);
    pv_koala_delete_func(koala);
    close_dl(dl_handle);
}

Before running, update:

INPUT_WAV_PATH to point to your noisy audio file
OUTPUT_WAV_PATH to specify where to save the enhanced audio
KOALA_MODEL_PATH to point to the Koala Noise Suppression model file (.pv)
KOALA_LIB_PATH to point to the correct Koala Noise Suppression library for your platform
PICOVOICE_ACCESS_KEY with your AccessKey from Picovoice Console

This is a simplified example but includes all the necessary components to get started. Check out the Koala C demo on GitHub for a complete demo application with WAV file I/O.

Compile and Run Your C Noise Suppression Application

Build and run the application:

Linux (gcc) and Raspberry Pi (gcc)

gcc -std=c99 -O2 -Wall -Wextra -I./dr_libs -I./koala/include -o koala_tutorial koala_tutorial.c -ldl

./koala_tutorial

macOS (clang)

clang -std=c99 -O2 -Wall -Wextra -I./dr_libs -I./koala/include -o koala_tutorial koala_tutorial.c

./koala_tutorial

Windows (MinGW)

gcc -std=c99 -O2 -Wall -Wextra -I./dr_libs -I./koala/include -o koala_tutorial.exe koala_tutorial.c

./koala_tutorial.exe

Conclusion

You now have a complete cross-platform noise suppression implementation in C that works on Linux, Windows, macOS, and Raspberry Pi. The dynamic loading approach gives you flexibility to deploy the same codebase across all supported platforms without modification.

This tutorial covered the essentials: setting up the Koala Noise Suppression library, implementing platform-specific dynamic loading, processing audio frames for noise suppression, and handling cleanup. You can extend this foundation by integrating real-time microphone input with PvRecorder, or adding noise suppression as a pre-processing step in other speech recognition pipelines, such as real-time speech-to-text or voice-controlled applications.

Start Building

Solving Common C Noise Suppression Implementation Problems

Audio file won't open or produces format errors

Confirm that your input audio file is in the correct format: 16-bit PCM, mono channel, and 16 kHz sample rate. Many audio files use different sample rates or stereo channels. Use audio conversion tools to resample and convert your files to the required format before processing.

Compilation fails with missing header errors

Double-check that all include paths in your compiler command match your actual folder structure. The -I flags should point to directories containing the header files, not the files themselves. Verify that you've downloaded all required header files and placed them in the correct locations.

Output audio is silent or corrupted

This often occurs when delay compensation isn't handled correctly. Ensure you're implementing the delay sample logic properly to align input and output streams. Also verify that memory buffers are properly allocated and that frame lengths match what the API expects.

Access key authentication fails

If initialization fails with an authentication error, verify that you've replaced the placeholder AccessKey with your actual key from Picovoice Console.

Frequently Asked Questions

Can I process real-time audio streams instead of files with Koala Noise Suppression?

Yes. The code examples use file I/O for simplicity, but Koala processes audio frame-by-frame. You can replace file reading with microphone input (e.g., via PvRecorder) or any streaming input. Just ensure you feed frames of the correct length to the processing function at the appropriate sample rate.

Does Koala Noise Suppression work with audio files in formats other than WAV?

Koala processes raw PCM audio data. You'll need to decode other formats (MP3, AAC, etc.) to 16-bit PCM at 16 kHz before passing audio to Koala.

How do I compile for cross-platform deployment from a single codebase?

The code in this tutorial is already cross-platform. Use conditional compilation directives to handle platform-specific library loading. Compile with the appropriate compiler for each target platform: gcc for Linux and Raspberry Pi, clang for macOS, MinGW for Windows.

Can I adjust the aggressiveness of noise suppression?

Koala Noise Suppression is tuned to provide optimal balance between noise suppression and speech quality. The model is designed to adapt automatically to different noise conditions without requiring manual tuning parameters.