Streaming seems to load full file into memory

[daanwitters]

I have no doubt that I am doing something wrong, but please help me out here. Thanks in advance.

I am trying to play rather large music files so I'm swapping from using a regular decoder to using a resource manager using streaming instead.
When I use the top command in Linux terminal I seem to get very similar memory buffered for the miniaudio PID regardless of whether I use streaming or not. More concretely when I play a long file from a USB drive and remove it mid way, streaming should stop right? (which it doesn't) As it can't continue paging.

I initialize the resource manager data source like this:

ma_resource_manager_data_source_init(&resourceManager,file.c_str(),
    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE 
    |MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM,
    NULL,&dataSource);

And use the following callback for the device (playback type):

void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount){
    ma_result result = ma_data_source_read_pcm_frames((ma_data_source*)pDevice->pUserData, pOutput, frameCount, NULL);
    if(MA_AT_END == result){
        //send out some signal
    }
    (void)pInput;
}

And the resource manager like this:

     resourceManagerConfig = ma_resource_manager_config_init();
     resourceManagerConfig.decodedFormat     = device.playback.format;
     resourceManagerConfig.decodedChannels   = device.playback.channels;
     resourceManagerConfig.decodedSampleRate = device.sampleRate;
     result = ma_resource_manager_init(&resourceManagerConfig, &resourceManager);

[mackron]

Your sample code looks fine on the surface. Are you able to run the program below and let see if you get the same results? Pass in the file path via the command line. May need to adjust the location of the miniaudio.h include based on your setup.

Could you also let me know what the flags member of the data source is set to after it's been initialized?

#define MINIAUDIO_IMPLEMENTATION
#include "miniaudio.h"

void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
{
    ma_data_source_read_pcm_frames((ma_data_source*)pDevice->pUserData, pOutput, frameCount, NULL);

    (void)pInput;
}

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_resource_manager_data_source dataSource;

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


    /* We'll initialize the device first. */
    deviceConfig = ma_device_config_init(ma_device_type_playback);
    deviceConfig.dataCallback = data_callback;
    deviceConfig.pUserData    = &dataSource;    /* <-- We'll be reading from this in the data callback. */

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


    /*
    We have the device so now we want to initialize the resource manager. We'll use the resource manager to load a
    sound based on the command line.
    */
    resourceManagerConfig = ma_resource_manager_config_init();
    resourceManagerConfig.decodedFormat     = device.playback.format;
    resourceManagerConfig.decodedChannels   = device.playback.channels;
    resourceManagerConfig.decodedSampleRate = device.sampleRate;

    result = ma_resource_manager_init(&resourceManagerConfig, &resourceManager);
    if (result != MA_SUCCESS) {
        ma_device_uninit(&device);
        printf("Failed to initialize the resource manager.");
        return -1;
    }

    /* Now that we have a resource manager we can load a sound. */
    result = ma_resource_manager_data_source_init(&resourceManager, argv[1], MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE | MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM, NULL, &dataSource);
    if (result != MA_SUCCESS) {
        printf("Failed to load sound \"%s\".", argv[1]);
        return -1;
    }


    /* Now that we have a sound we can start the device. */
    result = ma_device_start(&device);
    if (result != MA_SUCCESS) {
        ma_device_uninit(&device);
        printf("Failed to start device.");
        return -1;
    }

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

    /* Teardown. */

    /* Uninitialize the device first to ensure the data callback is stopped and doesn't try to access any data. */
    ma_device_uninit(&device);

    /*
    Before uninitializing the resource manager we need to uninitialize every data source. The data source is owned by
    the caller which means you're responsible for uninitializing it.
    */
    ma_resource_manager_data_source_uninit(&dataSource);

    /* Uninitialize the resource manager after each data source. */
    ma_resource_manager_uninit(&resourceManager);

    return 0;
}

[daanwitters]

I swapped from using Qt creator's build system (qmake) to using a Makefile with g++, and everything seems to work fine now (when removing the drive, the sounds stop playing after a while, indicating it doesn't buffer everything.
Using the example you provided, it behaves the same as mine in Qt, but also works fine using g++.

Thanks for the help!

Regarding buffered memory, I misinterpreted the results, so please ignore the comments I made about it above.

My data source flags are left default, as is done in the example you provided, printing them out gives 3 so I assume the flags

MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM    = 0x00000001,   
MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE    = 0x00000002,

have been set (setting async doesn't change the results).

[daanwitters]

@mackron sorry to bother you again.

Is it possible that decoded files are always buffered fully somewhere in memory? When I remove an USB drive containing the mp3 file playing, it continues playing the whole song, and it seems to take a while to decode as well. When I do the same thing using a .wav, the file stops playing after a few seconds.

I am still using all the settings mentioned above and I've also tested this using the sample code you provided.
My project is has very limited memory so this would definitely not be ideal.

Also where decoded data is written to or is it just put on heap?

[mackron]

No, that's not possible when loading a stream. When the STREAM flag is specified, the code will load a stream, not a buffer:

if ((pConfig->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
    return ma_resource_manager_data_stream_init_ex(pResourceManager, pConfig, &pDataSource->backend.stream);
} else {
    return ma_resource_manager_data_buffer_init_ex(pResourceManager, pConfig, &pDataSource->backend.buffer);
}

The only time the whole sound would be loaded into memory is if it happens to be shorter than two seconds (each page is 1 second, and there's 2 pages). It's unlikely this is the case for you.

I've just tested with that sample program I posted above and it's certainly not fully loading it into memory:

(That screenshot is from loading a ~3 minute long song)

Make double sure you're specifying the MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM flag. Also, make sure you don't have some other code somewhere loading the sound such as with ma_resource_manager_register_file().

When a stream is loaded, two pages are allocated on the heap, each being 1 second long:

pageBufferSizeInBytes = ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream) * 2 * ma_get_bytes_per_frame(pDataStream->decoder.outputFormat, pDataStream->decoder.outputChannels);

pDataStream->pPageData = ma_malloc(pageBufferSizeInBytes, &pResourceManager->config.allocationCallbacks);

That's the only buffer being allocated for streams for the purpose of audio playback. It's impossible for the sound to be fully loaded into memory if it's being loaded as a stream. This would have been reported a long, long time ago if that was the case because that's the whole point of a stream. If that's happening it means your code is triggering it somewhere.

[yanostulens]

Dear @mackron,

I'm having the same issue here. I copied the code you posted in you first comment word for word.

I playback an mp3 file from a USB-drive plugged into my pc (Ubuntu), after the music starts playing I unplug the USB-drive but the music just keeps on playing. When I do the exact same thing but with a wav file the music stops playing after around a second (which we would expect). It seems to me that this means the decoded mp3 file is buffered or stored somewhere on the internal memory.

Do you have any idea why this would happen?

Thank you for all the help :)

[mackron]

I tried that sample code I posted above without the STREAM flag, and I get ~95MB of usage:

Can you compare the memory usage both with and without the STREAM flag and report the results?

For me, with STREAM I'm getting ~3MB of usage, and without I'm getting ~95MB. That's exactly what I'd expect from a roughly 3 and a half minute song.

Is this happening with all MP3 files?

[yanostulens]

@mackron, same results here. With the STREAM flag I get ~1MB, without I get 34MB in memory. So this indeed shows the workings of streaming. What bothers me so much do is the question to why these MP3's keep playing. I'm starting to believe that Ubuntu is somehow caching files that are opened from a USB drive.

Nevertheless thank you very much for all the help and the awesome library! :)

[mackron]

I think as you say most likely it's just the operating system doing some kind of buffering of the file. Maybe it knows you're reading from removable storage so it's being safe by moving it into cache or something, I don't know.