Example of playing sound chunk by chunk?

[SC-One]

I could not find example of playing a sound that using callbacks or other ways that can use chunks of data. [Just found this] [2] 3

I mean Consumer/Provider data. I have custom provider that provide data in random periods(enough fast) , And I wanna use miniaudio as consumer that play my chunks data.
Where I can find an example or basic concepts that can help me to accomplish the goal? (or what's High level api for providing chunks data on sounds instead using files)

In addition my application is complete multi threaded.

[SC-One]

All examples using _file api , I dont know why there is no example that preparing data by callback (or any way that represent data as chunks) .
I just need a reference link to same aspects.

[SC-One]

I know something same to this is for reading from memory , But need process data that produce real time (background thread) , I mean play a sound that has dynamic buffer.

below example is whole of Buffer(sound) , it's not my goal.

    ma_result result = ma_decoder_init_memory(buffer, len, NULL, &decoder);

    if (result != MA_SUCCESS)
    {
        std::cout << "ERROR:   Failed decoder initialization." << std::endl;
        ma_decoder_uninit(&decoder);
        return;
    }

[mackron]

Are your data chunks in uncompressed PCM format, or do you mean you have chunks of encoded data such as compressed MP3 data?

If your data is already decoded (PCM), it's just a matter of giving the data to miniaudio via the data callback. If you're using the high level API (ma_engine) you would need to implement your own data source and use ma_sound_init_from_data_source(). The ring buffer might help (ma_pcm_rb) - that's a single-producer, single-consumer buffer (miniaudio would be the consumer).

If your data is still encoded (such as chunk of MP3 data), that is not supported by miniaudio and you will need to decode that separately before handing it to miniaudio.

(Moving this to the Discussions section.)

[mackron]

Do you mean you need to know how to implement the reading and seeking callbacks that are required in ma_decoder_init()? They're self explanatory. You just give miniaudio the specified number of bytes and write them to the supplied output buffer. Also write out the number of bytes that were actually read. Return MA_SUCCESS if everything went well, otherwise some other error code. There's no need for an example for this. I can't write examples for every single function in the library.

I don't know exactly what it is you're asking. If you have data that's already been decoded outside of miniaudio, it's just a matter of giving miniaudio the data so it can play it. I don't understand what the issue is here - just give the data to miniaudio however you want. So long as miniaudio gets the data it doesn't care how you get it there. Are you using the low level API? Just give it to the data callback however you want. You can make use of the pUserData member in ma_device to help you if you need it. If you're using the high level API, implement a custom data source and use ma_sound_init_from_data_source().

[SC-One]

I don;t need example , but how implement custom data source is best Document for this library! And We can't find it.
You cant write example for every single function , but you already write 1000 example that using just _file api.
whole of examples just is about reading files , all of them.

And at the end , I love it , because it worked as well on two platforms, I will try more.
Thanks regards.

[mackron]

The vast majority of people load from files so it makes sense that example code would focus on that. Custom data sources are documented in section 4.1 of the documentation: https://miniaud.io/docs/manual/#DataSources

[xfeltms]

Maybe this example would be useful to SC-One and others. An object instanciated for a class, that generates audio pr sample, is send to the callback funtion. The class could get chunks of data in whatever way programmed. I was looking for such an example code:

#define MA_NO_DECODING
#define MA_NO_ENCODING
#define MINIAUDIO_IMPLEMENTATION
#include "../include/miniaudio.h"

#include <stdio.h>
#include <math.h>

#ifdef EMSCRIPTEN
#include <emscripten.h>

void main_loop__em()
{
}
#endif

#define DEVICE_FORMAT ma_format_f32
#define DEVICE_CHANNELS 2
#define DEVICE_SAMPLE_RATE 48000

class audiogen
{//generates audio data per sample
private:
double fX = 0;
double fXAdd = 0.02;
public:
double GetNextSample()
{
fX+=fXAdd;

        if(fX>1.0)
        {
            fXAdd=0.2;
        }

        if(fX<0.0)
        {
            fXAdd=-0.2;
        }

        double fSample = sin(fX);
        return fSample;
    }

};

void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
{
audiogen* pAGen;

MA_ASSERT(pDevice->playback.channels == DEVICE_CHANNELS);

pAGen= (audiogen*)pDevice->pUserData;
MA_ASSERT(pAGen != NULL);

float* pFramesOutF32 = (float*)pOutput;
int iArrPos=0;
float fSample = (*pAGen).GetNextSample();
for (int iFrame = 0; iFrame < frameCount; iFrame += 1) 
{
    for (int iChannel = 0; iChannel < 2; iChannel += 1) 
    {
        iArrPos++;
        pFramesOutF32[iFrame*2 + iChannel] = fSample;
    }
}

(void)pInput;   /* Unused. */

}

int main(int argc, char** argv)
{
ma_waveform sineWave;
ma_device_config deviceConfig;
ma_device device;
ma_waveform_config sineWaveConfig;

audiogen agenobj;

deviceConfig = ma_device_config_init(ma_device_type_playback);
deviceConfig.playback.format   = DEVICE_FORMAT;
deviceConfig.playback.channels = DEVICE_CHANNELS;
deviceConfig.sampleRate        = DEVICE_SAMPLE_RATE;
deviceConfig.dataCallback      = data_callback;
deviceConfig.pUserData         = &agenobj; //audio generator object

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

printf("Device Name: %s\n", device.playback.name);

if (ma_device_start(&device) != MA_SUCCESS) {
    printf("Failed to start playback device.\n");
    ma_device_uninit(&device);
    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(&device);

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

}

[xfeltms]

A correction to the callback function regarding this line:

float fSample = (*pAGen).GetNextSample();

It should be placed as shown below, to play as intended:

void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
{
audiogen* pAGen;

MA_ASSERT(pDevice->playback.channels == DEVICE_CHANNELS);

pAGen= (audiogen*)pDevice->pUserData;
MA_ASSERT(pAGen != NULL);

float* pFramesOutF32 = (float*)pOutput;
int iArrPos=0;
for (int iFrame = 0; iFrame < frameCount; iFrame += 1)
{

float fSample = (*pAGen).GetNextSample(); //line should be here

for (int iChannel = 0; iChannel < 2; iChannel += 1) 
{
    iArrPos++;
    pFramesOutF32[iFrame*2 + iChannel] = fSample;
}

}

(void)pInput; /* Unused. */
}