[FEAT] Provide API to Get Device-Supported Sample Rates

[Mioter]

Requirements

• I have searched the existing issues to ensure this feature has not already been requested.
• I have clearly described the problem and the proposed solution.
• I have considered alternative solutions.

1. Is your feature request related to a problem? Please describe.

I'm unable to dynamically adjust the output sample rate based on the capabilities of the target audio device, which can lead to compatibility issues and suboptimal audio quality. Currently, there's no way to retrieve the sample rates that a device natively supports through the SoundFlow API.

2. Describe the Solution You'd Like

I would like the library to provide:

1. A method to get all supported sample rates for a specified audio device
2. A property in the DeviceInfo class that exposes the list of supported sample rates

This would allow developers to query the device's capabilities and select the most appropriate sample rate for audio output, ensuring better compatibility and performance.

3. Describe Alternatives You've Considered

I've considered using a set of common sample rates (44.1kHz, 48kHz, etc.) and testing each one to see if it works, but this is inefficient and can result in errors or unexpected behavior. Another approach is to hardcode a sample rate, which limits compatibility across different devices.

4. Proposed API (if applicable)

// In DeviceInfo class
public IReadOnlyList<int> SupportedSampleRates { get; }

// Or as a method in the audio device manager
public IEnumerable<int> GetSupportedSampleRates(string deviceId);

5. Benefits

• Enables dynamic adaptation to different audio hardware capabilities
• Reduces compatibility issues caused by using unsupported sample rates
• Improves audio quality by allowing selection of optimal sample rates

6. Potential Drawbacks/Challenges

No response

7. Additional Context

No response

[LSXPrime]

We already have such an API, not documented though

        DeviceInfo? deviceInfo = SelectDevice(DeviceType.Playback);
        if (!deviceInfo.HasValue) return;

        var capabilities = deviceInfo.Value.NativeDataFormats.ReadArray<NativeDataFormat>((int)deviceInfo.Value.NativeDataFormatCount);
        if (capabilities.Length != 0)
        {
            Console.WriteLine("Supported native data formats:");
            for (var i = 0; i < capabilities.Length; i++)
            {
                // Print Format, Channels, SampleRate
                Console.WriteLine($"Capability {i}: Format: {capabilities[i].Format}, Channels: {capabilities[i].Channels}, SampleRate: {capabilities[i].SampleRate}");
            }
        }
        

but for some reason devices on my machine that's acquired from AudioEngine.UpdateDevicesInfo() all have a 0 NativeDataFormatCount and 0 NativeDataFormats pointer, it seems to be a bug in marshalling or miniaudio can't access this part of my devices details, can you confirm this on your side?

[Mioter]

>_< I'm experiencing the same issue. Devices acquired from AudioEngine.UpdateDevicesInfo() also have NativeDataFormatCount = 0 and NativeDataFormats pointer = 0 on my machine. This appears to be either a marshalling bug or a limitation in miniaudio's ability to access device format details.

[LSXPrime]

No marshalling issues. I attempted to tackle this w/o packing the 4/8 bytes, but it still resulted in zero. I'll debug further by testing the native library in a C++ console application to confirm if this is a miniaudio limitation or something on our end. If it's the former, I'll raise an issue on the miniaudio repository.

[LSXPrime]

On testing the native side with both of our wrapper class and raw miniaudio implantation, the result is still the same

// Result for both implementations

Successfully initialized audio context.
Using backend: WASAPI

--- Playback Devices (6) ---
[0] Digital Output (High Definition Audio Device)
  No native data formats reported.
------------------------------------------------
[1] Cable Input - Arctan Speakers 16 Ch (VB-Audio Virtual Cable)
  No native data formats reported.
------------------------------------------------
[2] Cable Input - Arctan Speakers (VB-Audio Virtual Cable)
  No native data formats reported.
------------------------------------------------
[3] Speakers (USB Audio Device)
  No native data formats reported.
------------------------------------------------
[4] VG242Y P (NVIDIA High Definition Audio)
  No native data formats reported.
------------------------------------------------
[5] Speakers (FxSound Audio Enhancer) (DEFAULT)
  No native data formats reported.
------------------------------------------------

--- Capture/Recording Devices (2) ---
[0] Cable Output - Arctan Microphone (VB-Audio Virtual Cable)
  No native data formats reported.
------------------------------------------------
[1] Microphone (USB Audio Device) (DEFAULT)
  No native data formats reported.
------------------------------------------------

Cleanup complete. Exiting.

Process finished with exit code 0

Code for reference

// miniaudio raw implementation

#define MINIAUDIO_IMPLEMENTATION
#include "../submodules/miniaudio/miniaudio.h"

#include <iostream>

// Helper function to convert a ma_format enum to a human-readable string.
const char* get_format_name(const ma_format format) {
    switch (format) {
        case ma_format_unknown:   return "Unknown";
        case ma_format_u8:        return "Unsigned 8-bit";
        case ma_format_s16:       return "Signed 16-bit";
        case ma_format_s24:       return "Signed 24-bit";
        case ma_format_s32:       return "Signed 32-bit";
        case ma_format_f32:       return "32-bit Float";
        default:                  return "Other/Invalid";
    }
}

// Helper function to print the details of an array of devices.
void print_device_infos(const char* title, const ma_device_info* pDeviceInfos, ma_uint32 count) {
    std::cout << "--- " << title << " (" << count << ") ---" << std::endl;
    if (count == 0) {
        std::cout << "No devices found." << std::endl << std::endl;
        return;
    }

    for (ma_uint32 i = 0; i < count; ++i) {
        const ma_device_info& info = pDeviceInfos[i];

        // Print device name and default status
        std::cout << "[" << i << "] " << info.name;
        if (info.isDefault) {
            std::cout << " (DEFAULT)";
        }
        std::cout << std::endl;

        // Print native data formats
        if (info.nativeDataFormatCount > 0) {
            std::cout << "  Supported Native Formats (" << info.nativeDataFormatCount << "):" << std::endl;
            for (ma_uint32 j = 0; j < info.nativeDataFormatCount; ++j) {
                const auto& format = info.nativeDataFormats[j];
                std::cout << "    - Format: " << get_format_name(format.format)
                          << ",\tChannels: " << format.channels
                          << ",\tSample Rate: " << format.sampleRate << " Hz"
                          << std::endl;
            }
        } else {
            std::cout << "  No native data formats reported." << std::endl;
        }
        std::cout << "------------------------------------------------" << std::endl;
    }
    std::cout << std::endl;
}

int main() {
    // Initialize the context.
    ma_context context;
    ma_result result = ma_context_init(nullptr, 0, nullptr, &context);
    if (result != MA_SUCCESS) {
        std::cerr << "Error: Failed to initialize context: " << ma_result_description(result) << std::endl;
        return -1;
    }

    std::cout << "Successfully initialized audio context." << std::endl;
    std::cout << "Using backend: " << ma_get_backend_name(context.backend) << std::endl << std::endl;

    // Declare variables to hold device information.
    ma_device_info* pPlaybackDeviceInfos = nullptr;
    ma_device_info* pCaptureDeviceInfos = nullptr;
    ma_uint32 playbackDeviceCount = 0;
    ma_uint32 captureDeviceCount = 0;

    // Retrieve device information.
    result = ma_context_get_devices(&context, &pPlaybackDeviceInfos, &playbackDeviceCount, &pCaptureDeviceInfos, &captureDeviceCount);

    if (result != MA_SUCCESS) {
        std::cerr << "Error: Failed to retrieve device information: " << ma_result_description(result) << std::endl;
        ma_context_uninit(&context);
        return -1;
    }

    // Print the retrieved information.
    print_device_infos("Playback Devices", pPlaybackDeviceInfos, playbackDeviceCount);
    print_device_infos("Capture/Recording Devices", pCaptureDeviceInfos, captureDeviceCount);

    // Uninitialize the context.
    ma_context_uninit(&context);

    std::cout << "Cleanup complete. Exiting." << std::endl;

    return 0;
}

// SoundFlow wrapper implementation

#include <iostream>
#include "../library.h"

// Helper function to convert a ma_format enum to a human-readable string.
const char* get_format_name(const ma_format format) {
    switch (format) {
        case ma_format_unknown:   return "Unknown";
        case ma_format_u8:        return "Unsigned 8-bit";
        case ma_format_s16:       return "Signed 16-bit";
        case ma_format_s24:       return "Signed 24-bit";
        case ma_format_s32:       return "Signed 32-bit";
        case ma_format_f32:       return "32-bit Float";
        default:                  return "Other/Invalid";
    }
}

// Helper function to print the details of an array of devices.
void print_device_infos(const char* title, const sf_device_info* pDeviceInfos, ma_uint32 count) {
    std::cout << "--- " << title << " (" << count << ") ---" << std::endl;
    if (count == 0) {
        std::cout << "No devices found." << std::endl << std::endl;
        return;
    }

    for (ma_uint32 i = 0; i < count; ++i) {
        const sf_device_info& info = pDeviceInfos[i];

        // Print device name and default status
        std::cout << "[" << i << "] " << info.name;
        if (info.isDefault) {
            std::cout << " (DEFAULT)";
        }
        std::cout << std::endl;

        // Print native data formats
        if (info.nativeDataFormatCount > 0) {
            std::cout << "  Supported Native Formats (" << info.nativeDataFormatCount << "):" << std::endl;
            for (ma_uint32 j = 0; j < info.nativeDataFormatCount; ++j) {
                const native_data_format& format = info.nativeDataFormats[j];
                std::cout << "    - Format: " << get_format_name(format.format)
                          << ",\tChannels: " << format.channels
                          << ",\tSample Rate: " << format.sampleRate << " Hz"
                          << std::endl;
            }
        } else {
            std::cout << "  No native data formats reported." << std::endl;
        }
        std::cout << "------------------------------------------------" << std::endl;
    }
    std::cout << std::endl;
}

int main() {
    // Allocate context
    ma_context* context = sf_allocate_context();
    if (context == nullptr) {
        std::cerr << "Error: Failed to allocate context." << std::endl;
        return -1;
    }

    // Initialize the context.
    ma_result result = ma_context_init(nullptr, 0, nullptr, context);
    if (result != MA_SUCCESS) {
        std::cerr << "Error: Failed to initialize context: " << ma_result_description(result) << std::endl;
        sf_free(context);
        return -1;
    }

    std::cout << "Successfully initialized audio context." << std::endl;
    std::cout << "Using backend: " << ma_get_backend_name(context->backend) << std::endl << std::endl;

    // Declare variables to hold device information.
    sf_device_info* pPlaybackDeviceInfos = nullptr;
    sf_device_info* pCaptureDeviceInfos = nullptr;
    ma_uint32 playbackDeviceCount = 0;
    ma_uint32 captureDeviceCount = 0;

    // Retrieve device information using the library function.
    result = sf_get_devices(context, &pPlaybackDeviceInfos, &pCaptureDeviceInfos, &playbackDeviceCount, &captureDeviceCount);

    if (result != MA_SUCCESS) {
        std::cerr << "Error: Failed to retrieve device information: " << ma_result_description(result) << std::endl;
        ma_context_uninit(context);
        sf_free(context);
        return -1;
    }

    // Print the retrieved information.
    print_device_infos("Playback Devices", pPlaybackDeviceInfos, playbackDeviceCount);
    print_device_infos("Capture/Recording Devices", pCaptureDeviceInfos, captureDeviceCount);

    // Clean up resources.
    sf_free_device_infos(pPlaybackDeviceInfos, playbackDeviceCount);
    sf_free_device_infos(pCaptureDeviceInfos, captureDeviceCount);

    // Uninitialize and free the context.
    ma_context_uninit(context);
    sf_free(context);

    std::cout << "Cleanup complete. Exiting." << std::endl;

    return 0;
}

I will post an issue for this in miniaudio repository, once it get fixed, I will consider moving from the current stable miniaudio branch to the dev branch to release the patched version

[Mioter]

Thank you very much for your efforts! Your detailed testing and clear feedback are extremely helpful. I look forward to this issue being fixed and merged into miniaudio's development branch as soon as possible.
（＾-＾）