How to play multiple sound files? Not at the same time.

[patrikpatrik]

Sorry for asking such a noobish question but I can't find any documentation on this or my brain is kind of not functioning right. I just want to load up lets say a bird wav file and a dog barkding wav file.

I read that I'm not supposed to create another device but then how would I load both of them and play either one if I press B for bird or D for dog barking? I know about the callback but how do I distinguish 'ma_device_start(&device);' to start the one I want?

[mackron]

Decoders and devices are 100% decoupled from each other. Initialise 1 device and 2 decoders - one for bird and one for dog. When playing bird, read from that decoder; when playing dog read from that one. Rewind the decoders back to the start when you want to play them a second time (by seeking to frame 0).

[mackron]

Also, depending on your requirements you can use the high level API to do away with devices and decoders all together (look up the engine section in the documentation if you're interested in that).

[patrikpatrik]

Thank you for the quick response. I tried the 1 device with 2 decoders, but only the dog barking plays even though I tried to play the bird wav file. Am I doing this wrong?

`

// in main    
ma_decoder decoder; // <-- for bird    
ma_decoder decoder2; // <-- for dog bark    

const char* birdFile = "./bird.wav";    
const char* dogFile = "./dogBark.wav";    

if (strlen(birdFile) < 2) {    
    std::cout << "Couldnt find an input file!\n";    
    return -1;    
}    
result = ma_decoder_init_file(birdFile, NULL, &decoder);    
if (result != MA_SUCCESS) {
    std::cout << "Could not load file!\n";
    return -1;
}
if (strlen(dogFile) < 2) {
    std::cout << "Couldnt find an input file!\n";
    return -1;
}
result2 = ma_decoder_init_file(dogFile, NULL, &decoder2);
if (result2 != MA_SUCCESS) {
    std::cout << "Could not load file!\n";
    return -1;
}

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; // <-- for bird
deviceConfig.pUserData = &decoder2; // <-- for dog bark

if (ma_device_init(NULL, &deviceConfig, &device) != MA_SUCCESS) {
    std::cout << "Failed to open bird playback device!\n";
    ma_decoder_uninit(&decoder);
    return -1;
}
if (ma_device_init(NULL, &deviceConfig, &device) != MA_SUCCESS) {
    std::cout << "Failed to open dogBark playback device!\n";
    ma_decoder_uninit(&decoder2);
    return -1;
}

// then to play in callback function
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    if (key == GLFW_KEY_T && action == GLFW_PRESS)
    {
         ma_decoder_seek_to_pcm_frame(&decoder, 0); // <-- bird tree
         // ma_decoder_seek_to_pcm_frame(&decoder2, 0); // <-- dog bounce
         ma_device_start(&device);
    }
}

`
// only dog one plays

[mackron]

For starters, you're initialising your device twice. Remove the second initialization. Second, you'll need to post the data callback so I can see what's going on in there. Just looking at it, I can see that you're not setting any kind of variable to indicate what sound is playing. You need to set some kind of variable in key_callback to indicate which sound you want to be playing, and then check that variable in the callback.

If you're a beginner, I would highly suggest using the high level API. The low level API (what you're using now) has complications that you need to be aware of, particularly with thread safety. I would highly suggest using the high level API, something like this (untested):

static ma_engine g_engine;

int main(int argc, char** argv)
{
    ma_result result;

    result = ma_engine_init(NULL, &g_engine);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize audio engine.");
        return -1;
    }

    // ...
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    if (action == GLFW_PRESS)
    {
        if (key == GLFW_KEY_B) {
            ma_engine_play_sound(&g_engine, birdFile, NULL);
        } else if (key == GLFW_KEY_D) {
            ma_engine_play_sound(&g_engine, dogFile, NULL);
        }
    }
}

With this there's no device, no data callback and no decoders - just the main engine object (ma_engine) and some sounds. My suggestion is to get that working and then go from there.

[patrikpatrik]

@mackron Thank you, this high level api works wonders. For about 30 minutes I couldn't get ma_engine initialized until I realized I had an older version of miniaudio.h where there was no ma_engine. By the way, my key_callback looked like this for the lower level api:

    // to register key input JUST ONCE    
    void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)    
  {    
    
    if (key == GLFW_KEY_B && action == GLFW_PRESS)
    {
        std::cout << "Pressed B!\n";

         ma_decoder_seek_to_pcm_frame(&decoder, 0);
         ma_device_start(&device);
    }
}

and my data_callback is:

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

    if(!g_IsPaused)
        ma_decoder_read_pcm_frames(pDecoder, pOutput, frameCount);

    //(void)pInput;
}

[patrikpatrik]

GAH stupid backticks arent working to encapsulate code what the heck is wrong!!!!