How to decode long files via streaming?

[erikjalevik]

I am trying to decode a file into memory asynchronously via streaming, to avoid having to wait for the entire file to be processed before any data becomes available.

If possible, I'd like to do it without implementing my own thread handling. To do so, I thought I'd use the notification functionality of the resource manager.

I'm passing a ma_resource_manager_pipeline_notifications object to ma_resource_manager_data_source_init, along with flags MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM and MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC.

This way, I'm receiving an "init" event after the first bit of audio has been decoded. Here ma_resource_manager_data_source_get_available_frames returns 88000 frames, which I then consume via ma_data_source_read_pcm_frames.

But then I'm stuck. How do I continue from here? I would have hoped to receive events continuously as each bit of audio becomes available, but it seems like "init" is only emitted once, and "done" only at the end, as you'd expect.

Would I have to set up a polling thread that checks for new data at regular intervals?

Furthermore, I'm not quite clear about whether I should use ma_data_source_read_pcm_frames or ma_resource_manager_data_source_read_pcm_frames to consume the audio in this scenario. What is the difference between these two functions?

Thanks!

[mackron]

It doesn't work the way you're thinking. You don't receive notifications to tell you when some audio is ready. Put simply, when you call ma_resource_manager_data_source_read_pcm_frames(), the resource manager will automatically load pages in the background as you read. When you initialize the resource manager, there's a background thread running. As you read data, the resource manager will post an internal message to the background thread to read more data. This is all done for you automatically as you read data.

A data source created by the resource manager is a ma_data_source, which means it can be plugged into any function that takes a ma_data_source object. In practice, ma_resource_manager_data_source_read_pcm_frames() and ma_data_source_read_pcm_frames() do the same thing, but ma_data_source will give you more features such as loop points and ranges. I generally recommend you use ma_data_source_read_pcm_frames() to keep everything uniform. That way, if you change your data source to, for example, an ma_decoder, you'll be able to plug in the new data source and everything will Just Work without further changes.

[erikjalevik]

Thanks for the quick reply!

Yes, I read the bit about ma_resource_manager_data_source_read_pcm_frames() in the programming manual doing more loading in the background, but the piece of the puzzle I'm missing is how to know when to call it, without setting up a polling loop repeatedly checking if there's frames available.

(For context, the use case here is just rendering an audio waveform to the screen as quickly as possible.)

[mackron]

So you want to be able to decode the entire sound as fast as possible? As in, you won't be actually playing the sound back while you're loading or anything?

[erikjalevik]

Yeah, I need to play back sounds too, but that can happen independently of the waveform rendering. So I was planning to have separate player and decoder logic. If the decoder has to use a worker thread internally it's not the end of the world. Was just hoping that Miniaudio abstracted that part away, since it does so for playback.

[erikjalevik]

Got stuck again when trying the sync implementation. Both ma_decode_file and ma_decoder_init_file give you the option of passing in a config specifying format, channel count and sample rate. I would like to use floats as the format, but also whatever native channel count and sample rate the file has (it can be any arbitrary file). I think that means I should leave the config as NULL, if I interpret the phrase "When passing in NULL for decoder config in ma_decoder_init*(), the output format will be the same as that defined by the decoding backend" correctly.

However, both functions just return the audio as an interleaved void* buffer. So unless I hardcode a channel count upfront, how can I know the channel count embedded in this void* array?

Is the idea that I first create a data source from the file, and use ma_data_source_get_data_format on it, and only thereafter use the decode functions? It somehow seems like an unnecessary extra step that I should be able to avoid...

[mackron]

If you want to have two copies of the data, both of which with different formats, the only practical way I can think of would be to use a data converter. Initialize your decoder with a NULL config (you are correct in it's usage), and then inspect the outputFormat, outputChannels and outputSampleRate members of your ma_decoder instance to know it's native format. As you read with with ma_decoder_read_pcm_frames() (or ma_data_source_read_pcm_frames()), you'll get data in it's native format. Do what you need to do with that data, and then pass it through a ma_data_converter to convert it to the other data format you need. If you only need to convert the sample format and not the channel count or sample rate, use ma_convert_pcm_frames_format() (use ma_dither_mode_none for the dithering mode).

[erikjalevik]

Ah thanks, I had completely missed that I could retrieve native format, channels and sample rate from the decoder. That should let me piece it all together.