How to Record Audio in C Across Windows, macOS, Linux & Raspberry Pi

🏢 Enterprise AI Consulting

Get dedicated help specific to your use case and for your hardware and software choices.

Recording audio in C across multiple platforms (Linux, macOS, Windows, and Raspberry Pi) requires careful handling of low-level buffers, sample formats, and platform-specific audio APIs. Unlike higher-level languages, C lacks a built-in microphone interface across operating systems.

Each platform uses different audio subsystems with distinct APIs:

macOS: Core Audio framework
Windows: WASAPI (Windows Audio Session API) or DirectSound
Linux & Raspberry Pi: ALSA (Advanced Linux Sound Architecture) or PulseAudio

Without a unified abstraction layer, developers must maintain separate initialization sequences, buffer management strategies, and error handling patterns for each operating system—significantly increasing complexity and maintenance burden.

This tutorial uses PvRecorder: a lightweight, cross-platform C library that provides a unified audio capture interface for real-time audio streaming. With PvRecorder, you can capture high-quality microphone input consistently across all major platforms, making it ideal for cross-platform voice-controlled applications, streaming speech-to-text, wake-word detection, and other real-time audio processing tasks.

By the end of this tutorial, you will be able to:

build the example from the command line
dynamically load the PvRecorder shared library at runtime
open the microphone and stream audio frames in real time
stop and clean up safely

This is a practical foundation for:

Prerequisites

C99-compatible compiler
Windows: MinGW

Supported Platforms

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

Project Setup

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/
├── pvrecorder_tutorial.c
└── pvrecorder/ # This folder will be created in the next step.
    ├── libpv_recorder.{so|dylib|dll}
    └── include/
        ├── pv_circular_buffer.h
        └── pv_recorder.h

Step 1. Add PvRecorder library files

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

pvrecorder/include/

Download the correct library file for your platform and place it in:

pvrecorder/

Implement Dynamic Loading

PvRecorder 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 library

Step 2. Include platform-specific headers

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#else
#include <dlfcn.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

#include "pv_recorder.h"

Why these matter

On Windows systems, windows.h provides the LoadLibrary function to load a shared library and GetProcAddress to retrieve individual function pointers.
On Unix-based systems, dlopen and dlsym from the dlfcn.h header provide the same functionality.
Lastly, signal.h allows us to handle Ctrl-C later in this example.

Step 3. Define dynamic loading helper functions

3a. 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
}

3b. 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
}

3c. Close the library

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

3d. 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
}

Capturing Microphone Audio

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

Step 4. Load the library file

Point library_path to the library file you previously downloaded, and dynamically load the library:

const char *library_path = "./pvrecorder/libpv_recorder.so"; // adjust per platform
void *dl_handle = open_dl(library_path);
if (!dl_handle) {
    fprintf(stderr, "failed to load dynamic library at `%s`.\n", library_path);
    exit(1);
}

Step 5. Initialize the recorder

Dynamically load and call pv_recorder_init to initialize the recorder:

pv_recorder_status_t (*pv_recorder_init_func)(const int32_t, const int32_t, const int32_t, pv_recorder_t **) =
load_symbol(dl_handle, "pv_recorder_init");
if (!pv_recorder_init_func) {
    print_dl_error("failed to load `pv_recorder_init`");
    exit(1);
}

const int32_t frame_length = 512;
const int32_t device_index = -1; // -1 == default device
const int32_t buffered_frame_count = 10;

pv_recorder_t *recorder = NULL;
pv_recorder_status_t status = pv_recorder_init_func(
        frame_length,
        device_index,
        buffered_frame_count,
        &recorder);

What these values mean

frame_length: Number of audio samples captured per read operation
device_index: Selected microphone (-1 = default device)
buffered_frame_count: Number of audio frames buffered internally

You can choose any available microphone instead of using the default device—see selecting an available device for details.

Most speech recognition engines expect:

16-bit samples (int16_t)
16 kHz audio
frames of 512–1024 samples

Step 6. Capture audio

Start the recorder and continuously read audio frames in real time:

pv_recorder_status_t (*pv_recorder_start_func)(pv_recorder_t *) = load_symbol(dl_handle, "pv_recorder_start");
if (!pv_recorder_start_func) {
    print_dl_error("failed to load `pv_recorder_start`");
    exit(1);
}

pv_recorder_status_t (*pv_recorder_read_func)(pv_recorder_t *, int16_t *) = load_symbol(dl_handle, "pv_recorder_read");
if (!pv_recorder_read_func) {
    print_dl_error("failed to load `pv_recorder_read`");
    exit(1);
}

status = pv_recorder_start_func(recorder);
    
// must have length equal to `frame_length` that was given to `pv_recorder_init`
int16_t *frame = malloc(frame_length * sizeof(int16_t));
while (true) {
    pv_recorder_status_t status = pv_recorder_read_func(recorder, frame);

    // use frame of audio data
    // ...
}
free(frame);

If you're building a speech recognition pipeline, pass frame to your speech recognition engine for processing.

Step 7. Stop and clean up

When done, stop and delete the recorder to free acquired memory:

pv_recorder_status_t (*pv_recorder_stop_func)(pv_recorder_t *) = load_symbol(dl_handle, "pv_recorder_stop");
if (!pv_recorder_stop_func) {
    print_dl_error("failed to load `pv_recorder_stop`");
    exit(1);
}

void (*pv_recorder_delete_func)(pv_recorder_t *) = load_symbol(dl_handle, "pv_recorder_delete");
if (!pv_recorder_delete_func) {
    print_dl_error("failed to load `pv_recorder_delete`");
    exit(1);
}

status = pv_recorder_stop_func(recorder);
pv_recorder_delete_func(recorder);
close_dl(dl_handle);

Complete Example: Recording Audio in C

Here is the complete pvrecorder_tutorial.c you can copy, build, and run (update library_path to point to the correct library for your platform):

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#else
#include <dlfcn.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

#include "pv_recorder.h"

static volatile bool is_interrupted = false;

void interrupt_handler(int _) {
    (void) _;
    is_interrupted = true;
}

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) {
    signal(SIGINT, interrupt_handler);

    const char *library_path = "./pvrecorder/libpv_recorder.so"; // adjust per platform
    void *dl_handle = open_dl(library_path);
    if (!dl_handle) {
        fprintf(stderr, "failed to load dynamic library at `%s`.\n", library_path);
        exit(1);
    }

    const char *(*pv_recorder_status_to_string_func)(pv_recorder_status_t) = 
        load_symbol(dl_handle, "pv_recorder_status_to_string");
    if (!pv_recorder_status_to_string_func) {
        print_dl_error("failed to load `pv_recorder_status_to_string`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_init_func)(
        const int32_t, 
        const int32_t, 
        const int32_t,
        pv_recorder_t **) = load_symbol(dl_handle, "pv_recorder_init");
    if (!pv_recorder_init_func) {
        print_dl_error("failed to load `pv_recorder_init`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_start_func)(pv_recorder_t *) = load_symbol(dl_handle, "pv_recorder_start");
    if (!pv_recorder_start_func) {
        print_dl_error("failed to load `pv_recorder_start`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_read_func)(pv_recorder_t *, int16_t *) = 
        load_symbol(dl_handle, "pv_recorder_read");
    if (!pv_recorder_read_func) {
        print_dl_error("failed to load `pv_recorder_read`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_stop_func)(pv_recorder_t *) = load_symbol(dl_handle, "pv_recorder_stop");
    if (!pv_recorder_stop_func) {
        print_dl_error("failed to load `pv_recorder_stop`");
        exit(1);
    }

    void (*pv_recorder_delete_func)(pv_recorder_t *) = load_symbol(dl_handle, "pv_recorder_delete");
    if (!pv_recorder_delete_func) {
        print_dl_error("failed to load `pv_recorder_delete`");
        exit(1);
    }

    const int32_t frame_length = 512;
    const int32_t device_index = -1;
    const int32_t buffered_frame_count = 10;

    pv_recorder_t *recorder = NULL;
    pv_recorder_status_t status = pv_recorder_init_func(
            frame_length,
            device_index,
            buffered_frame_count,
            &recorder);
    if (status != PV_RECORDER_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to initialize device with %s.\n", pv_recorder_status_to_string_func(status));
        exit(1);
    }

    status = pv_recorder_start_func(recorder);
    if (status != PV_RECORDER_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to start device with %s.\n", pv_recorder_status_to_string_func(status));
        exit(1);
    }

    int16_t *frame = malloc(frame_length * sizeof(int16_t));

    printf("Recording... Press Ctrl+C to stop.\n");
    while (!is_interrupted) {
        pv_recorder_status_t status = pv_recorder_read_func(recorder, frame);
        if (status != PV_RECORDER_STATUS_SUCCESS) {
            fprintf(stderr, "Failed to read audio frames with %s.\n", pv_recorder_status_to_string_func(status));
            exit(1);
        }

        printf("first sample = %d\n", frame[0]);
    }
    free(frame);

    status = pv_recorder_stop_func(recorder);
    if (status != PV_RECORDER_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to stop device with %s.\n", pv_recorder_status_to_string_func(status));
        exit(1);
    }

    printf("Stopped.\n");
    pv_recorder_delete_func(recorder);
    close_dl(dl_handle);
}

This is a simplified example but includes all the necessary components to get started. Check out the PvRecorder C demo on GitHub for a complete demo application.

Build & Run

Build and run the application:

Linux (gcc) and Raspberry Pi (gcc)

gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o pvrecorder_tutorial pvrecorder_tutorial.c -ldl

./pvrecorder_tutorial

macOS (clang)

clang -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o pvrecorder_tutorial pvrecorder_tutorial.c

./pvrecorder_tutorial

Windows (MinGW)

gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o pvrecorder_tutorial.exe pvrecorder_tutorial.c

./pvrecorder_tutorial.exe

Troubleshooting

Even with correct setup, microphone recording in C can be affected by device configuration, buffering behavior, or platform audio drivers. The following checks help diagnose the most common issues when working with real-time audio capture.

1. Enable Debug Logging

pv_recorder_set_debug_logging(recorder, true);

Debug logging provides diagnostic messages that can reveal buffer overflows or silent frames. This is often the fastest way to identify timing or hardware issues during development.

2. Verify the Selected Input Device

const char *selected_device = pv_recorder_get_selected_device(recorder);
fprintf(stdout, "Selected device: %s.\n", selected_device);

Confirming the active microphone is useful if:

your system has multiple input devices
virtual audio devices are installed
audio appears silent or distorted

To double-check what's being captured, record to a WAV file and listen back. The official PvRecorder C demo on GitHub includes a reference implementation.

You can also verify that recording is active before reading frames:

bool pv_recorder_get_is_recording(recorder);

3. Fix Skipping, Stuttering, or Choppy Audio

Audio that sounds uneven or intermittently silent typically indicates the application is not reading frames quickly enough. This results in internal buffer overflow.

To resolve:

enable debug logging (see above)
check for "overflow" messages
increase the buffered_frames_count used during initialization

A higher buffer count increases memory usage but allows more tolerance.

4. Investigate Low-Level Audio Backend Issues

PvRecorder uses miniaudio internally. If you suspect driver, hardware, or OS-level issues, try miniaudio's standalone capture example.

If miniaudio exhibits the same symptoms, the root cause is likely system-level rather than application code.

Next Steps: Build a Speech Recognition Pipeline

With reliable microphone input streaming into your C application, you can extend the project into voice processing and transcription. A typical next step is feeding captured PCM frames into a real-time speech-to-text engine.

Real-Time Streaming Speech Recognition in C

Cheetah Streaming Speech-to-Text: convert speech audio into text continuously with low latency, suitable for voice assistants and transcription tools.

Start Building

Frequently Asked Questions

What is the best audio format for speech recognition in C?

Most speech recognition engines expect single channel, 16-bit PCM audio sampled at 16 kHz. Using this format ensures low latency and consistent audio quality.

How do I choose the correct microphone device in C?

Use the device enumeration API (e.g., pv_recorder_get_available_devices) to list all connected audio devices. Each device has an index; pass the index to the recorder initialization function. If you want the default device, you can use -1.

Why is my audio choppy or skipping?

Choppy audio usually indicates buffer overflows. You can resolve this by increasing the internal buffer count (buffered_frames_count) when initializing the recorder. Also, ensure your frame length is appropriate for real-time processing (commonly 512–1024 samples).

Can I record audio on multiple platforms with the same C code?

Yes. By using a cross-platform audio library like PvRecorder, you can write a single C codebase that captures audio on Linux, Windows, macOS, and Raspberry Pi.

How do I integrate captured audio with a speech recognition engine?

Once you have raw PCM frames from your microphone, pass them directly into the speech recognition engine's streaming API or buffer. Ensure the audio format (sample rate, bit depth, and channel count) matches the engine's requirements.