Miniaud.io

https://miniaud.io/docs/
Admin
Miniaud.io is an audio library or framework, providing comprehensive documentation, programming...
Tokens:84,809
Snippets:359
Trust Score:7.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Initialize and Start Audio Playback

Source: https://miniaud.io/docs/examples/custom_backend

Initializes the miniaudio context and a playback device, configures it for sine wave generation, starts the device, and enters a main loop. Includes error checking for initialization and starting the device.

```c
contextConfig.custom.onContextInit = ma_context_init__custom_loader;
    
    result = ma_context_init(backends, sizeof(backends)/sizeof(backends[0]), &contextConfig, (ma_context*)&context);
    if (result != MA_SUCCESS) {
        return -1;
    }

    /* In playback mode we're just going to play a sine wave. */
    sineWaveConfig = ma_waveform_config_init(DEVICE_FORMAT, DEVICE_CHANNELS, DEVICE_SAMPLE_RATE, ma_waveform_type_sine, 0.2, 220);
    ma_waveform_init(&sineWaveConfig, &sineWave);

    /* The device is created exactly as per normal. */
    deviceConfig = ma_device_config_init(ma_device_type_playback);
    deviceConfig.playback.format   = DEVICE_FORMAT;
    deviceConfig.playback.channels = DEVICE_CHANNELS;
    deviceConfig.capture.format    = DEVICE_FORMAT;
    deviceConfig.capture.channels  = DEVICE_CHANNELS;
    deviceConfig.sampleRate        = DEVICE_SAMPLE_RATE;
    deviceConfig.dataCallback      = data_callback;
    deviceConfig.pUserData         = &sineWave;

    result = ma_device_init((ma_context*)&context, &deviceConfig, (ma_device*)&device);
    if (result != MA_SUCCESS) {
        ma_context_uninit((ma_context*)&context);
        return -1;
    }


    printf("Device Name: %s\n", ((ma_device*)&device)->playback.name);

    if (ma_device_start((ma_device*)&device) != MA_SUCCESS) {
        ma_device_uninit((ma_device*)&device);
        ma_context_uninit((ma_context*)&context);
        return -5;
    }
    
#ifdef __EMSCRIPTEN__
    emscripten_set_main_loop(main_loop__em, 0, 1);
#else
    printf("Press Enter to quit...\n");
    getchar();
#endif
    
    ma_device_uninit((ma_device*)&device);
    ma_context_uninit((ma_context*)&context);

    (void)argc;
    (void)argv;

    return 0;
```

--------------------------------

### miniaud_io Main Program Setup

Source: https://miniaud.io/docs/examples/custom_backend

This C code snippet outlines the main program execution flow for miniaud_io. It defines audio device parameters (format, channels, sample rate), initializes context and device configurations, and sets up a sine wave generator. The example demonstrates using `ma_backend_custom` and explains the strategy for implementing and selecting custom backends.

```c
/*
Main program starts here.
*/
#define DEVICE_FORMAT       ma_format_f32
#define DEVICE_CHANNELS     2
#define DEVICE_SAMPLE_RATE  48000

int main(int argc, char** argv)
{
    ma_result result;
    ma_context_config contextConfig;
    ma_context_ex context;
    ma_device_config deviceConfig;
    ma_device_ex device;
    ma_waveform_config sineWaveConfig;
    ma_waveform sineWave;

    /*
    We're just using ma_backend_custom in this example for demonstration purposes, but a more realistic use case would probably want to include
    other backends as well for robustness.
    */
    ma_backend backends[] = {
        ma_backend_custom
    };

    /*
    To implement a custom backend you need to implement the callbacks in the "custom" member of the context config. The only mandatory
    callback required at this point is the onContextInit() callback. If you do not set the other callbacks, you must set them in
    onContextInit() by setting them on the pCallbacks parameter.

    The way we're doing it in this example enables us to easily plug in multiple custom backends. What we do is set the onContextInit()
    callback to a generic "loader" function (ma_context_init__custom_loader() in this example), which then calls out to backend-specific
    context initialization routines, one of which will be for SDL. That way, if for example we wanted to add support for another backend, 
    we don't need to touch this part of the code. Instead we add logic to ma_context_init__custom_loader() to choose the most appropriate
    custom backend. That will then fill out the other callbacks appropriately.
    */
    contextConfig = ma_context_config_init();
    /* ... rest of the main function ... */
    return 0;
}

```

--------------------------------

### Initialize and Start Playback Device

Source: https://miniaud.io/docs/examples/node_graph

Configures and initializes a playback device with specified format, channels, and sample rate. It then starts the device to play the processed audio. Includes error handling and a cleanup mechanism.

```c
ma_device_config deviceConfig;
ma_device device;

deviceConfig = ma_device_config_init(ma_device_type_playback);
deviceConfig.playback.format   = FORMAT;
deviceConfig.playback.channels = CHANNELS;
deviceConfig.sampleRate        = SAMPLE_RATE;
deviceConfig.dataCallback      = data_callback;
deviceConfig.pUserData         = NULL;

result = ma_device_init(NULL, &deviceConfig, &device);
if (result != MA_SUCCESS) {
    printf("ERROR: Failed to initialize device.");
    goto cleanup_graph;
}

result = ma_device_start(&device);
if (result != MA_SUCCESS) {
    ma_device_uninit(&device);
    goto cleanup_graph;
}

printf("Press Enter to quit...\n");
getchar();

/* We're done. Clean up the device. */
ma_device_uninit(&device);
```

--------------------------------

### Start Audio Engine

Source: https://miniaud.io/docs/examples/engine_advanced

Starts the initialized audio engine. Logs a warning if the engine fails to start.

```c
result = ma_engine_start(&engines[iEngine]);
if (result != MA_SUCCESS) {
    printf("WARNING: Failed to start engine %d.\n", iEngine);
}
```

--------------------------------

### Audio Device and Sound Initialization and Management

Source: https://miniaud.io/docs/examples/hilo_interop

This C code snippet demonstrates the initialization and management of an audio device and sound using the miniaudio library. It includes starting the device and sound, handling user input to quit, and uninitializing all components. Error handling for device initialization is also shown.

```c
/* Link the starting of the device and sound together. */
    ma_device_start(&device);
    ma_sound_start(&sound);


    printf("Press Enter to quit...\n");
    getchar();

    ma_sound_uninit(&sound);
    ma_engine_uninit(&engine);
    ma_device_uninit(&device);
    ma_pcm_rb_uninit(&rb);


    (void)argc;
    (void)argv;
    return 0;
}

/* Error handling for device initialization */
    if (ma_device_init(NULL, &device) != MA_SUCCESS) {
        printf("Failed to initialize the sound.");
        return -1;
    }
```

--------------------------------

### Main Function - Initialization and Setup

Source: https://miniaud.io/docs/examples/hilo_interop

Initializes the capture device and the ring buffer. It configures the device for capture with a specific format and assigns the capture callback. The ring buffer is initialized using parameters from the capture device.

```c
int main(int argc, char** argv)
{
    ma_result result;
    ma_device_config deviceConfig;

    /*
    The first thing we'll do is set up the capture side. There are two parts to this. The first is
    the device itself, and the other is the ring buffer. It doesn't matter what order we initialize
    these in, so long as the ring buffer is created before the device is started so that the
    callback can be guaranteed to have a valid destination. We'll initialize the device first, and
    then use the format, channels and sample rate to initialize the ring buffer.

    It's important that the sample format of the device is set to f32 because that's what the engine
    uses internally.
    */

    /* Initialize the capture device. */
    deviceConfig = ma_device_config_init(ma_device_type_capture);
    deviceConfig.capture.format = ma_format_f32;
    deviceConfig.dataCallback = capture_data_callback;

    result = ma_device_init(NULL, &deviceConfig, &device);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize capture device.");
        return -1;
    }

    /* Initialize the ring buffer. */
    result = ma_pcm_rb_init(device.capture.format, device.capture.channels, device.capture.internalPeriodSizeInFrames * 5, NULL, NULL, &rb);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize the ring buffer.");
        return -1;
    }

    /*
    Ring buffers don't require a sample rate for their normal operation, but we can associate it
    with a sample rate. We'll want to do this so the engine can resample if necessary.
    */
    ma_pcm_rb_set_sample_rate(&rb, device.sampleRate);



    /*
    At this point the capture side is set up and we can now set up the playback side. Here we are
    using ma_engine and linking the captured data to a sound so it can be manipulated just like
    any other sound in the world.

    Note that we have not yet started the capture device. Since the captured data is tied to a
    sound, we'll link the starting and stopping of the capture device to the starting and stopping
    of the sound.
    */

    /* We'll get the engine up and running before we start the capture device. */
    result = ma_engine_init(NULL, &engine);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize the engine.");
        return -1;
    }

    /*
    We can now create our sound. This is created from a data source, which in this example is a
    ring buffer. The capture side will be writing data into the ring buffer, whereas the sound
    will be reading from it.
    */
    result = ma_sound_init_from_data_source(&engine, &rb, 0, NULL, &sound);
    if (result != MA_SUCCESS) {

```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/simple_loopback

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### Audio Node Graph Setup and Device Operation

Source: https://miniaud.io/docs/examples/duplex_effect

This C code snippet illustrates the process of setting up an audio node graph using the miniaudio library. It includes attaching output buses between nodes, initializing data source nodes, and starting/stopping the audio device. Error handling is demonstrated with goto statements for cleanup.

```c
ma_node_attach_output_bus(&g_sourceNode, 0, &g_vocoderNode, 0);

    /* Excite/modulator. Attached to input bus 1 of the vocoder node. */
    result = ma_audio_buffer_ref_init(device.capture.format, device.capture.channels, NULL, 0, &g_exciteData);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize audio buffer for source.");
        goto done2;
    }

    exciteNodeConfig = ma_data_source_node_config_init(&g_exciteData);

    result = ma_data_source_node_init(&g_nodeGraph, &exciteNodeConfig, NULL, &g_exciteNode);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize source node.");
        goto done2;
    }

    ma_node_attach_output_bus(&g_exciteNode, 0, &g_vocoderNode, 1);


    ma_device_start(&device);

    printf("Press Enter to quit...\n");
    getchar();

    /* It's important that we stop the device first or else we'll uninitialize the graph from under the device. */
    ma_device_stop(&device);

/*done4:*/ ma_data_source_node_uninit(&g_exciteNode, NULL);
done3: ma_data_source_node_uninit(&g_sourceNode, NULL);
done2: ma_vocoder_node_uninit(&g_vocoderNode, NULL);
done1: ma_node_graph_uninit(&g_nodeGraph, NULL);
done0: ma_device_uninit(&device);

    (void)argc;
    (void)argv;
    return 0;
}
```

--------------------------------

### Simple Audio Playback in C

Source: https://miniaud.io/docs/examples/simple_playback

This C code snippet demonstrates how to load a sound file and play it back using the miniaudio library's low-level API. It utilizes a data callback function (`data_callback`) to deliver audio frames to the playback device. The example initializes a decoder, configures a playback device, starts playback, and waits for user input to exit.

```c
#include "../miniaudio.c"

#include <stdio.h>

void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
{
    ma_decoder* pDecoder = (ma_decoder*)pDevice->pUserData;
    if (pDecoder == NULL) {
        return;
    }

    ma_decoder_read_pcm_frames(pDecoder, pOutput, frameCount, NULL);

    (void)pInput;
}

int main(int argc, char** argv)
{
    ma_result result;
    ma_decoder decoder;
    ma_device_config deviceConfig;
    ma_device device;

    if (argc < 2) {
        printf("No input file.\n");
        return -1;
    }

    result = ma_decoder_init_file(argv[1], NULL, &decoder);
    if (result != MA_SUCCESS) {
        printf("Could not load file: %s\n", argv[1]);
        return -2;
    }

    deviceConfig = ma_device_config_init(ma_device_type_playback);
    deviceConfig.playback.format   = decoder.outputFormat;
    deviceConfig.playback.channels = decoder.outputChannels;
    deviceConfig.sampleRate        = decoder.outputSampleRate;
    deviceConfig.dataCallback      = data_callback;
    deviceConfig.pUserData         = &decoder;

    if (ma_device_init(NULL, &deviceConfig, &device) != MA_SUCCESS) {
        printf("Failed to open playback device.\n");
        ma_decoder_uninit(&decoder);
        return -3;
    }

    if (ma_device_start(&device) != MA_SUCCESS) {
        printf("Failed to start playback device.\n");
        ma_device_uninit(&device);
        ma_decoder_uninit(&decoder);
        return -4;
    }

    printf("Press Enter to quit...");
    getchar();

    ma_device_uninit(&device);
    ma_decoder_uninit(&decoder);

    return 0;
}

```

--------------------------------

### Simple Loopback Example

Source: https://miniaud.io/docs/examples/index

Demonstrates setting up a simple audio loopback using miniaudio.

```c
/*
Demonstrates how to capture data from a microphone using the low-level API.
https://miniaud.io/docs/examples/simple_loopback.html
*/

// Placeholder for simple loopback code.
```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/simple_playback

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### Engine Hello World

Source: https://miniaud.io/docs/examples/index

A basic example demonstrating how to initialize a miniaudio audio engine and play a sound.

```c
/*
This example demonstrates how to initialize an audio engine and play a sound.
https://miniaud.io/docs/examples/engine_hello_world.html
*/

// Placeholder for engine hello world code.
```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/engine_sdl

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/custom_backend

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### Main Function: Device and Resource Manager Initialization

Source: https://miniaud.io/docs/examples/resource_manager_advanced

The `main` function initializes the audio device with specific configuration (f32 format, data callback) and starts it. It then proceeds to initialize a resource manager, setting the stage for loading audio resources.

```c
int main(int argc, char** argv)
{
    ma_result result;
    ma_device_config deviceConfig;
    ma_device device;
    ma_resource_manager_config resourceManagerConfig;
    ma_resource_manager resourceManager;
    ma_thread jobThread;
    int iFile;

    deviceConfig = ma_device_config_init(ma_device_type_playback);
    deviceConfig.playback.format = ma_format_f32;
    deviceConfig.dataCallback    = data_callback;
    deviceConfig.pUserData       = NULL;

    result = ma_device_init(NULL, &deviceConfig, &device);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize device.");
        return -1;
    }


    /* We can start the device before loading any sounds. We'll just end up outputting silence. */
    result = ma_device_start(&device);
    if (result != MA_SUCCESS) {
        ma_device_uninit(&device);
        printf("Failed to start device.");
        return -1;
    }


    /*
    We have the device so now we want to initialize the resource manager. We'll use the resource manager to load some
    sounds based on the command line.
    */

```

--------------------------------

### SDL Audio Device Initialization and Callbacks

Source: https://miniaud.io/docs/examples/custom_backend

This snippet demonstrates the initialization of SDL audio subsystems and the assignment of various SDL audio device functions to a context structure. It also shows how to set up custom backend callbacks for context initialization, uninitialization, device enumeration, device info retrieval, and device lifecycle management (init, uninit, start, stop).

```c
#if defined(MA_HAS_SDL)

ma_result ma_context_init__sdl(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
{
    ma_result result;
    ma_context_ex* pContextEx = (ma_context_ex*)pContext;
    MA_ASSERT(pContext != NULL);
    MA_ASSERT(pConfig != NULL);
    MA_ASSERT(pCallbacks != NULL);

    /* SDL. */
    pContextEx->sdl.hSDL = ma_dlopen(ma_context_get_log(pContext), "libSDL2-2.0.so.0");
    if (pContextEx->sdl.hSDL == NULL) {
        pContextEx->sdl.hSDL = ma_dlopen(ma_context_get_log(pContext), "libSDL2-2.0.dylib");
    }
    if (pContextEx->sdl.hSDL == NULL) {
        pContextEx->sdl.hSDL = ma_dlopen(ma_context_get_log(pContext), "SDL2.dll");
    }
    if (pContextEx->sdl.hSDL == NULL) {
        return MA_ERROR;
    }

#ifdef MA_NO_RUNTIME_LINKING
    pContextEx->sdl.SDL_InitSubSystem      = (ma_proc)SDL_InitSubSystem;
    pContextEx->sdl.SDL_QuitSubSystem      = (ma_proc)SDL_QuitSubSystem;
    pContextEx->sdl.SDL_GetNumAudioDevices = (ma_proc)SDL_GetNumAudioDevices;
    pContextEx->sdl.SDL_GetAudioDeviceName = (ma_proc)SDL_GetAudioDeviceName;
    pContextEx->sdl.SDL_CloseAudioDevice   = (ma_proc)SDL_CloseAudioDevice;
    pContextEx->sdl.SDL_OpenAudioDevice    = (ma_proc)SDL_OpenAudioDevice;
    pContextEx->sdl.SDL_PauseAudioDevice   = (ma_proc)SDL_PauseAudioDevice;
#else
    pContextEx->sdl.SDL_InitSubSystem      = ma_dlsym(ma_context_get_log(pContext), pContextEx->sdl.hSDL, "SDL_InitSubSystem");
    pContextEx->sdl.SDL_QuitSubSystem      = ma_dlsym(ma_context_get_log(pContext), pContextEx->sdl.hSDL, "SDL_QuitSubSystem");
    pContextEx->sdl.SDL_GetNumAudioDevices = ma_dlsym(ma_context_get_log(pContext), pContextEx->sdl.hSDL, "SDL_GetNumAudioDevices");
    pContextEx->sdl.SDL_GetAudioDeviceName = ma_dlsym(ma_context_get_log(pContext), pContextEx->sdl.hSDL, "SDL_GetAudioDeviceName");
    pContextEx->sdl.SDL_CloseAudioDevice   = ma_dlsym(ma_context_get_log(pContext), pContextEx->sdl.hSDL, "SDL_CloseAudioDevice");
    pContextEx->sdl.SDL_OpenAudioDevice    = ma_dlsym(ma_context_get_log(pContext), pContextEx->sdl.hSDL, "SDL_OpenAudioDevice");
    pContextEx->sdl.SDL_PauseAudioDevice   = ma_dlsym(ma_context_get_log(pContext), pContextEx->sdl.hSDL, "SDL_PauseAudioDevice");
#endif  /* MA_NO_RUNTIME_LINKING */

    result = ((MA_PFN_SDL_InitSubSystem)pContextEx->sdl.SDL_InitSubSystem)(MA_SDL_INIT_AUDIO);
    if (result != 0) {
        ma_dlclose(ma_context_get_log(pContext), pContextEx->sdl.hSDL);
        return MA_ERROR;
    }

    /*
    The last step is to make sure the callbacks are set properly in pCallbacks. Internally, miniaudio will copy these callbacks into the
    context object and then use them for then on for calling into our custom backend.
    */
    pCallbacks->onContextInit             = ma_context_init__sdl;
    pCallbacks->onContextUninit           = ma_context_uninit__sdl;
    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__sdl;
    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__sdl;
    pCallbacks->onDeviceInit              = ma_device_init__sdl;
    pCallbacks->onDeviceUninit            = ma_device_uninit__sdl;
    pCallbacks->onDeviceStart             = ma_device_start__sdl;
    pCallbacks->onDeviceStop              = ma_device_stop__sdl;

    return MA_SUCCESS;
}
#endif  /* MA_HAS_SDL */

```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/resource_manager

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/simple_mixing

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/simple_playback_sine

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### Simple Playback Example

Source: https://miniaud.io/docs/examples/index

Demonstrates how to load a sound file and play it back using the low-level API of miniaudio. This involves initializing a device and a decoder.

```C
#include <stdio.h>
#include "miniaudio.h"

ma_decoder decoder;

void playback_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount) {
    (void)pInput;
    ma_decoder_read_pcm_frames(&decoder, pOutput, frameCount, NULL);
}

int main(void) {
    ma_context context;
    ma_device_config deviceConfig;
    ma_device device;
    ma_decoder_config decoderConfig;
    ma_result result;

    // Initialize the context
    result = ma_context_init(NULL, 0, NULL, &context);
    if (result != MA_SUCCESS) {
        fprintf(stderr, "Failed to initialize context\n");
        return -1;
    }

    // Configure the audio device
    deviceConfig = ma_device_config_init(ma_device_type_playback);
    deviceConfig.sampleRate = 44100;
    deviceConfig.periodSizeInFrames = 1024;
    deviceConfig.dataCallback = playback_callback;

    // Initialize the audio device
    result = ma_device_init(NULL, &deviceConfig, &device);
    if (result != MA_SUCCESS) {
        fprintf(stderr, "Failed to initialize audio device\n");
        ma_context_uninit(&context);
        return -1;
    }

    // Configure the decoder
    decoderConfig = ma_decoder_config_init(ma_format_unknown, 0, 0);

    // Initialize the decoder for the sound file
    result = ma_decoder_init_file("sound.wav", &decoderConfig, &decoder);
    if (result != MA_SUCCESS) {
        fprintf(stderr, "Failed to initialize decoder for sound.wav\n");
        ma_device_uninit(&device);
        ma_context_uninit(&context);
        return -1;
    }

    // Start the audio device
    result = ma_device_start(&device);
    if (result != MA_SUCCESS) {
        fprintf(stderr, "Failed to start audio device\n");
        ma_decoder_uninit(&decoder);
        ma_device_uninit(&device);
        ma_context_uninit(&context);
        return -1;
    }

    printf("Playing sound.wav... Press Enter to stop.\n");
    getchar();

    // Stop and uninit everything
    ma_device_stop(&device);
    ma_decoder_uninit(&decoder);
    ma_device_uninit(&device);
    ma_context_uninit(&context);

    return 0;
}
```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/simple_spatialization

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### miniaudio Examples

Source: https://miniaud.io/docs/examples/resource_manager_advanced

A collection of examples demonstrating various functionalities of the miniaudio library, including custom backends, decoders, effects, and basic audio operations.

```html
Custom Backend: https://miniaud.io/docs/examples/custom_backend.html
Custom Decoder: https://miniaud.io/docs/examples/custom_decoder.html
Custom Decoder Engine: https://miniaud.io/docs/examples/custom_decoder_engine.html
Data Source Chaining: https://miniaud.io/docs/examples/data_source_chaining.html
Duplex Effect: https://miniaud.io/docs/examples/duplex_effect.html
Engine Advanced: https://miniaud.io/docs/examples/engine_advanced.html
Engine Effects: https://miniaud.io/docs/examples/engine_effects.html
Engine Hello World: https://miniaud.io/docs/examples/engine_hello_world.html
Engine Sdl: https://miniaud.io/docs/examples/engine_sdl.html
Engine Steamaudio: https://miniaud.io/docs/examples/engine_steamaudio.html
Hilo Interop: https://miniaud.io/docs/examples/hilo_interop.html
Node Graph: https://miniaud.io/docs/examples/node_graph.html
Resource Manager: https://miniaud.io/docs/examples/resource_manager.html
Resource Manager Advanced: https://miniaud.io/docs/examples/resource_manager_advanced.html
Simple Capture: https://miniaud.io/docs/examples/simple_capture.html
Simple Duplex: https://miniaud.io/docs/examples/simple_duplex.html
Simple Enumeration: https://miniaud.io/docs/examples/simple_enumeration.html
Simple Loopback: https://miniaud.io/docs/examples/simple_loopback.html
Simple Looping: https://miniaud.io/docs/examples/simple_looping.html
Simple Mixing: https://miniaud.io/docs/examples/simple_mixing.html
Simple Playback: https://miniaud.io/docs/examples/simple_playback.html
Simple Playback Sine: https://miniaud.io/docs/examples/simple_playback_sine.html
Simple Spatialization: https://miniaud.io/docs/examples/simple_spatialization.html
```

--------------------------------

### Audio Playback Initialization and Management

Source: https://miniaud.io/docs/examples/simple_mixing

Initializes an audio playback device with specified format, channels, and sample rate. It sets up a data callback function and starts playback. The function waits for a stop event before uninitializing the device and cleaning up resources.

```c
/* Create only a single device. The decoders will be mixed together in the callback. In this example the data format needs to be the same as the decoders. */
    deviceConfig = ma_device_config_init(ma_device_type_playback);
    deviceConfig.playback.format   = SAMPLE_FORMAT;
    deviceConfig.playback.channels = CHANNEL_COUNT;
    deviceConfig.sampleRate        = SAMPLE_RATE;
    deviceConfig.dataCallback      = data_callback;
    deviceConfig.pUserData         = NULL;

    if (ma_device_init(NULL, &deviceConfig, &device) != MA_SUCCESS) {
        for (iDecoder = 0; iDecoder < g_decoderCount; ++iDecoder) {
            ma_decoder_uninit(&g_pDecoders[iDecoder]);
        }
        free(g_pDecoders);
        free(g_pDecodersAtEnd);

        printf("Failed to open playback device.\n");
        return -3;
    }

    /*
    We can't stop in the audio thread so we instead need to use an event. We wait on this thread in the main thread, and signal it in the audio thread. This
    needs to be done before starting the device. We need a context to initialize the event, which we can get from the device. Alternatively you can initialize
    a context separately, but we don't need to do that for this example.
    */
    ma_event_init(&g_stopEvent);

    /* Now we start playback and wait for the audio thread to tell us to stop. */
    if (ma_device_start(&device) != MA_SUCCESS) {
        ma_device_uninit(&device);
        for (iDecoder = 0; iDecoder < g_decoderCount; ++iDecoder) {
            ma_decoder_uninit(&g_pDecoders[iDecoder]);
        }
        free(g_pDecoders);
        free(g_pDecodersAtEnd);

        printf("Failed to start playback device.\n");
        return -4;
    }

    printf("Waiting for playback to complete...\n");
    ma_event_wait(&g_stopEvent);
    
    /* Getting here means the audio thread has signaled that the device should be stopped. */
    ma_device_uninit(&device);
    
    for (iDecoder = 0; iDecoder < g_decoderCount; ++iDecoder) {
        ma_decoder_uninit(&g_pDecoders[iDecoder]);
    }
    free(g_pDecoders);
    free(g_pDecodersAtEnd);

    return 0;
}
```
Tokens:
Raw