From dc72a5683b11bb346d5760870e2b4897b49c3b75 Mon Sep 17 00:00:00 2001 From: David Reid Date: Wed, 4 Feb 2026 10:52:08 +1000 Subject: [PATCH] Add some getters: ma_device_get_format() ma_device_get_channels() ma_device_get_sample_rate() ma_device_get_internal_format() ma_device_get_internal_channels() ma_device_get_internal_sample_rate() ma_device_get_internal_channel_map() --- miniaudio.h | 329 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 318 insertions(+), 11 deletions(-) diff --git a/miniaudio.h b/miniaudio.h index 5828b21c..594d04f5 100644 --- a/miniaudio.h +++ b/miniaudio.h @@ -9379,6 +9379,84 @@ This should only be called in single-threaded mode. It should be called in a loo MA_API ma_result ma_device_step(ma_device* pDevice, ma_blocking_mode blockingMode); +/* +Retrieve the format of the device. + + +Parameters +---------- +pDevice (in) + A pointer to the device whose format is being retrieved. + +deviceType (in) + Either `ma_device_type_playback` or `ma_device_type_capture` specifying which side of the device whose format is being retrieved. + + +Return Value +------------ +The public facing format of the device. + +Will return `ma_format_unknown` if an invalid device or device type is specified. + + +Remarks +------- +Since the capture and playback sides can have different sample formats you need to use the `deviceType` parameter to discrimate between +the two. Use `ma_device_type_playback` for the playback side, or `ma_device_type_capture` for the capture side. You cannot use +`ma_device_type_duplex`. Doing so will result in `ma_format_unknown` being returned. +*/ +MA_API ma_format ma_device_get_format(const ma_device* pDevice, ma_device_type deviceType); + +/* +Retrieve the channel count of the device. + + +Parameters +---------- +pDevice (in) + A pointer to the device whose channel count is being retrieved. + +deviceType (in) + Either `ma_device_type_playback` or `ma_device_type_capture` specifying which side of the device whose channel count is being retrieved. + + +Return Value +------------ +The public facing channel count of the device. + +Will return 0 if an invalid device or device type is specified. + + +Remarks +------- +Since the capture and playback sides can have different channel counts you need to use the `deviceType` parameter to discrimate between +the two. Use `ma_device_type_playback` for the playback side, or `ma_device_type_capture` for the capture side. You cannot use +`ma_device_type_duplex`. Doing so will result in 0 being returned. +*/ +MA_API ma_uint32 ma_device_get_channels(const ma_device* pDevice, ma_device_type deviceType); + +/* +Retrieve the sample rate of the device. + + +Parameters +---------- +pDevice (in) + A pointer to the device whose sample rate is being retrieved. + + +Return Value +------------ +The public facing sample rate of the device. + + +Remarks +------- +Unlike the sample format, channel count and channel map, the sample rate is shared between the capture and playback sides of the device +which means a device type is not necessary. +*/ +MA_API ma_uint32 ma_device_get_sample_rate(const ma_device* pDevice); + /* Retrieves the channel map of the device. @@ -9398,11 +9476,133 @@ channelMapCap (in) The capacity of `pChannelMap`. +Remarks +------- +Since the capture and playback sides can have different channel maps you need to use the `deviceType` parameter to discrimate between +the two. Use `ma_device_type_playback` for the playback side, or `ma_device_type_capture` for the capture side. You cannot use +`ma_device_type_duplex`. Doing so will result in a blank channel map being returned. +*/ +MA_API void ma_device_get_channel_map(const ma_device* pDevice, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap); + + +/* +Retrieve the internal format of the device. + + +Parameters +---------- +pDevice (in) + A pointer to the device whose internal format is being retrieved. + +deviceType (in) + Either `ma_device_type_playback` or `ma_device_type_capture` specifying which side of the device whose internal format is being retrieved. + + Return Value ------------ -MA_SUCCESS if successful; any other error otherwise. +The internal format of the device. + +Will return `ma_format_unknown` if an invalid device or device type is specified. + + +Remarks +------- +This would usually only be called by backends. A normal program should almost never need to call this. + +Since the capture and playback sides can have different sample formats you need to use the `deviceType` parameter to discrimate between +the two. Use `ma_device_type_playback` for the playback side, or `ma_device_type_capture` for the capture side. You cannot use +`ma_device_type_duplex`. Doing so will result in `ma_format_unknown` being returned. */ -MA_API ma_result ma_device_get_channel_map(const ma_device* pDevice, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap); +MA_API ma_format ma_device_get_internal_format(const ma_device* pDevice, ma_device_type deviceType); + +/* +Retrieve the internal channel count of the device. + + +Parameters +---------- +pDevice (in) + A pointer to the device whose internal channel count is being retrieved. + +deviceType (in) + Either `ma_device_type_playback` or `ma_device_type_capture` specifying which side of the device whose internal channel count is being retrieved. + + +Return Value +------------ +The internal channel count of the device. + +Will return 0 if an invalid device or device type is specified. + + +Remarks +------- +This would usually only be called by backends. A normal program should almost never need to call this. + +Since the capture and playback sides can have different channel counts you need to use the `deviceType` parameter to discrimate between +the two. Use `ma_device_type_playback` for the playback side, or `ma_device_type_capture` for the capture side. You cannot use +`ma_device_type_duplex`. Doing so will result in 0 being returned. +*/ +MA_API ma_uint32 ma_device_get_internal_channels(const ma_device* pDevice, ma_device_type deviceType); + +/* +Retrieve the internal sample rate of the device. + + +Parameters +---------- +pDevice (in) + A pointer to the device whose sample rate is being retrieved. + +deviceType (in) + Either `ma_device_type_playback` or `ma_device_type_capture` specifying which side of the device whose internal sample rate is being retrieved. + + +Return Value +------------ +The internal sample rate of the device. + +Will return 0 if an invalid device or device type is specified. + + +Remarks +------- +This would usually only be called by backends. A normal program should almost never need to call this. + +Since the capture and playback sides can have different internal sample rates you need to use the `deviceType` parameter to discrimate +between the two. Use `ma_device_type_playback` for the playback side, or `ma_device_type_capture` for the capture side. You cannot use +`ma_device_type_duplex`. Doing so will result in 0 being returned. +*/ +MA_API ma_uint32 ma_device_get_internal_sample_rate(const ma_device* pDevice, ma_device_type deviceType); + +/* +Retrieves the internal channel map of the device. + + +Parameters +---------- +pDevice (in) + A pointer to the device whose internal channel map is being retrieved. + +deviceType (in) + Either `ma_device_type_playback` or `ma_device_type_capture` specifying which side of the device whose internal channel map is being retrieved. + +pChannelMap (out) + A pointer to the buffer that will receive the internal channel map. + +channelMapCap (in) + The capacity of `pChannelMap`. + + +Remarks +------- +This would usually only be called by backends. A normal program should almost never need to call this. + +Since the capture and playback sides can have different channel maps you need to use the `deviceType` parameter to discrimate between +the two. Use `ma_device_type_playback` for the playback side, or `ma_device_type_capture` for the capture side. You cannot use +`ma_device_type_duplex`. Doing so will result in a blank channel map being returned. +*/ +MA_API void ma_device_get_internal_channel_map(const ma_device* pDevice, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap); /* @@ -49487,20 +49687,127 @@ MA_API ma_result ma_device_step(ma_device* pDevice, ma_blocking_mode blockingMod return MA_SUCCESS; } -MA_API ma_result ma_device_get_channel_map(const ma_device* pDevice, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap) +MA_API ma_format ma_device_get_format(const ma_device* pDevice, ma_device_type deviceType) { - if (pDevice == NULL || pChannelMap == NULL) { - return MA_INVALID_ARGS; - } - - if (deviceType == ma_device_type_duplex) { - return MA_INVALID_ARGS; /* Don't know if the playback or capture side is being requested. */ + if (pDevice == NULL) { + return ma_format_unknown; } if (deviceType == ma_device_type_playback) { - return ma_data_converter_get_input_channel_map(&pDevice->playback.converter, pChannelMap, channelMapCap); + return pDevice->playback.converter.formatIn; } else { - return ma_data_converter_get_output_channel_map(&pDevice->capture.converter, pChannelMap, channelMapCap); + return pDevice->capture.converter.formatOut; + } +} + +MA_API ma_uint32 ma_device_get_channels(const ma_device* pDevice, ma_device_type deviceType) +{ + if (pDevice == NULL) { + return 0; + } + + if (deviceType == ma_device_type_playback) { + return pDevice->playback.converter.channelsIn; + } else { + return pDevice->capture.converter.channelsOut; + } +} + +MA_API ma_uint32 ma_device_get_sample_rate(const ma_device* pDevice) +{ + if (pDevice == NULL) { + return 0; + } + + if (pDevice->type == ma_device_type_playback) { + return pDevice->playback.converter.sampleRateIn; + } else { + return pDevice->capture.converter.sampleRateOut; + } +} + +MA_API void ma_device_get_channel_map(const ma_device* pDevice, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap) +{ + if (pChannelMap == NULL) { + return; + } + + MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap); + + if (pDevice == NULL) { + return; + } + + if (deviceType == ma_device_type_duplex) { + return; /* Don't know if the playback or capture side is being requested. */ + } + + if (deviceType == ma_device_type_playback) { + ma_data_converter_get_input_channel_map(&pDevice->playback.converter, pChannelMap, channelMapCap); + } else { + ma_data_converter_get_output_channel_map(&pDevice->capture.converter, pChannelMap, channelMapCap); + } +} + +MA_API ma_format ma_device_get_internal_format(const ma_device* pDevice, ma_device_type deviceType) +{ + if (pDevice == NULL) { + return ma_format_unknown; + } + + if (deviceType == ma_device_type_playback) { + return pDevice->playback.converter.formatOut; + } else { + return pDevice->capture.converter.formatIn; + } +} + +MA_API ma_uint32 ma_device_get_internal_channels(const ma_device* pDevice, ma_device_type deviceType) +{ + if (pDevice == NULL) { + return 0; + } + + if (deviceType == ma_device_type_playback) { + return pDevice->playback.converter.channelsOut; + } else { + return pDevice->capture.converter.channelsIn; + } +} + +MA_API ma_uint32 ma_device_get_internal_sample_rate(const ma_device* pDevice, ma_device_type deviceType) +{ + if (pDevice == NULL) { + return 0; + } + + if (deviceType == ma_device_type_playback) { + return pDevice->playback.converter.sampleRateOut; + } else { + return pDevice->capture.converter.sampleRateIn; + } +} + +MA_API void ma_device_get_internal_channel_map(const ma_device* pDevice, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap) +{ + if (pChannelMap == NULL) { + return; + } + + MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap); + + if (pDevice == NULL) { + return; + } + + if (deviceType == ma_device_type_duplex) { + return; /* Don't know if the playback or capture side is being requested. */ + } + + if (deviceType == ma_device_type_playback) { + ma_data_converter_get_output_channel_map(&pDevice->playback.converter, pChannelMap, channelMapCap); + } else { + ma_data_converter_get_input_channel_map(&pDevice->capture.converter, pChannelMap, channelMapCap); } }