Repository navigation
- 8000
|
Hi, I'm implementing dynamic sample rate adjustment in miniaudio and would appreciate feedback on my approach. I've written a function that reinitializes the device with a new sample rate: struct ma_context_collection {
ma_context context;
ma_device device;
ma_engine engine;
ma_resource_manager resourceManager;
ma_uint32 sampleRate;
ma_uint8 channels;
ma_format format;
};
MA_API ma_result ma_reinit_device(ma_context_collection* collection, ma_uint32 sampleRate)
{
if (collection == NULL)
return MA_INVALID_ARGS;
if (collection->device.sampleRate == sampleRate)
return MA_SUCCESS;
collection->sampleRate = sampleRate;
collection->engine.sampleRate = sampleRate;
ma_device_id deviceId;
memset(&deviceId, 0, sizeof(deviceId));
ma_device_config deviceConfig = ma_device_config_init(ma_device_type_playback);
deviceConfig.playback.format = collection->device.playback.format;
deviceConfig.playback.channels = collection->device.playback.channels;
deviceConfig.sampleRate = sampleRate;
deviceConfig.dataCallback = collection->device.onData;
memcpy(&deviceId, &collection->device.playback.id, sizeof(collection->device.playback.id));
deviceConfig.playback.pDeviceID = &deviceId;
ma_result ret = ma_device_stop(&collection->device);
if (ret != MA_SUCCESS) {
return ret;
}
ma_engine_uninit(&collection->engine);
ma_device_uninit(&collection->device);
memset(&collection->device, 0, sizeof(collection->device));
ret = ma_device_init(&collection->context, &deviceConfig, &collection->device);
if (ret != MA_SUCCESS) {
return ret;
}
ma_engine_config engineConfig = ma_engine_config_init();
engineConfig.listenerCount = MA_ENGINE_MAX_LISTENERS;
engineConfig.pDevice = &collection->device;
engineConfig.pResourceManager = &collection->resourceManager;
ret = ma_engine_init(&engineConfig, &collection->engine);
if (ret != MA_SUCCESS) {
ma_device_uninit(&collection->device);
return ret;
}
collection->device.pUserData = &collection->engine;
ret = ma_device_start(&collection->device);
if (ret != MA_SUCCESS) {
ma_device_uninit(&collection->device);
return ret;
}
return MA_SUCCESS;
}I've noticed that after changing the sample rate, I need to reinitialize existing ma_sound instances. Here's how I'm handling that: ma_context_collection collection;
// ...
ma_sound sound;
ma_sound_init_from_file(&collection.engine, path, MA_SOUND_FLAG_ASYNC | MA_SOUND_FLAG_STREAM, NULL, NULL, &sound);
ma_uint32 audioSampleRate = 0;
ma_sound_get_data_format(&sound, NULL, NULL, &audioSampleRate, NULL, 0);
if (collection.sampleRate != audioSampleRate)
{
ma_result ret = ma_reinit_device(&collection, audioSampleRate);
if (ret == MA_SUCCESS)
{
ma_sound_uninit(&sound);
ma_sound_init_from_file(&collection.engine, path, MA_SOUND_FLAG_ASYNC | MA_SOUND_FLAG_STREAM, NULL, NULL, &sound);
}
}My questions:
My tests show this works locally, but I want to ensure it's a robust solution before using it in production. |
Replies: 1 comment 5 replies
What is your use case for wanting to dynamically change your sample rate? Is it just a configuration thing that you user changes through the UI? |
|
Thanks for the quick response. I'm building a local music player with miniaudio and want to avoid resampling whenever possible when playing songs with different formats. My goal is to dynamically adjust the device's sample rate based on the audio file being played—for example, automatically adapting to high‑sample‑rate tracks like DSF instead of downsampling everything to 44.1kHz or 48kHz. I initially tried setting the device to a fixed sample rate of 44.1kHz, but when playing a DSF file (which has a native sample rate of 352.8kHz), I got some hissing/scratching noises. After adjusting the device's sample rate to match the file's native rate (352.8kHz), the issue disappeared. |
|
OK, yes that would be a use case where changing the rate at the device level would be the best option. When you use a fixed sample rate at the device level you will end up using miniaudio's resampler when going from 352.8 down to 44.1, and the problem with that is miniaudio's resampler is just a dumb linear resampler with a low pass filter for anti-aliasing. So I am not surprised you would be hearing artifacts with that. When changing it at the device level it gives the backend a chance to use it's own internal resampler which is likely higher quality than miniaudio's and would explain why the issue goes away. Something you could consider to simplify your object management is to bypass the engine completely and use |
|
Thank you mackron, this simpler approach is perfect❤️ |
|
I think I need to improve the communication on that. Did you see the The idea is that the engine is just an optional extension to make it easier to do mixing, effects and sound management. The core part of the library is actually I'd be interested in feedback on how to improve the communication on that front. |
|
Yes, when I first looked at the README, the first one (ma_engine) does look simpler and feels like the "recommended" way. It wasn't until you mentioned the simple_playback example that I realized ma_device + ma_decoder was a better fit for my use case. A small note before the first example would probably be enough. Something like:
That would help users pick the right approach from the start. |
What is your use case for wanting to dynamically change your sample rate? Is it just a configuration thing that you user changes through the UI?