system/ulib/audio-proto-utils/format-utils.cpp

// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <audio-proto-utils/format-utils.h>
#include <fbl/algorithm.h>
#include <string.h>

namespace audio {
namespace utils {

// Note: these sets must be kept in monotonically increasing order.
static const uint32_t RATES_48000_FAMILY[] = { 8000,16000,32000,48000,96000,192000,384000,768000 };
static const uint32_t RATES_44100_FAMILY[] = { 11025,22050,44100,88200,176400 };
static const uint32_t* RATES_48000_FAMILY_LAST = RATES_48000_FAMILY + fbl::count_of(RATES_48000_FAMILY);
static const uint32_t* RATES_44100_FAMILY_LAST = RATES_44100_FAMILY + fbl::count_of(RATES_44100_FAMILY);
static constexpr auto DISCRETE_FLAGS = ASF_RANGE_FLAG_FPS_48000_FAMILY
                                     | ASF_RANGE_FLAG_FPS_44100_FAMILY;

bool FrameRateIn48kFamily(uint32_t rate) {
    const uint32_t* found = fbl::lower_bound(RATES_48000_FAMILY, RATES_48000_FAMILY_LAST, rate);
    return ((found < RATES_48000_FAMILY_LAST) && (*found == rate));
}

bool FrameRateIn441kFamily(uint32_t rate) {
    const uint32_t* found = fbl::lower_bound(RATES_44100_FAMILY, RATES_44100_FAMILY_LAST, rate);
    return ((found < RATES_44100_FAMILY_LAST) && (*found == rate));
}

// Figure out the size of an audio frame based on the sample format.  Returns 0
// in the case of an error (bad channel count, bad sample format)
uint32_t ComputeFrameSize(uint16_t channels, audio_sample_format_t sample_format) {
    uint32_t fmt_noflags = sample_format & ~AUDIO_SAMPLE_FORMAT_FLAG_MASK;

    switch (fmt_noflags) {
    case AUDIO_SAMPLE_FORMAT_8BIT:         return 1u * channels;
    case AUDIO_SAMPLE_FORMAT_16BIT:        return 2u * channels;
    case AUDIO_SAMPLE_FORMAT_24BIT_PACKED: return 3u * channels;
    case AUDIO_SAMPLE_FORMAT_20BIT_IN32:
    case AUDIO_SAMPLE_FORMAT_24BIT_IN32:
    case AUDIO_SAMPLE_FORMAT_32BIT:
    case AUDIO_SAMPLE_FORMAT_32BIT_FLOAT:  return 4u * channels;

    // See MG-1003
    // We currently don't really know how 20 bit audio should be packed.  For
    // now, treat it as an error.
    case AUDIO_SAMPLE_FORMAT_20BIT_PACKED:
    default:
        return 0;
    }
}

bool FormatIsCompatible(uint32_t frame_rate,
                        uint16_t channels,
                        audio_sample_format_t sample_format,
                        const audio_stream_format_range_t& format_range) {
    // Are the requested number of channels in range?
    if ((channels < format_range.min_channels) || (channels > format_range.max_channels))
        return false;

    // Is the requested sample format compatible with the range's supported
    // formats?  If so...
    //
    // 1) The flags for each (requested and supported) must match exactly.
    // 2) The requested format must be unique, and a PCM format (we don't know
    //    how to test compatibility for compressed bitstream formats right now)
    // 3) The requested format must intersect the set of supported formats.
    //
    // Start by testing requirement #1.
    uint32_t requested_flags = sample_format & AUDIO_SAMPLE_FORMAT_FLAG_MASK;
    uint32_t supported_flags = format_range.sample_formats & AUDIO_SAMPLE_FORMAT_FLAG_MASK;
    if (requested_flags != supported_flags)
        return false;

    // Requirement #2.  If this format is unique and PCM, then there is exactly
    // 1 bit set in it and that bit is not AUDIO_SAMPLE_FORMAT_BITSTREAM.  We
    // can use fbl::is_pow2 to check if there is exactly 1 bit set.  (note,
    // fbl::is_pow2 does not consider 0 to be a power of 2, so it's perfect for
    // this)
    uint32_t requested_noflags = sample_format & ~AUDIO_SAMPLE_FORMAT_FLAG_MASK;
    if ((requested_noflags == AUDIO_SAMPLE_FORMAT_BITSTREAM) ||
        (!fbl::is_pow2(requested_noflags)))
        return false;

    // Requirement #3.  Testing intersection is easy, just and the two.  No need
    // to strip the flags from the supported format bitmask, we have already
    // stripped them from the request when checking requirement #2.
    if (!(format_range.sample_formats & requested_noflags))
        return false;

    // Check the requested frame rate.  If it is not in the range expressed by
    // the format_range, then we know this is not a match.
    if ((frame_rate < format_range.min_frames_per_second) ||
        (frame_rate > format_range.max_frames_per_second))
        return false;

    // The frame rate is in range, if this format_range supports continuous
    // frame rates, then this is a match.
    if (format_range.flags & ASF_RANGE_FLAG_FPS_CONTINUOUS)
        return true;

    // Check the 48k family.
    if ((format_range.flags & ASF_RANGE_FLAG_FPS_48000_FAMILY) && FrameRateIn48kFamily(frame_rate))
        return true;

    // Check the 44.1k family.
    if ((format_range.flags & ASF_RANGE_FLAG_FPS_44100_FAMILY) && FrameRateIn441kFamily(frame_rate))
        return true;

    // No supported frame rates found.  Declare no-match.
    return false;
}

FrameRateEnumerator::iterator::iterator(const FrameRateEnumerator* enumerator)
    : enumerator_(enumerator) {
    // If we have no enumerator, then we cannot advance to the first valid frame
    // rate.  Just get out.
    if (!enumerator_)
        return;

    // Sanity check our range first.  If it is continuous, or invalid in any
    // way, then we are not going to enumerate any valid frame rates.  Just set
    // our enumerator to nullptr and get out.
    const auto& range = enumerator_->range();
    if ((range.flags & ASF_RANGE_FLAG_FPS_CONTINUOUS) ||
       !(range.flags & DISCRETE_FLAGS) ||
        (range.min_frames_per_second > range.max_frames_per_second)) {
        enumerator_ = nullptr;
        return;
    }

    // Reset our current iterator state, then advance to the first valid
    // frame rate (if any)
    cur_flag_ = ASF_RANGE_FLAG_FPS_48000_FAMILY;
    fmt_ndx_  = static_cast<uint16_t>(-1);
    Advance();
}

void FrameRateEnumerator::iterator::Advance() {
    if (enumerator_ == nullptr) {
        ZX_DEBUG_ASSERT(!cur_rate_ && !cur_flag_ && !fmt_ndx_);
        return;
    }

    const auto& range = enumerator_->range();

    while (cur_flag_ & DISCRETE_FLAGS) {
        const uint32_t* rates;
        uint16_t rates_count;

        if (cur_flag_ == ASF_RANGE_FLAG_FPS_48000_FAMILY) {
            rates = RATES_48000_FAMILY;
            rates_count = sizeof(RATES_48000_FAMILY);
        } else {
            ZX_DEBUG_ASSERT(cur_flag_ == ASF_RANGE_FLAG_FPS_44100_FAMILY);
            rates = RATES_44100_FAMILY;
            rates_count = sizeof(RATES_44100_FAMILY);
        }

        if (range.flags & cur_flag_) {
            for (++fmt_ndx_; fmt_ndx_ < rates_count; ++fmt_ndx_) {
                uint32_t rate = rates[fmt_ndx_];

                // If the rate in the table is less than the minimum
                // frames_per_second, keep advancing the index.
                if (rate < range.min_frames_per_second)
                    continue;

                // If the rate in the table is greater than the maximum
                // frames_per_second, then we are done with this table.  There are
                // no more matches to be found in it.
                if (rate > range.max_frames_per_second)
                    break;

                // The rate in this table is between the min and the max rates
                // supported by this range.  Record it and get out.
                cur_rate_ = rate;
                return;
            }
        }

        // We are done with this table.  If we were searching the 48KHz family,
        // move on to the 44.1KHz family.  Otherwise, we are finished.
        if (cur_flag_ == ASF_RANGE_FLAG_FPS_48000_FAMILY) {
            cur_flag_ = ASF_RANGE_FLAG_FPS_44100_FAMILY;
            fmt_ndx_  = static_cast<uint16_t>(-1);
        } else {
            break;
        }
    }

    memset(this, 0, sizeof(*this));
}

}  // namespace utils
}  // namespace audio