pcm_capabilities.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <array>
#include <cstdint>
#include <iterator>
#include <optional>
#include <vector>
 
namespace pulp::audio {

struct PcmCapabilities {
    unsigned rate_min = 0;
    unsigned rate_max = 0;
    std::vector<unsigned> accepted_rates;
    bool rates_tested = false;
 
    unsigned channels_min = 0;
    unsigned channels_max = 0;

    unsigned long period_min = 0;
    unsigned long period_max = 0;
    unsigned long buffer_max = 0;
};

inline const std::array<unsigned, 13>& standard_sample_rates() {
    static const std::array<unsigned, 13> rates{8000,  11025, 16000,  22050,  32000,  44100, 48000,
                                                88200, 96000, 176400, 192000, 352800, 384000};
    return rates;
}

inline std::vector<double> sample_rates_from(const PcmCapabilities& caps) {
    std::vector<double> out;
    if (caps.rate_min == 0 || caps.rate_max < caps.rate_min)
        return out;
    auto in_range = [&](unsigned r) { return r >= caps.rate_min && r <= caps.rate_max; };
 
    std::vector<unsigned> picked;
    if (caps.rates_tested) {
        for (unsigned r : caps.accepted_rates) {
            if (in_range(r))
                picked.push_back(r);
        }
    } else {
        for (unsigned r : standard_sample_rates()) {
            if (in_range(r))
                picked.push_back(r);
        }
    }
    if (picked.empty() && caps.rate_min == caps.rate_max)
        picked.push_back(caps.rate_min);
 
    std::sort(picked.begin(), picked.end());
    picked.erase(std::unique(picked.begin(), picked.end()), picked.end());
    out.reserve(picked.size());
    for (unsigned r : picked)
        out.push_back(static_cast<double>(r));
    return out;
}

inline std::vector<int> buffer_sizes_from(const PcmCapabilities& caps,
                                          unsigned periods_per_buffer = 2) {
    std::vector<int> out;
    if (caps.period_min == 0 || caps.period_max < caps.period_min)
        return out;
    if (periods_per_buffer == 0)
        periods_per_buffer = 1;
    auto fits = [&](unsigned long p) {
        if (p < caps.period_min || p > caps.period_max)
            return false;
        if (p > 0x7FFFFFFFul)
            return false;
        return caps.buffer_max == 0 || p * periods_per_buffer <= caps.buffer_max;
    };
    for (unsigned long p = 16; p <= 16384; p *= 2) {
        if (fits(p))
            out.push_back(static_cast<int>(p));
    }
    if (out.empty() && fits(caps.period_min))
        out.push_back(static_cast<int>(caps.period_min));
    return out;
}
 
namespace detail {
template <typename T>
std::vector<T> intersect_sorted(const std::vector<T>& a, const std::vector<T>& b) {
    std::vector<T> out;
    std::set_intersection(a.begin(), a.end(), b.begin(), b.end(), std::back_inserter(out));
    return out;
}
} // namespace detail

struct PcmDeviceSummary {
    std::vector<double> sample_rates;
    std::vector<int> buffer_sizes;
    int max_input_channels = 0;
    int max_output_channels = 0;
};

inline PcmDeviceSummary summarize_pcm_capabilities(const std::optional<PcmCapabilities>& playback,
                                                   const std::optional<PcmCapabilities>& capture) {
    auto usable = [](const std::optional<PcmCapabilities>& c) {
        return c && c->channels_max > 0 && c->channels_min <= c->channels_max;
    };
    const bool has_play = usable(playback);
    const bool has_cap = usable(capture);
 
    PcmDeviceSummary out;
    if (!has_play && !has_cap) {
        out.max_output_channels = 2;
        out.max_input_channels = 2;
        out.sample_rates = {44100, 48000, 88200, 96000};
        out.buffer_sizes = {64, 128, 256, 512, 1024, 2048, 4096};
        return out;
    }
 
    out.max_output_channels = has_play ? static_cast<int>(playback->channels_max) : 0;
    out.max_input_channels = has_cap ? static_cast<int>(capture->channels_max) : 0;
 
    if (has_play && has_cap) {
        out.sample_rates =
            detail::intersect_sorted(sample_rates_from(*playback), sample_rates_from(*capture));
        out.buffer_sizes =
            detail::intersect_sorted(buffer_sizes_from(*playback), buffer_sizes_from(*capture));
    } else {
        const auto& only = has_play ? *playback : *capture;
        out.sample_rates = sample_rates_from(only);
        out.buffer_sizes = buffer_sizes_from(only);
    }
    return out;
}
 
} // namespace pulp::audio