Cross-Platform Speaker Recognition in C Tutorial

🎯 Voice AI Consulting

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

At a high level, speaker recognition determines who is speaking. It includes speaker verification (authentication of a known user—also called voice biometrics, Voice ID, or speaker authentication) and speaker identification (selecting one speaker from many). These capabilities are used for secure access control, passive identity checks, and personalized multi-user voice interfaces.

Building speaker recognition into C applications requires real-time audio processing and consistent performance across major platforms like Linux, Windows, macOS, and even Raspberry Pi. Developers often compare open-source options like pyannote, SpeechBrain, and WeSpeaker with cloud-based voice biometric services, but both come with trade-offs. Cloud services add latency, which is one of the most important criteria for evaluating real-time speaker recognition, require constant connectivity, and send sensitive audio off-device, while open-source frameworks often need heavy tuning to reach production-quality accuracy and resource usage.

For applications that need low-latency, private, on-device verification or identification—such as smart home systems, secure authentication flows, or multi-user AI assistants—local processing can deliver the most reliable results.

This comprehensive tutorial demonstrates how to build cross-platform speaker recognition in C using Picovoice Eagle, a high-performance on-device speaker recognition engine. Eagle processes voice data locally and identifies speakers in real time with proven advantages over alternatives: higher accuracy and lower resource utilization as demonstrated by independent open-source benchmarks.

What You'll Learn

This tutorial covers a complete implementation of speaker recognition in C, including:

Capturing live microphone audio across all major platforms
Dynamic library loading for cross-platform compatibility
Enrolling speaker profiles with quality feedback
Exporting and importing speaker profiles for persistent storage
Performing real-time speaker recognition with confidence scores
Error handling and cleanup best practices

By the end of this guide, you'll have two complete C applications:

enrollment.c - Enrolls new speakers and saves their voice profiles
recognition.c - Uses saved voice profiles to identify speakers in real time

Important: This tutorial builds on How to Record Audio in C. Ensure your audio capture environment is properly configured before continuing.

Prerequisites
- Supported Platforms
Project Setup
- Step 1: Add Eagle library files
Enrollment & Recognition Setup
Part 1: Implementing Speaker Enrollment
Part 2: Implementing Real-Time Speaker Recognition
Complete Example: Speaker Enrollment & Recognition in C
Troubleshooting Common Issues
Frequently Asked Questions

Prerequisites

Before starting this tutorial, ensure you have:

C99-compatible compiler
Windows users: MinGW
A Picovoice AccessKey (Get your free AccessKey)
Working microphone for audio capture

Supported Platforms

Eagle Speaker Recognition supports the following platforms:

Linux: x86_64
macOS: x86_64 and arm64
Windows: x86_64 and arm64
Raspberry Pi: Models 3, 4, and 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/
├── enrollment.c                   # Speaker enrollment
├── recognition.c                  # Speaker recognition
├── pvrecorder/                    # Audio capture (set up in "How to Record Audio in C")
│   ├── libpv_recorder.{so|dylib|dll}
│   └── include/
│       ├── pv_recorder.h
│       └── pv_circular_buffer.h
└── eagle/               
    ├── eagle_params.pv            # Eagle model file
    ├── libpv_eagle.{so|dylib|dll} # Speaker recognition library
    └── include/                   # Speaker recognition header files
        ├── pv_eagle.h
        └── picovoice.h

For instructions on audio capture using pvrecorder, refer to the prerequisite tutorial: How to Record Audio in C.

Step 1: Add Eagle Library Files

Set up the Eagle Speaker Recognition library:

Create a folder named eagle/ in your project root.
Download the Eagle header files from GitHub (pv_eagle.h and picovoice.h) and place them in:

eagle/include/

Download the appropriate Eagle library (libpv_eagle.so, libpv_eagle.dylib, or libpv_eagle.dll) for your platform and place it in:

eagle/

Download the Eagle model file (eagle_params.pv) and place it in:

eagle/

Your Eagle directory should now contain the library file, model file, and include folder with both header files.

Enrollment & Recognition Setup

We'll create two separate C applications: enrollment.c for enrolling speakers, and recognition.c for identifying them. The setup process is the same for both files. Start by creating both files, then add the required headers and cross-platform dynamic loading functions to each.

These helpers work identically whether you're using PvRecorder, Cheetah Streaming Speech-to-Text, Rhino Speech-to-Intent, Eagle Speaker Recognition, or other Picovoice engines.

Step 2: Include Required Headers

Add the necessary headers to your C file:

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

#include <windows.h>

#define UTF8_COMPOSITION_FLAG (0)
#define NULL_TERMINATED       (-1)

#else

#include <dlfcn.h>

#endif

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

#include "pv_eagle.h"
#include "pv_recorder.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 writing and reading speaker profiles on Windows
signal.h: Enables Ctrl+C interrupt handling

Step 3: Define Dynamic Loading Helper Functions

Eagle Speaker Recognition ships as a shared library (.so, .dylib, or .dll depending on platform). Rather than statically linking at compile time, we'll load the library dynamically at runtime.

We'll build a set of helper functions that handle:

Opening shared libraries across different operating systems
Fetching function pointers from loaded libraries
Graceful cleanup and error handling

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
}

This function opens a shared library and returns a handle.

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
}

Retrieves a function pointer from the loaded library by symbol name.

3c. Close the Library

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

Properly closes the library handle and frees associated resources. Call this in your cleanup code.

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

Provides detailed error messages specific to each platform's dynamic loading mechanism.

Step 4: Add Interrupt Handling

For clean program termination on Ctrl+C, add interrupt handling:

static volatile bool is_interrupted = false;

static void interrupt_handler(int signal) {
    (void)signal;
    is_interrupted = true;
}

int main(void) {
    signal(SIGINT, interrupt_handler);
    
    // Your application code here
}

This allows users to gracefully stop speaker enrollment or recognition.

Step 5: Load Required Libraries

Load the Eagle Speaker Recognition library:

const char *library_path = "./eagle/libpv_eagle.{so|dylib|dll}"; // adjust per platform
void *eagle_library = open_dl(library_path);

Part 1: Implementing Speaker Enrollment

Eagle Speaker Recognition requires two distinct phases: enrollment and recognition. During enrollment, users speak into the microphone to create a unique voice profile. This section builds the enrollment application (enrollment.c).

Understanding Speaker Enrollment

The enrollment process:

Captures audio samples from the user's voice
Analyzes acoustic features to build a speaker profile
Provides real-time feedback on audio quality
Requires a minimum duration of speech for reliability
Exports a binary profile file for later recognition

Step 6: Load Eagle Profiler Functions

Load all necessary Eagle functions for enrollment:

// Load Eagle Profiler initialization function
pv_status_t (*pv_eagle_profiler_init_func)(
        const char *,
        const char *,
        const char *,
        pv_eagle_profiler_t **) = load_symbol(eagle_library, "pv_eagle_profiler_init");

// Load Eagle Profiler delete function
void (*pv_eagle_profiler_delete_func)(pv_eagle_profiler_t *) =
        load_symbol(eagle_library, "pv_eagle_profiler_delete");

// Load feedback to string converter function
const char *(*pv_eagle_profiler_enroll_feedback_to_string_func)(pv_eagle_profiler_enroll_feedback_t) = 
        load_symbol(eagle_library, "pv_eagle_profiler_enroll_feedback_to_string");

// Load enrollment function
pv_status_t (*pv_eagle_profiler_enroll_func)(
        pv_eagle_profiler_t *,
        const int16_t *,
        int32_t,
        pv_eagle_profiler_enroll_feedback_t *,
        float *) = load_symbol(eagle_library, "pv_eagle_profiler_enroll");

// Load function that gets the minimum enrollment samples
pv_status_t (*pv_eagle_profiler_enroll_min_audio_length_samples_func)(const pv_eagle_profiler_t *, int32_t *) =
        load_symbol(eagle_library, "pv_eagle_profiler_enroll_min_audio_length_samples");

// Load export functions
pv_status_t (*pv_eagle_profiler_export_func)(const pv_eagle_profiler_t *, void *) =
        load_symbol(eagle_library, "pv_eagle_profiler_export");

pv_status_t (*pv_eagle_profiler_export_size_func)(const pv_eagle_profiler_t *, int32_t *) =
        load_symbol(eagle_library, "pv_eagle_profiler_export_size");

// Load frame length function
int32_t (*pv_eagle_frame_length_func)() = load_symbol(eagle_library, "pv_eagle_frame_length");

Step 7: Initialize Eagle Profiler

The Eagle Profiler is the enrollment component that builds speaker profiles:

static const char* access_key = "${ACCESS_KEY}"; // Replace with your Picovoice AccessKey
const char *model_path = "./eagle/eagle_params.pv"; // Update path as needed
char *device = "best"; // Update as needed

pv_eagle_profiler_t* eagle_profiler = NULL;
pv_status_t eagle_profiler_status = pv_eagle_profiler_init_func(access_key, model_path, device, &eagle_profiler);

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

You can set it to 'best' to automatically pick the most suitable option, or specify a device yourself. For example, 'gpu' uses the first available GPU, while 'gpu:0' or 'gpu:1' targets a specific GPU. If you want to run on the CPU, use 'cpu', or control the number of CPU threads with something like 'cpu:4'.

Important: Replace ${ACCESS_KEY} with your actual AccessKey from Picovoice Console.

Step 8: Determine Minimum Enrollment Samples

Eagle requires a minimum amount of audio for reliable enrollment:

int32_t num_enroll_samples = 0;
eagle_profiler_status = pv_eagle_profiler_enroll_min_audio_length_samples_func(eagle_profiler, &num_enroll_samples);

Step 9: Perform Speaker Enrollment

Capture audio with PvRecorder and enroll the speaker with real-time progress feedback:

const int32_t frame_length = pv_eagle_frame_length_func();

// Allocate buffer for enrollment audio
int16_t *enroll_pcm = (int16_t *) malloc(num_enroll_samples * sizeof(int16_t));

float enroll_percentage = 0.0f;
pv_eagle_profiler_enroll_feedback_t feedback = PV_EAGLE_PROFILER_ENROLL_FEEDBACK_AUDIO_OK;

while (enroll_percentage < 100.0f) {

    // Collect minimum required audio
    for (int32_t i = 0; i < num_enroll_samples; i += frame_length) {
        int16_t *pcm = &enroll_pcm[i];
        recorder_status = pv_recorder_read_func(recorder, pcm);
    }
    
    // Process enrollment
    eagle_profiler_status = pv_eagle_profiler_enroll_func(
            eagle_profiler,
            enroll_pcm,
            num_enroll_samples,
            &feedback,
            &enroll_percentage);
    
    // Display feedback if audio quality issues detected
    if (feedback != PV_EAGLE_PROFILER_ENROLL_FEEDBACK_AUDIO_OK) {
        fprintf(
                stdout,
                "\nEnrollment audio feedback: %s\n",
                pv_eagle_profiler_enroll_feedback_to_string_func(feedback));
    }
    
    // Show progress
    fprintf(stdout, "Enrollment progress: %.2f%%\n", enroll_percentage);
}
fprintf(stdout, "\n");

Enrollment tips for users:

Speak naturally in a quiet environment
Avoid background noise, music, or other voices
Speak different phrases or sentences for variety

Step 10: Export Speaker Profile

Once enrollment reaches 100%, export the speaker profile:

int32_t profile_size_bytes = 0;
eagle_profiler_status = pv_eagle_profiler_export_size_func(eagle_profiler, &profile_size_bytes);

void *speaker_profile = calloc(profile_size_bytes, sizeof(uint8_t));

eagle_profiler_status = pv_eagle_profiler_export_func(eagle_profiler, speaker_profile);

Step 11: Write Speaker Profile to File

Save the profile to a file for later use in recognition:

FILE *output_profile_file = NULL;
    const char *output_profile_path = "./eagle_speaker_profile"; // You can choose any output file name

#if defined(_WIN32) || defined(_WIN64)
    // Windows requires UTF-8 to wide character conversion
    int output_profile_path_wchars_num = MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            output_profile_path,
            NULL_TERMINATED,
            NULL,
            0);
    wchar_t output_profile_path_wchars[output_profile_path_wchars_num];
    MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            output_profile_path,
            NULL_TERMINATED,
            output_profile_path_wchars,
            output_profile_path_wchars_num);
    output_profile_file = _wfopen(output_profile_path_wchars, L"wb");
#else
    // Unix systems handle UTF-8 paths directly
    output_profile_file = fopen(output_profile_path, "wb");
#endif

    // Write profile to file
    fwrite(speaker_profile, profile_size_bytes, sizeof(uint8_t), output_profile_file);

    fclose(output_profile_file);

Step 12: Cleanup Enrollment Resources

Properly release all allocated resources:

// Free allocated memory
free(enroll_pcm);
free(speaker_profile);

// Delete Picovoice objects
pv_recorder_delete_func(recorder);
pv_eagle_profiler_delete_func(eagle_profiler);

// Close dynamic libraries
close_dl(recorder_library);
close_dl(eagle_library);

Part 2: Implementing Real-Time Speaker Recognition

Now that you have enrolled a speaker profile, let's build the recognition application (recognition.c).

Understanding Speaker Recognition

The recognition process works as follows:

Loads one or more pre-enrolled speaker profiles from the enrollment stage
Initializes Eagle Speaker Recognition with these profiles
Captures live audio frames from the microphone
Eagle Speaker Recognition processes each audio frame
Returns confidence scores ranging from 0.0 (no match) to 1.0 (perfect match) for each enrolled speaker

Higher scores indicate stronger voice matches.

Step 13: Load Eagle Recognizer Functions

Load all required function symbols for recognition:

// Load Eagle initialization function
pv_status_t (*pv_eagle_init_func)(
        const char *,
        const char *,
        const char *,
        int32_t,
        const void * const *,
        pv_eagle_t **) = load_symbol(eagle_library, "pv_eagle_init");

// Load cleanup function
void (*pv_eagle_delete_func)(pv_eagle_t *) = load_symbol(eagle_library, "pv_eagle_delete");

// Load processing function
pv_status_t (*pv_eagle_process_func)(
        pv_eagle_t *,
        const int16_t *,
        float *) = load_symbol(eagle_library, "pv_eagle_process");

// Load frame length function
int32_t (*pv_eagle_frame_length_func)() = load_symbol(eagle_library, "pv_eagle_frame_length");

Step 14: Load Speaker Profile from File

Begin your recognition application by loading the previously enrolled speaker profile:

// Open speaker profile file with platform-specific handling
    const char *input_profile_path = "./eagle_speaker_profile"; // Update path as needed
    FILE *input_profile_file = NULL;
    
#if defined(_WIN32) || defined(_WIN64)
    // Windows requires UTF-8 to wide character conversion for file paths
    int profile_path_wchars_num = MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            input_profile_path,
            NULL_TERMINATED,
            NULL,
            0);
    wchar_t profile_path_wchars[profile_path_wchars_num];
    MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            input_profile_path,
            NULL_TERMINATED,
            profile_path_wchars,
            profile_path_wchars_num);
    input_profile_file = _wfopen(profile_path_wchars, L"rb");
#else
    // Unix systems handle UTF-8 paths directly
    input_profile_file = fopen(input_profile_path, "rb");
#endif
    
    // Determine file size
    fseek(input_profile_file, 0, SEEK_END);
    long speaker_profile_size = ftell(input_profile_file);
    fseek(input_profile_file, 0, SEEK_SET);
    
    // Read the entire profile into memory
    void *speaker_profile = calloc(speaker_profile_size, sizeof(uint8_t));
    size_t num_bytes = fread(speaker_profile, sizeof(uint8_t), speaker_profile_size, input_profile_file);
    if (num_bytes != speaker_profile_size) {
        fprintf(stderr, "Failed to read speaker profile from '%s'.\n", input_profile_path);
        exit(EXIT_FAILURE);
    }
    fclose(input_profile_file);
}

This example loads a single speaker profile, but Eagle Speaker Recognition supports multiple profiles for multi-user identification.

Step 15: Initialize Eagle Recognizer

Initialize the Eagle recognizer with your enrolled speaker profile(s):

// Initialize Eagle with speaker profile
static const char* access_key = "${ACCESS_KEY}"; // Replace with your Picovoice AccessKey
const char *model_path = "./eagle/eagle_params.pv"; // Update path as needed
char *device = "best"; // Update as needed

pv_eagle_t *eagle = NULL;
pv_status_t eagle_status = pv_eagle_init_func(
        access_key,
        model_path,
        device,
        1, // number of enrolled speakers
        (const void *const *) &speaker_profile,
        &eagle);

Step 16: Perform Real-Time Speaker Recognition

Start the recognition loop to continuously identify the speaker:

float score = 0.0f;
int16_t *pcm = (int16_t *) calloc(frame_length, sizeof(int16_t));

recorder_status = pv_recorder_start_func(recorder);

while (!is_interrupted) {

    // Read one frame of audio
    recorder_status = pv_recorder_read_func(recorder, pcm);
    
    // Process frame through Eagle
    eagle_status = pv_eagle_process_func(eagle, pcm, &score);
    
    // Display recognition score with visual indicator
    fprintf(stdout, "\r[Score: %.3f] ", score);
    fflush(stdout);
}

pv_recorder_stop_func(recorder);

Understanding recognition scores:

0.0 - 0.3: Very low confidence, likely not the enrolled speaker
0.3 - 0.5: Low to moderate confidence, uncertain match
0.5 - 0.7: Good confidence, probable match
0.7 - 1.0: High confidence, strong match

Step 17: Cleanup Recognition Resources

Properly release all allocated resources and close libraries:

// Free allocated memory
free(pcm);
free(speaker_profile);

// Delete Picovoice objects
pv_recorder_delete_func(recorder);
pv_eagle_delete_func(eagle);

// Close dynamic libraries
close_dl(recorder_library);
close_dl(eagle_library);

Best practice: Always ensure cleanup code runs even if errors occur during recognition.

Complete Example: Speaker Enrollment & Recognition in C

Here are the full enrollment.c and recognition.c files you can copy, build, and run. They are complete with error handling and PvRecorder implementation for audio capture. Before building and running, replace ${ACCESS_KEY} with your Picovoice AccessKey and update file paths according to your project setup.

Enrollment Complete Code

Here is enrollment.c:

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

#include <windows.h>

#define UTF8_COMPOSITION_FLAG (0)
#define NULL_TERMINATED       (-1)

#else

#include <dlfcn.h>

#endif

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

#include "pv_eagle.h"
#include "pv_recorder.h"

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
}

static volatile bool is_interrupted = false;

static void interrupt_handler(int signal) {
    (void)signal;
    is_interrupted = true;
}

int main(void) {
    signal(SIGINT, interrupt_handler);

    // PvRecorder dynamic loading
    const char *pv_recorder_library_path = "./pvrecorder/libpv_recorder.so"; // Update path as needed
    void *recorder_library = open_dl(pv_recorder_library_path);
    if (!recorder_library) {
        fprintf(stderr, "failed to load dynamic library at `%s`.\n", pv_recorder_library_path);
        exit(1);
    }

    const char *(*pv_recorder_status_to_string_func)(pv_recorder_status_t) =
            load_symbol(recorder_library, "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(recorder_library, "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(recorder_library, "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(recorder_library, "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(recorder_library, "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(recorder_library, "pv_recorder_delete");
    if (!pv_recorder_delete_func) {
        print_dl_error("failed to load `pv_recorder_delete`");
        exit(1);
    }

    // Eagle dynamic loading
    const char *library_path = "./eagle/libpv_eagle.so"; // Update path as needed
    void *eagle_library = open_dl(library_path);
    if (!eagle_library) {
        fprintf(stderr, "failed to load dynamic library at `%s`.\n", library_path);
        exit(1);
    }

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

    pv_status_t(*pv_eagle_profiler_init_func)(
            const char *,
            const char *,
            const char *,
            pv_eagle_profiler_t **) = load_symbol(eagle_library, "pv_eagle_profiler_init");
    if (!pv_eagle_profiler_init_func) {
        print_dl_error("Failed to load 'pv_eagle_profiler_init'");
        exit(EXIT_FAILURE);
    }

    void (*pv_eagle_profiler_delete_func)(pv_eagle_profiler_t *) =
            load_symbol(eagle_library, "pv_eagle_profiler_delete");
    if (!pv_eagle_profiler_delete_func) {
        print_dl_error("Failed to load 'pv_eagle_profiler_delete'");
        exit(EXIT_FAILURE);
    }

    const char *(*pv_eagle_profiler_enroll_feedback_to_string_func)(pv_eagle_profiler_enroll_feedback_t) =
            load_symbol(eagle_library, "pv_eagle_profiler_enroll_feedback_to_string");
    if (!pv_eagle_profiler_enroll_feedback_to_string_func) {
        print_dl_error("Failed to load 'pv_eagle_profiler_enroll_feedback_to_string'");
        exit(EXIT_FAILURE);
    }

    pv_status_t(*pv_eagle_profiler_enroll_func)(
            pv_eagle_profiler_t *,
            const int16_t *,
            int32_t,
            pv_eagle_profiler_enroll_feedback_t *,
            float *) = load_symbol(eagle_library, "pv_eagle_profiler_enroll");
    if (!pv_eagle_profiler_enroll_func) {
        print_dl_error("Failed to load 'pv_eagle_profiler_enroll'");
        exit(EXIT_FAILURE);
    }

    pv_status_t(*pv_eagle_profiler_enroll_min_audio_length_samples_func)(const pv_eagle_profiler_t *, int32_t *) =
            load_symbol(eagle_library, "pv_eagle_profiler_enroll_min_audio_length_samples");
    if (!pv_eagle_profiler_enroll_min_audio_length_samples_func) {
        print_dl_error("Failed to load 'pv_eagle_profiler_enroll_min_audio_length_samples'");
        exit(EXIT_FAILURE);
    }

    pv_status_t(*pv_eagle_profiler_export_func)(const pv_eagle_profiler_t *, void *) =
            load_symbol(eagle_library, "pv_eagle_profiler_export");
    if (!pv_eagle_profiler_export_func) {
        print_dl_error("Failed to load 'pv_eagle_profiler_export'");
        exit(EXIT_FAILURE);
    }

    pv_status_t(*pv_eagle_profiler_export_size_func)(const pv_eagle_profiler_t *, int32_t *) =
            load_symbol(eagle_library, "pv_eagle_profiler_export_size");
    if (!pv_eagle_profiler_export_size_func) {
        print_dl_error("Failed to load 'pv_eagle_profiler_export_size'");
        exit(EXIT_FAILURE);
    }

    int32_t (*pv_eagle_frame_length_func)() = load_symbol(eagle_library, "pv_eagle_frame_length");
    if (!pv_eagle_frame_length_func) {
        print_dl_error("Failed to load 'pv_eagle_frame_length'");
        exit(EXIT_FAILURE);
    }

    static const char* access_key = "${ACCESS_KEY}"; // Replace with your Picovoice AccessKey
    const char *model_path = "./eagle/eagle_params.pv"; // Update path as needed
    char *device = "best"; // Update as needed

    pv_eagle_profiler_t* eagle_profiler = NULL;
    pv_status_t eagle_profiler_status = pv_eagle_profiler_init_func(access_key, model_path, device, &eagle_profiler);
    if (eagle_profiler_status != PV_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to create an instance of eagle profiler");
        exit(EXIT_FAILURE);
    }

    int32_t num_enroll_samples = 0;
    eagle_profiler_status = pv_eagle_profiler_enroll_min_audio_length_samples_func(eagle_profiler, &num_enroll_samples);
    if (eagle_profiler_status != PV_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to get minimum number of enrollment samples");
        exit(EXIT_FAILURE);
    }

    const int32_t frame_length = pv_eagle_frame_length_func();
    const int32_t device_index = -1;
    const int32_t buffered_frame_count = 100;

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

    int16_t *enroll_pcm = (int16_t *) malloc(num_enroll_samples * sizeof(int16_t));
    if (!enroll_pcm) {
        fprintf(stderr, "Failed to allocate pcm memory.\n");
        exit(EXIT_FAILURE);
    }

    fprintf(stdout, "Starting enrollment. Keep talking to the device until the progress reaches 100%%.\n");

    float enroll_percentage = 0.0f;
    pv_eagle_profiler_enroll_feedback_t feedback = PV_EAGLE_PROFILER_ENROLL_FEEDBACK_AUDIO_OK;

    pv_recorder_status_t recorder_status = pv_recorder_start_func(recorder);
    if (recorder_status != PV_RECORDER_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to start device with %s.\n", pv_recorder_status_to_string_func(recorder_status));
        exit(EXIT_FAILURE);
    }
    while ((enroll_percentage < 100.0f) && (!is_interrupted)) {
        for (int32_t i = 0; i < num_enroll_samples; i += frame_length) {
            int16_t *pcm = &enroll_pcm[i];
            recorder_status = pv_recorder_read_func(recorder, pcm);
            if (recorder_status != PV_RECORDER_STATUS_SUCCESS) {
                fprintf(stderr, "Failed to read audio with %s.\n", pv_recorder_status_to_string_func(recorder_status));
                exit(EXIT_FAILURE);
            }
        }

        eagle_profiler_status = pv_eagle_profiler_enroll_func(
                eagle_profiler,
                enroll_pcm,
                num_enroll_samples,
                &feedback,
                &enroll_percentage);
        if (eagle_profiler_status != PV_STATUS_SUCCESS) {
            fprintf(stderr, "Failed to enroll audio");
            exit(EXIT_FAILURE);
        }
        if (feedback != PV_EAGLE_PROFILER_ENROLL_FEEDBACK_AUDIO_OK) {
            fprintf(
                    stdout,
                    "\nEnrollment audio feedback: %s\n",
                    pv_eagle_profiler_enroll_feedback_to_string_func(feedback));
        }
        fprintf(stdout, "\rEnrollment progress: %.2f%%", enroll_percentage);
        fflush(stdout);
    }
    fprintf(stdout, "\n");

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

    if (is_interrupted) {
        fprintf(stdout, "Enrollment interrupted.\n");
        exit(EXIT_SUCCESS);
    }

    fprintf(stdout, "Enrollment complete.\n");

    int32_t profile_size_bytes = 0;
    eagle_profiler_status = pv_eagle_profiler_export_size_func(eagle_profiler, &profile_size_bytes);
    if (eagle_profiler_status != PV_STATUS_SUCCESS) {
        (void) fprintf(stderr, "Failed to get profile size with `%s`", pv_status_to_string_func(eagle_profiler_status));
        exit(EXIT_FAILURE);
    }

    void *speaker_profile = calloc(profile_size_bytes, sizeof(uint8_t));
    if (!speaker_profile) {
        (void) fprintf(stderr, "Failed to allocate memory for profile");
        exit(EXIT_FAILURE);
    }

    eagle_profiler_status = pv_eagle_profiler_export_func(eagle_profiler, speaker_profile);
    if (eagle_profiler_status != PV_STATUS_SUCCESS) {
        (void) fprintf(stderr, "Failed to export profile with `%s`", pv_status_to_string_func(eagle_profiler_status));
        exit(EXIT_FAILURE);
    }

    free(enroll_pcm);
    free(speaker_profile);
    pv_recorder_delete_func(recorder);
    pv_eagle_profiler_delete_func(eagle_profiler);
    close_dl(recorder_library);
    close_dl(eagle_library);

    FILE *output_profile_file = NULL;
    const char *output_profile_path = "./eagle_speaker_profile"; // Update path as needed

#if defined(_WIN32) || defined(_WIN64)
    int output_profile_path_wchars_num = MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            output_profile_path,
            NULL_TERMINATED,
            NULL,
            0);
    wchar_t output_profile_path_wchars[output_profile_path_wchars_num];
    MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            output_profile_path,
            NULL_TERMINATED,
            output_profile_path_wchars,
            output_profile_path_wchars_num);
    output_profile_file = _wfopen(output_profile_path_wchars, L"wb");
#else
    output_profile_file = fopen(output_profile_path, "wb");
#endif

    if (!output_profile_file) {
        fprintf(stderr, "Failed to open '%s' for writing\n", output_profile_path);
        exit(EXIT_FAILURE);
    }

    fwrite(speaker_profile, profile_size_bytes, sizeof(uint8_t), output_profile_file);

    fclose(output_profile_file);
}

Recognition Complete Code

Here is recognition.c:

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

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

#include <windows.h>

#define UTF8_COMPOSITION_FLAG (0)
#define NULL_TERMINATED       (-1)

#else

#include <dlfcn.h>

#endif

#include "pv_eagle.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);

    // PvRecorder dynamic loading
    const char *pv_recorder_library_path = "./pvrecorder/libpv_recorder.so"; // Update path as needed
    void *recorder_library = open_dl(pv_recorder_library_path);
    if (!recorder_library) {
        fprintf(stderr, "failed to load dynamic library at `%s`.\n", pv_recorder_library_path);
        exit(1);
    }

    const char *(*pv_recorder_status_to_string_func)(pv_recorder_status_t) =
            load_symbol(recorder_library, "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(recorder_library, "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(recorder_library, "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(recorder_library, "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(recorder_library, "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(recorder_library, "pv_recorder_delete");
    if (!pv_recorder_delete_func) {
        print_dl_error("failed to load `pv_recorder_delete`");
        exit(1);
    }

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

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

    pv_status_t (*pv_eagle_init_func)(
            const char *,
            const char *,
            const char *,
            int32_t,
            const void * const *,
            pv_eagle_t **) = load_symbol(eagle_library, "pv_eagle_init");
    if (!pv_eagle_init_func) {
        print_dl_error("Failed to load 'pv_eagle_init'");
        exit(EXIT_FAILURE);
    }

    void (*pv_eagle_delete_func)(pv_eagle_t *) = load_symbol(eagle_library, "pv_eagle_delete");
    if (!pv_eagle_delete_func) {
        print_dl_error("Failed to load 'pv_eagle_delete'");
        exit(EXIT_FAILURE);
    }

    pv_status_t (*pv_eagle_process_func)(
            pv_eagle_t *,
            const int16_t *,
            float *) = load_symbol(eagle_library, "pv_eagle_process");
    if (!pv_eagle_process_func) {
        print_dl_error("Failed to load 'pv_eagle_process'");
        exit(EXIT_FAILURE);
    }

    pv_status_t (*pv_eagle_frame_length_func)() = load_symbol(eagle_library, "pv_eagle_frame_length");
    if (!pv_eagle_frame_length_func) {
        print_dl_error("Failed to load 'pv_eagle_frame_length'");
        exit(EXIT_FAILURE);
    }

    const char *input_profile_path = "./eagle_speaker_profile"; // Update path as needed
    FILE *input_profile_file = NULL;

#if defined(_WIN32) || defined(_WIN64)
    int profile_path_wchars_num = MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            input_profile_path,
            NULL_TERMINATED,
            NULL,
            0);
    wchar_t profile_path_wchars[profile_path_wchars_num];
    MultiByteToWideChar(
            CP_UTF8,
            UTF8_COMPOSITION_FLAG,
            input_profile_path,
            NULL_TERMINATED,
            profile_path_wchars,
            profile_path_wchars_num);
    input_profile_file = _wfopen(profile_path_wchars, L"rb");
#else
    input_profile_file = fopen(input_profile_path, "rb");
#endif

    if (!input_profile_file) {
        fprintf(stderr, "Failed to open speaker profile file at '%s'.\n", input_profile_path);
        exit(EXIT_FAILURE);
    }

    fseek(input_profile_file, 0, SEEK_END);
    long speaker_profile_size = ftell(input_profile_file);
    fseek(input_profile_file, 0, SEEK_SET);

    void *speaker_profile = calloc(speaker_profile_size, sizeof(uint8_t));
    size_t num_bytes = fread(speaker_profile, sizeof(uint8_t), speaker_profile_size, input_profile_file);
    if (num_bytes != speaker_profile_size) {
        fprintf(stderr, "Failed to read speaker profile from '%s'.\n", input_profile_path);
        exit(EXIT_FAILURE);
    }
    fclose(input_profile_file);

    const char *access_key = "${ACCESS_KEY}";
    const char *model_path = "./eagle/eagle_params.pv"; // Update path as needed
    char *device = "best"; // Update as needed

    pv_eagle_t *eagle = NULL;
    pv_status_t eagle_status = pv_eagle_init_func(
            access_key,
            model_path,
            device,
            1,
            (const void *const *) &speaker_profile,
            &eagle);
    if (eagle_status != PV_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to create an instance of eagle with '%s'", pv_status_to_string_func(eagle_status));
        exit(EXIT_FAILURE);
    }

    const int32_t frame_length = pv_eagle_frame_length_func();
    const int32_t device_index = -1;
    const int32_t buffered_frame_count = 100;

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

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

    float score = 0.0f;
    int16_t *pcm = (int16_t *) calloc(frame_length, sizeof(int16_t));
    if (!pcm) {
        fprintf(stderr, "Failed to allocate pcm memory.\n");
        exit(EXIT_FAILURE);
    }

    fprintf(stdout, "Listening... (press Ctrl+C to stop)\n");
    while (!is_interrupted) {
        recorder_status = pv_recorder_read_func(recorder, pcm);
        if (recorder_status != PV_RECORDER_STATUS_SUCCESS) {
            fprintf(stderr, "Failed to read with %s.\n", pv_recorder_status_to_string_func(recorder_status));
            exit(EXIT_FAILURE);
        }

        eagle_status = pv_eagle_process_func(eagle, pcm, &score);
        if (eagle_status != PV_STATUS_SUCCESS) {
            fprintf(stderr, "Failed to process audio with %s", pv_status_to_string_func(eagle_status));
            exit(EXIT_FAILURE);
        }

        fprintf(stdout, "\r[score: %.2f]", score);
        fflush(stdout);
    }
    fprintf(stdout, "\n");

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

    free(pcm);
    free(speaker_profile);
    pv_recorder_delete_func(recorder);
    pv_eagle_delete_func(eagle);
    close_dl(recorder_library);
    close_dl(eagle_library);
}

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

Compiling and Running Your Applications

Compile Your Applications

# Compile Linux (gcc) and Raspberry Pi (gcc)
gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o enrollment enrollment.c -ldl
gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o recognition recognition.c -ldl

# Compile macOS (clang)
clang -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o enrollment enrollment.c
clang -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o recognition recognition.c

# Compile Windows (MinGW)
gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o enrollment.exe enrollment.c
gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -o recognition.exe recognition.c

Run Enrollment

# Linux, Raspberry Pi, and macOS
./enrollment

# Windows
./enrollment.exe

Follow the on-screen prompts to enroll a speaker.

Run Recognition

# Linux, Raspberry Pi, and macOS
./recognition

# Windows
./recognition.exe

Speak into the microphone and observe the real-time confidence scores. Press Ctrl+C to stop recognition.

Troubleshooting Common Issues

Failed to open Eagle library

Verify the library path matches your platform (.so, .dylib, or .dll) and architecture (x86_64 vs ARM)
Ensure the library file exists in the specified location

Failed to initialize Eagle

Invalid AccessKey - verify your key at console.picovoice.ai
Invalid model path - ensure eagle_params.pv exists and path is correct

Low or inconsistent recognition scores

Minimize background noise during both enrollment and recognition
Verify microphone volume levels are adequate
Re-enroll if audio conditions have significantly changed

Frequently Asked Questions

Can Eagle Speaker Recognition recognize multiple speakers simultaneously?

Yes. Eagle can handle multiple enrolled speakers and return scores for each.

Do I need to re-enroll speakers periodically?

No. Speaker profiles are stable over time. Re-enrollment is only needed if the person's voice changes significantly or if audio conditions change dramatically.

Can Eagle work offline?

Yes. Eagle performs all processing on-device without requiring network connectivity. Internet is required only for licensing and usage tracking.

What audio format does Eagle expect?

Eagle requires 16-bit linear PCM audio at 16 kHz sample rate, single channel (mono). PvRecorder automatically provides audio in this format.

How to Build Cross-Platform Speaker Recognition in C: Complete Tutorial