bt_a2dp/

media_types.rs

// Copyright 2019 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.

use bitfield::bitfield;
use bitflags::bitflags;
use bt_avdtp as avdtp;

bitflags! {
    /// Sampling Frequency field for SBC (Octet 0; b4-7).
    /// 44100Hz and 48000Hz are mandatory for A2DP sink.
    /// A2DP source must support at least one of 44100Hz and 48000Hz.
    /// A2DP Sec. 4.3.2.1
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SbcSamplingFrequency:u8 {
        const FREQ16000HZ   = 0b1000;
        const FREQ32000HZ   = 0b0100;
        const FREQ44100HZ   = 0b0010;
        const FREQ48000HZ   = 0b0001;
        const MANDATORY_SNK = Self::FREQ44100HZ.bits() | Self::FREQ48000HZ.bits();
    }
}

impl SbcSamplingFrequency {
    /// Select the "best" sampling frequency of the ones available.
    fn best(&self) -> Option<Self> {
        let ordered = [Self::FREQ48000HZ, Self::FREQ44100HZ, Self::FREQ32000HZ, Self::FREQ16000HZ];
        ordered.iter().find(|freq| self.contains(**freq)).copied()
    }
}

bitflags! {
    /// Channel Mode field for SBC (Octet 0; b0-3).
    /// Support for all modes is mandatory in A2DP sink.
    /// Mono and at least one of Dual Channel, Stereo, and Joint Stereo must be
    /// supported by A2DP source.
    /// A2DP Sec. 4.3.2.2
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SbcChannelMode:u8 {
        const MONO          = 0b1000;
        const DUAL_CHANNEL  = 0b0100;
        const STEREO        = 0b0010;
        const JOINT_STEREO  = 0b0001;
        const MANDATORY_SNK = Self::MONO.bits()
            | Self::DUAL_CHANNEL.bits()
            | Self::STEREO.bits()
            | Self::JOINT_STEREO.bits();
    }
}

impl SbcChannelMode {
    fn best(&self) -> Option<Self> {
        let ordered = [Self::JOINT_STEREO, Self::STEREO, Self::DUAL_CHANNEL, Self::MONO];
        ordered.iter().find(|mode| self.contains(**mode)).copied()
    }
}

bitflags! {
    /// The Block Length field for SBC (Octet 1; b4-7).
    /// Support for all block lengths is mandatory in both A2DP Sink and Source.
    /// A2DP Sec. 4.3.2.3
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SbcBlockCount:u8 {
        const FOUR          = 0b1000;
        const EIGHT         = 0b0100;
        const TWELVE        = 0b0010;
        const SIXTEEN       = 0b0001;
        const MANDATORY_SNK = Self::FOUR.bits()
            | Self::EIGHT.bits()
            | Self::TWELVE.bits()
            | Self::SIXTEEN.bits();
        const MANDATORY_SRC = Self::FOUR.bits()
            | Self::EIGHT.bits()
            | Self::TWELVE.bits()
            | Self::SIXTEEN.bits();
    }
}

bitflags! {
    /// The Number of Subbands field for SBC (Octet 1; b2-3).
    /// Support for both 4 and 8 subbands is mandatory in A2DP Sink.
    /// Support for only 8 subbands is mandatory in A2DP Source.
    /// 4 subbands is optional.
    /// A2DP Sec. 4.3.2.4
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SbcSubBands:u8 {
        const FOUR            = 0b0010;
        const EIGHT            = 0b0001;
        const MANDATORY_SNK = Self::FOUR.bits() | Self::EIGHT.bits();
        const MANDATORY_SRC = Self::EIGHT.bits();
    }
}

bitflags! {
    /// Allocation Method field for SBC (Octet 1; b0-1).
    /// Support for both SNR and Loudness is mandatory in A2DP Sink.
    /// Support for at least Loudness is mandatory in A2DP Source. SNR is optional.
    /// A2DP Sec. 4.3.2.5
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SbcAllocation:u8 {
        const SNR           = 0b0010;
        const LOUDNESS      = 0b0001;
        const MANDATORY_SNK = Self::SNR.bits() | Self::LOUDNESS.bits();
        const MANDATORY_SRC = Self::LOUDNESS.bits();
    }
}

pub const SBC_CODEC_EXTRA_LEN: usize = 4;

bitfield! {
    /// SBC Codec Specific Information Elements (A2DP Sec. 4.3.2).
    /// Packet structure:
    ///     Octet0: Sampling Frequency (b4-7), Channel Mode (b0-3)
    ///     Octet1: Block Length (b4-7), Subbands (b2-3), Allocation Method (b0-1)
    ///     Octet2: Minimum Bitpool Value [2,250]
    ///     Octet3: Maximum Bitpool Value [2,250]
    /// Some fields are mandatory choose 1, and therefore do not have a mandatory parameter method.
    struct SbcCodecInfoBits(u32);
    impl Debug;
    u8;
    maxbitpoolval, set_maxbpv: 7, 0;
    minbitpoolval, set_minbpv: 15, 8;
    allocation_method, set_allocation_method: 17,16;
    sub_bands, set_sub_bands: 19, 18;
    block_count, set_block_count: 23, 20;
    channel_mode, set_channel_mode: 27, 24;
    sampling_frequency, set_sampling_frequency: 31, 28;
}

#[derive(Debug)]
pub struct SbcCodecInfo(SbcCodecInfoBits);

impl SbcCodecInfo {
    // Bitpool values can range from [2,250].
    pub const BITPOOL_MIN: u8 = 2;
    pub const BITPOOL_MAX: u8 = 250;
    pub fn new(
        sampling_frequency: SbcSamplingFrequency,
        channel_mode: SbcChannelMode,
        block_count: SbcBlockCount,
        sub_bands: SbcSubBands,
        allocation: SbcAllocation,
        min_bpv: u8,
        max_bpv: u8,
    ) -> avdtp::Result<Self> {
        if min_bpv > max_bpv {
            return Err(avdtp::Error::OutOfRange);
        }
        if min_bpv < Self::BITPOOL_MIN
            || min_bpv > Self::BITPOOL_MAX
            || max_bpv < Self::BITPOOL_MIN
            || max_bpv > Self::BITPOOL_MAX
        {
            return Err(avdtp::Error::OutOfRange);
        }

        let mut res = SbcCodecInfoBits(0);
        res.set_maxbpv(max_bpv);
        res.set_minbpv(min_bpv);
        res.set_allocation_method(allocation.bits());
        res.set_sub_bands(sub_bands.bits());
        res.set_block_count(block_count.bits());
        res.set_channel_mode(channel_mode.bits());
        res.set_sampling_frequency(sampling_frequency.bits());
        Ok(Self(res))
    }

    pub fn to_bytes(&self) -> [u8; 4] {
        (self.0).0.to_be_bytes()
    }

    pub fn sub_bands(&self) -> SbcSubBands {
        SbcSubBands::from_bits_truncate(self.0.sub_bands())
    }

    pub fn allocation_method(&self) -> SbcAllocation {
        SbcAllocation::from_bits_truncate(self.0.allocation_method())
    }

    pub fn block_count(&self) -> SbcBlockCount {
        SbcBlockCount::from_bits_truncate(self.0.block_count())
    }

    pub fn channel_mode(&self) -> SbcChannelMode {
        SbcChannelMode::from_bits_truncate(self.0.channel_mode())
    }

    /// Returns the number of channels selected.
    /// Returns Error::OutOfRange if both mono and stereo are selected.
    pub fn channel_count(&self) -> avdtp::Result<usize> {
        let chan_mode = self.channel_mode();
        if chan_mode == SbcChannelMode::MONO {
            return Ok(1);
        } else if !chan_mode.is_empty() && (chan_mode & SbcChannelMode::MONO).is_empty() {
            return Ok(2);
        }
        Err(avdtp::Error::OutOfRange)
    }

    pub fn max_bitpool(&self) -> u8 {
        self.0.maxbitpoolval()
    }

    /// Returns the sampling frequency selected, in hz.
    /// Returns Error::OutOfRange if multiple frequencies are selected.
    pub fn sampling_frequency(&self) -> avdtp::Result<u32> {
        let hz = match SbcSamplingFrequency::from_bits_truncate(self.0.sampling_frequency()) {
            SbcSamplingFrequency::FREQ16000HZ => 16000,
            SbcSamplingFrequency::FREQ32000HZ => 32000,
            SbcSamplingFrequency::FREQ44100HZ => 44100,
            SbcSamplingFrequency::FREQ48000HZ => 48000,
            _ => return Err(avdtp::Error::OutOfRange),
        };
        Ok(hz)
    }

    /// Returns true if `other` is a compatible configuration of `self`
    pub fn supports(&self, other: &Self) -> bool {
        let allowed_frequencies =
            SbcSamplingFrequency::from_bits_truncate(self.0.sampling_frequency());
        let selected_frequencies =
            SbcSamplingFrequency::from_bits_truncate(other.0.sampling_frequency());
        if !(allowed_frequencies.intersects(selected_frequencies)) {
            return false;
        }
        if !(self.allocation_method().intersects(other.allocation_method())) {
            return false;
        }
        if !(self.channel_mode().intersects(other.channel_mode())) {
            return false;
        }
        if !(self.block_count().intersects(other.block_count())) {
            return false;
        }
        if !(self.sub_bands().intersects(other.sub_bands())) {
            return false;
        }
        if self.0.minbitpoolval() > other.0.minbitpoolval() {
            return false;
        }
        if self.0.maxbitpoolval() < other.0.maxbitpoolval() {
            return false;
        }
        return true;
    }

    /// Return the best intersection of a and b's capabilities, if one exists.
    pub fn negotiate(a: &Self, b: &Self) -> Option<Self> {
        let min_bitpool = std::cmp::max(a.0.minbitpoolval(), b.0.minbitpoolval());
        let max_bitpool = std::cmp::min(a.0.maxbitpoolval(), b.0.maxbitpoolval());
        if max_bitpool < min_bitpool {
            return None;
        }
        let available_frequencies = SbcSamplingFrequency::from_bits_truncate(
            a.0.sampling_frequency() & b.0.sampling_frequency(),
        );
        let frequency = match available_frequencies.best() {
            None => return None,
            Some(freq) => freq,
        };
        let available_mode = a.channel_mode() & b.channel_mode();
        let channel_mode = match available_mode.best() {
            None => return None,
            Some(mode) => mode,
        };
        // All sources and sinks must support these options. A2DP 1.3.2 Sec 4.3.2
        let allocation = SbcAllocation::LOUDNESS;
        let block_count = SbcBlockCount::SIXTEEN;
        let sub_bands = SbcSubBands::EIGHT;
        Some(
            SbcCodecInfo::new(
                frequency,
                channel_mode,
                block_count,
                sub_bands,
                allocation,
                min_bitpool,
                max_bitpool,
            )
            .expect("supported options"),
        )
    }
}

impl TryFrom<&[u8]> for SbcCodecInfo {
    type Error = avdtp::Error;

    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
        if value.len() != SBC_CODEC_EXTRA_LEN {
            return Err(avdtp::Error::OutOfRange);
        }

        let mut codec_info_bytes = [0_u8; SBC_CODEC_EXTRA_LEN];
        codec_info_bytes.copy_from_slice(&value);

        Ok(Self(SbcCodecInfoBits(u32::from_be_bytes(codec_info_bytes))))
    }
}

impl From<SbcCodecInfo> for avdtp::ServiceCapability {
    fn from(codec_info: SbcCodecInfo) -> Self {
        Self::MediaCodec {
            media_type: avdtp::MediaType::Audio,
            codec_type: avdtp::MediaCodecType::AUDIO_SBC,
            codec_extra: codec_info.to_bytes().to_vec(),
        }
    }
}

bitflags! {
    /// Object Type field for MPEG-2,4 AAC (Octet 0; b0-7).
    /// Support for MPEG-2 AAC LC is mandatory in both A2DP Sink and Source.
    /// Bits 0 to 4 are RFA.
    /// A2DP Sec. 4.5.2.1
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct AacObjectType:u8 {
        const MPEG2_AAC_LC       = 0b10000000;
        const MPEG4_AAC_LC       = 0b01000000;
        const MPEG4_AAC_LTP      = 0b00100000;
        const MPEG4_AAC_SCALABLE = 0b00010000;
        const MANDATORY_SNK = Self::MPEG2_AAC_LC.bits();
        const MANDATORY_SRC = Self::MPEG2_AAC_LC.bits();
    }
}

bitflags! {
    /// Sampling Frequency field for MPEG-2,4 AAC (Octet 1; b0-7, Octet 2; b4-7)
    /// Support for 44.1KHz & 48.0KHz is mandatory in A2DP Sink.
    /// Support for either 44.1KHz or 48.0KHz is mandatory in A2DP Source.
    /// A2DP Sec. 4.5.2.2
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct AacSamplingFrequency:u16 {
        const FREQ8000HZ  = 0b100000000000;
        const FREQ11025HZ = 0b010000000000;
        const FREQ12000HZ = 0b001000000000;
        const FREQ16000HZ = 0b000100000000;
        const FREQ22050HZ = 0b000010000000;
        const FREQ24000HZ = 0b000001000000;
        const FREQ32000HZ = 0b000000100000;
        const FREQ44100HZ = 0b000000010000;
        const FREQ48000HZ = 0b000000001000;
        const FREQ64000HZ = 0b000000000100;
        const FREQ88200HZ = 0b000000000010;
        const FREQ96000HZ = 0b000000000001;
        const MANDATORY_SNK = Self::FREQ44100HZ.bits() | Self::FREQ48000HZ.bits();
    }
}

impl AacSamplingFrequency {
    fn best(&self) -> Option<Self> {
        // Since one of 48000 or 44100 is mandatory, this list should find one.
        let ordered = [Self::FREQ96000HZ, Self::FREQ48000HZ, Self::FREQ44100HZ];
        ordered.iter().find(|freq| self.contains(**freq)).copied()
    }
}

bitflags! {
    /// Channels field for MPEG-2,4 AAC (Octet 2; b2-3).
    /// Support for both 1 and 2 channels is mandatory in A2DP Sink.
    /// Support for either 1 or 2 channels is mandatory in A2DP Source.
    /// A2DP Sec 4.5.2.3
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct AacChannels:u8 {
        const ONE = 0b10;
        const TWO = 0b01;
        const MANDATORY_SNK = Self::ONE.bits() | Self::TWO.bits();
    }
}

impl AacChannels {
    fn best(&self) -> Option<Self> {
        let ordered = [Self::TWO, Self::ONE];
        ordered.iter().find(|channels| self.contains(**channels)).copied()
    }
}

bitflags! {
    /// Support of Variable Bit Rate (VBR) field for MPEG-2,4 AAC (Octet 3; b7).
    /// Support for VBR is mandatory in A2DP Sink.
    /// A2DP Sec 4.5.2.5
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    struct AacVariableBitRate: u8 {
        const VBR_SUPPORTED = 0b1;
        const MANDATORY_SNK = Self::VBR_SUPPORTED.bits();
    }
}

pub const AAC_CODEC_EXTRA_LEN: usize = 6;

bitfield! {
    /// MPEG-2 AAC Codec Specific Information Elements (A2DP Sec 4.5.2)
    /// Structure:
    ///     Octet0: Object Type (b 40-47)
    ///     Octet1: Sampling Frequency (b 32-39)
    ///     Octet2: Sampling Frequency (b 28-31), Channels (b 26-27), RFA (b 24-25)
    ///     Octet3: VBR (b 23), Bit Rate (b 16-22)
    ///     Octet4: Bit Rate (b 8-15)
    ///     Octet5: Bit Rate (b 0-7)
    /// Some fields are mandatory choose 1, and therefore do not have a mandatory parameter method.
    struct AacCodecInfoBits(u64);
    impl Debug;
    u8;
    u32, bitrate, set_bitrate: 22, 0;
    vbr, set_vbr: 23, 23;
    // Bits 24-25 RFA.
    channels, set_channels: 27,26;
    u16, sampling_frequency, set_sampling_frequency: 39, 28;
    object_type, set_object_type: 47, 40;
    // Bits 48-63 Unused.
}

#[derive(Debug)]
pub struct AacCodecInfo(AacCodecInfoBits);

impl AacCodecInfo {
    pub fn new(
        object_type: AacObjectType,
        sampling_frequency: AacSamplingFrequency,
        channels: AacChannels,
        vbr: bool,
        bitrate: u32,
    ) -> avdtp::Result<Self> {
        // Bitrate is expressed as a 23bit UiMsbf, stored in a u32.
        if bitrate > 0x7fffff {
            return Err(avdtp::Error::OutOfRange);
        }
        let mut res = AacCodecInfoBits(0);
        res.set_bitrate(bitrate);
        if vbr {
            res.set_vbr(AacVariableBitRate::VBR_SUPPORTED.bits());
        }
        res.set_channels(channels.bits());
        res.set_sampling_frequency(sampling_frequency.bits());
        res.set_object_type(object_type.bits());
        Ok(Self(res))
    }

    /// `AacCodecInfoBytes` is represented as an u64, with upper 16 bits unused.
    /// Return a vector of the lower 6 bytes.
    pub fn to_bytes(&self) -> [u8; 6] {
        let codec_info = (self.0).0.to_be_bytes();
        let mut res = [0u8; 6];
        res.copy_from_slice(&codec_info[2..8]);
        res
    }

    pub fn variable_bit_rate(&self) -> bool {
        self.0.vbr() == 0b1
    }

    pub fn bitrate(&self) -> u32 {
        self.0.bitrate()
    }

    pub fn channels(&self) -> AacChannels {
        AacChannels::from_bits_truncate(self.0.channels())
    }

    /// Returns the number of channels selected.
    /// Returns Error::OutOfRange if both mono and stereo are selected.
    pub fn channel_count(&self) -> avdtp::Result<usize> {
        let count = match self.channels() {
            AacChannels::ONE => 1,
            AacChannels::TWO => 2,
            _ => return Err(avdtp::Error::OutOfRange),
        };
        Ok(count)
    }

    fn object_type(&self) -> AacObjectType {
        AacObjectType::from_bits_truncate(self.0.object_type())
    }

    /// Returns the sampling frequeency selected, in hz.
    /// Returns Error::OutOfRange if multiple frequencies are selected.
    pub fn sampling_frequency(&self) -> avdtp::Result<u32> {
        let hz = match AacSamplingFrequency::from_bits_truncate(self.0.sampling_frequency()) {
            AacSamplingFrequency::FREQ8000HZ => 8000,
            AacSamplingFrequency::FREQ11025HZ => 11025,
            AacSamplingFrequency::FREQ12000HZ => 12000,
            AacSamplingFrequency::FREQ16000HZ => 16000,
            AacSamplingFrequency::FREQ22050HZ => 22050,
            AacSamplingFrequency::FREQ24000HZ => 24000,
            AacSamplingFrequency::FREQ32000HZ => 32000,
            AacSamplingFrequency::FREQ44100HZ => 44100,
            AacSamplingFrequency::FREQ48000HZ => 48000,
            AacSamplingFrequency::FREQ64000HZ => 64000,
            AacSamplingFrequency::FREQ88200HZ => 88200,
            AacSamplingFrequency::FREQ96000HZ => 96000,
            _ => return Err(avdtp::Error::OutOfRange),
        };
        Ok(hz)
    }

    /// Returns true if `other` is a compatable configuration of `self`
    pub fn supports(&self, other: &Self) -> bool {
        let allowed_frequencies =
            AacSamplingFrequency::from_bits_truncate(self.0.sampling_frequency());
        let selected_frequencies =
            AacSamplingFrequency::from_bits_truncate(other.0.sampling_frequency());
        if !(allowed_frequencies.intersects(selected_frequencies)) {
            return false;
        }
        if !(self.channels().intersects(other.channels())) {
            return false;
        }
        if !(self.object_type().intersects(other.object_type())) {
            return false;
        }
        if !self.variable_bit_rate() && other.variable_bit_rate() {
            return false;
        }
        // Note: the "capabilities" bitrate field is unclear in the A2DP spec: 4.5.2.4.
        // Interpreting this as the max bitrate for either constant or vbr.
        // Zero is "not known", which we interpret to be "any bitrate is okay", but only
        // if we are interpreting our bitrate support
        if self.bitrate() != 0 && (self.bitrate() < other.bitrate()) {
            return false;
        }
        return true;
    }

    pub fn negotiate(a: &Self, b: &Self) -> Option<Self> {
        let available_frequencies = AacSamplingFrequency::from_bits_truncate(
            a.0.sampling_frequency() & b.0.sampling_frequency(),
        );
        let sampling_frequency = match available_frequencies.best() {
            None => return None,
            Some(freq) => freq,
        };
        let available_channels = a.channels() & b.channels();
        let channels = match available_channels.best() {
            None => return None,
            Some(channels) => channels,
        };
        let vbr = a.variable_bit_rate() && b.variable_bit_rate();
        // If either bitrate is unspecified, take the other one, otherwise, the minimum.
        // If both are unspecified, choose a reasonable one.
        let bitrate = match (a.bitrate(), b.bitrate()) {
            // Pick a reasonable quality bitrate to use by default. 64k average per channel.
            (0, 0) => 128000,
            (0, b) => b,
            (a, 0) => a,
            (a, b) => std::cmp::min(a, b),
        };
        // This option is mandatory for source and sink and we prefer it. See A2DP 1.3.2 Sec 4.5.2
        let object_type = AacObjectType::MPEG2_AAC_LC;
        Some(AacCodecInfo::new(object_type, sampling_frequency, channels, vbr, bitrate).unwrap())
    }
}

impl TryFrom<&[u8]> for AacCodecInfo {
    type Error = avdtp::Error;

    /// Create `AacCodecInfo` from slice of length `AAC_CODEC_EXTRA_LEN`
    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
        if value.len() != AAC_CODEC_EXTRA_LEN {
            return Err(avdtp::Error::OutOfRange);
        }
        let mut codec_info_bytes = [0_u8; 8];
        let codec_info_slice = &mut codec_info_bytes[2..8];
        // AacCodecInfo is represented as 8 bytes, with lower 6 bytes containing
        // the codec extra data.
        codec_info_slice.copy_from_slice(&value);
        Ok(Self(AacCodecInfoBits(u64::from_be_bytes(codec_info_bytes))))
    }
}

impl From<AacCodecInfo> for avdtp::ServiceCapability {
    fn from(codec_info: AacCodecInfo) -> Self {
        Self::MediaCodec {
            media_type: avdtp::MediaType::Audio,
            codec_type: avdtp::MediaCodecType::AUDIO_AAC,
            codec_extra: codec_info.to_bytes().to_vec(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use assert_matches::assert_matches;

    #[test]
    /// Unit test for the SBC media codec info generation.
    fn test_sbc_codec_info() {
        // Mandatory A2DP Sink support case.
        let sbc_codec_info: SbcCodecInfo = SbcCodecInfo::new(
            SbcSamplingFrequency::MANDATORY_SNK,
            SbcChannelMode::MANDATORY_SNK,
            SbcBlockCount::MANDATORY_SNK,
            SbcSubBands::MANDATORY_SNK,
            SbcAllocation::MANDATORY_SNK,
            2,
            250,
        )
        .expect("Couldn't create sbc media codec info.");
        let res = sbc_codec_info.to_bytes();
        let codec_extra: Vec<u8> = vec![0x3F, 0xFF, 2, 250];
        assert_eq!(codec_extra, res);

        // reverse parsing and check we match
        let res = SbcCodecInfo::try_from(&codec_extra[..]).expect("created codec info");
        assert_eq!((res.0).0, (sbc_codec_info.0).0);

        // Mandatory A2DP source support case. Some fields are choose 1 fields.
        let sbc_codec_info: SbcCodecInfo = SbcCodecInfo::new(
            SbcSamplingFrequency::FREQ44100HZ,
            SbcChannelMode::MONO | SbcChannelMode::DUAL_CHANNEL,
            SbcBlockCount::MANDATORY_SRC,
            SbcSubBands::MANDATORY_SRC,
            SbcAllocation::MANDATORY_SRC,
            2,
            250,
        )
        .expect("Couldn't create sbc media codec info.");
        let res = sbc_codec_info.to_bytes();
        assert_eq!(vec![0x2C, 0xF5, 2, 250], res);

        // No supported codec information
        let sbc_codec_info: SbcCodecInfo = SbcCodecInfo::new(
            SbcSamplingFrequency::empty(),
            SbcChannelMode::empty(),
            SbcBlockCount::empty(),
            SbcSubBands::empty(),
            SbcAllocation::empty(),
            2,
            250,
        )
        .expect("Couldn't create sbc media codec info.");
        assert_matches!(sbc_codec_info.channel_count(), Err(avdtp::Error::OutOfRange));
        let res = sbc_codec_info.to_bytes();
        assert_eq!(vec![0x00, 0x00, 2, 250], res);

        // All codec field values are supported
        let sbc_codec_info: SbcCodecInfo = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");
        assert_matches!(sbc_codec_info.channel_count(), Err(avdtp::Error::OutOfRange));
        let res = sbc_codec_info.to_bytes();
        assert_eq!(vec![0xFF, 0xFF, 2, 250], res);

        // Out of range bitpool value
        let sbc_codec_info = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            20,
            252, // Too large.
        );
        assert!(sbc_codec_info.is_err());

        // Out of range bitpool value
        let sbc_codec_info = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            0, // Too small
            240,
        );
        assert!(sbc_codec_info.is_err());

        // Invalid bitpool value
        let sbc_codec_info = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            100,
            50,
        );
        assert!(sbc_codec_info.is_err());

        let empty = vec![0, 0, 0, 0];
        let res = SbcCodecInfo::try_from(&empty[..]).expect("created codec info");
        assert_eq!((res.0).0, 0);

        let too_big = vec![0, 0, 0, 0, 0];
        assert_matches!(SbcCodecInfo::try_from(&too_big[..]), Err(avdtp::Error::OutOfRange));

        // Mono and Stereo
        let sbc_codec_info: SbcCodecInfo = SbcCodecInfo::new(
            SbcSamplingFrequency::FREQ44100HZ,
            SbcChannelMode::MONO,
            SbcBlockCount::MANDATORY_SRC,
            SbcSubBands::MANDATORY_SRC,
            SbcAllocation::MANDATORY_SRC,
            2,
            250,
        )
        .expect("Couldn't create sbc media codec info.");
        assert_matches!(sbc_codec_info.channel_count(), Ok(1));

        let sbc_codec_info: SbcCodecInfo = SbcCodecInfo::new(
            SbcSamplingFrequency::FREQ44100HZ,
            SbcChannelMode::JOINT_STEREO,
            SbcBlockCount::MANDATORY_SRC,
            SbcSubBands::MANDATORY_SRC,
            SbcAllocation::MANDATORY_SRC,
            2,
            250,
        )
        .expect("Couldn't create sbc media codec info.");
        assert_matches!(sbc_codec_info.channel_count(), Ok(2));
    }

    #[test]
    fn test_sbc_codec_supports() {
        let sbc_codec_all = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");
        // Should support itself.
        assert!(sbc_codec_all.supports(&sbc_codec_all));

        let sbc_codec_441 = SbcCodecInfo::new(
            SbcSamplingFrequency::FREQ44100HZ,
            SbcChannelMode::all(),
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            53,                        // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");

        let sbc_codec_48 = SbcCodecInfo::new(
            SbcSamplingFrequency::FREQ48000HZ,
            SbcChannelMode::all(),
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            53,                        // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");

        assert!(sbc_codec_all.supports(&sbc_codec_441));
        assert!(sbc_codec_all.supports(&sbc_codec_48));

        // Frequency mismatches
        assert!(!sbc_codec_48.supports(&sbc_codec_441));
        assert!(!sbc_codec_441.supports(&sbc_codec_48));

        // Min / Max bitpools
        assert!(!sbc_codec_48.supports(&sbc_codec_all));
        assert!(!sbc_codec_441.supports(&sbc_codec_all));

        let sbc_codec_mono = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::MONO,
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");
        let sbc_codec_stereo = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::JOINT_STEREO,
            SbcBlockCount::all(),
            SbcSubBands::all(),
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");

        assert!(sbc_codec_all.supports(&sbc_codec_mono));
        assert!(sbc_codec_all.supports(&sbc_codec_stereo));
        assert!(!sbc_codec_mono.supports(&sbc_codec_stereo));
        assert!(!sbc_codec_stereo.supports(&sbc_codec_mono));

        let sbc_codec_blocks_4 = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::FOUR,
            SbcSubBands::all(),
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");
        let sbc_codec_blocks_8 = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::EIGHT,
            SbcSubBands::all(),
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");

        assert!(sbc_codec_all.supports(&sbc_codec_blocks_4));
        assert!(sbc_codec_all.supports(&sbc_codec_blocks_8));
        assert!(!sbc_codec_blocks_4.supports(&sbc_codec_blocks_8));
        assert!(!sbc_codec_blocks_8.supports(&sbc_codec_blocks_4));

        let sbc_codec_bands_4 = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::FOUR,
            SbcSubBands::FOUR,
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");
        let sbc_codec_bands_8 = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::FOUR,
            SbcSubBands::EIGHT,
            SbcAllocation::all(),
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");

        assert!(sbc_codec_all.supports(&sbc_codec_bands_4));
        assert!(sbc_codec_all.supports(&sbc_codec_bands_8));
        assert!(!sbc_codec_bands_4.supports(&sbc_codec_bands_8));
        assert!(!sbc_codec_bands_8.supports(&sbc_codec_bands_4));

        let sbc_codec_snr = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::FOUR,
            SbcSubBands::FOUR,
            SbcAllocation::SNR,
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");
        let sbc_codec_loudness = SbcCodecInfo::new(
            SbcSamplingFrequency::all(),
            SbcChannelMode::all(),
            SbcBlockCount::FOUR,
            SbcSubBands::FOUR,
            SbcAllocation::LOUDNESS,
            SbcCodecInfo::BITPOOL_MIN, // Smallest bitpool value.
            SbcCodecInfo::BITPOOL_MAX, // Largest bitpool value.
        )
        .expect("Couldn't create sbc media codec info.");

        assert!(sbc_codec_all.supports(&sbc_codec_snr));
        assert!(sbc_codec_all.supports(&sbc_codec_loudness));
        assert!(!sbc_codec_snr.supports(&sbc_codec_loudness));
        assert!(!sbc_codec_loudness.supports(&sbc_codec_snr));
    }

    #[test]
    fn test_aac_codec_info() {
        // Empty case.
        let aac_codec_info = AacCodecInfo::new(
            AacObjectType::empty(),
            AacSamplingFrequency::empty(),
            AacChannels::empty(),
            false,
            0,
        )
        .expect("Error creating aac media codec info.");
        let res = aac_codec_info.to_bytes();
        assert_eq!(vec![0, 0, 0, 0, 0, 0], res);

        // All codec info supported case.
        let aac_codec_info = AacCodecInfo::new(
            AacObjectType::all(),
            AacSamplingFrequency::all(),
            AacChannels::all(),
            true,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");
        assert_matches!(aac_codec_info.channel_count(), Err(avdtp::Error::OutOfRange));
        let res = aac_codec_info.to_bytes();
        assert_eq!(vec![0xF0, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF], res);

        // Only VBR specified.
        let aac_codec_info = AacCodecInfo::new(
            AacObjectType::empty(),
            AacSamplingFrequency::empty(),
            AacChannels::empty(),
            true,
            0,
        )
        .expect("Error creating aac media codec info.");
        assert_matches!(aac_codec_info.channel_count(), Err(avdtp::Error::OutOfRange));
        let res = aac_codec_info.to_bytes();
        assert_eq!(vec![0x00, 0x00, 0x00, 0x80, 0x00, 0x00], res);

        // A2DP Sink mandatory fields supported.
        let aac_codec_info = AacCodecInfo::new(
            AacObjectType::MANDATORY_SNK,
            AacSamplingFrequency::MANDATORY_SNK,
            AacChannels::MANDATORY_SNK,
            true,
            0xAAFF, // Arbitrary bit rate.
        )
        .expect("Error creating aac media codec info.");
        let res = aac_codec_info.to_bytes();
        let codec_extra: Vec<u8> = vec![0x80, 0x01, 0x8C, 0x80, 0xAA, 0xFF];
        assert_eq!(codec_extra, res);

        // reverse parsing and check we match
        let res = AacCodecInfo::try_from(&codec_extra[..]).expect("created codec info");
        assert_eq!((res.0).0, (aac_codec_info.0).0);

        // A2DP Source mandatory fields supported.
        let aac_codec_info = AacCodecInfo::new(
            AacObjectType::MANDATORY_SRC,
            AacSamplingFrequency::FREQ44100HZ,
            AacChannels::ONE,
            false,  // VBR is optional in SRC.
            0xAAFF, // Arbitrary
        )
        .expect("Error creating aac media codec info.");
        assert_matches!(aac_codec_info.channel_count(), Ok(1));
        let res = aac_codec_info.to_bytes();
        assert_eq!(vec![0x80, 0x01, 0x08, 0x00, 0xAA, 0xFF], res);

        // A2DP Source with two channels
        let aac_codec_info = AacCodecInfo::new(
            AacObjectType::MANDATORY_SRC,
            AacSamplingFrequency::FREQ44100HZ,
            AacChannels::TWO,
            false,  // VBR is optional in SRC.
            0xAAFF, // Arbitrary
        )
        .expect("Error creating aac media codec info.");
        assert_matches!(aac_codec_info.channel_count(), Ok(2));

        // Out of range bit rate.
        let aac_codec_info = AacCodecInfo::new(
            AacObjectType::MANDATORY_SRC,
            AacSamplingFrequency::FREQ44100HZ,
            AacChannels::ONE,
            false,
            0xFFFFFF, // Too large
        );
        assert!(aac_codec_info.is_err());

        let empty = vec![0, 0, 0, 0, 0, 0];
        let res = AacCodecInfo::try_from(&empty[..]).expect("created codec info");
        assert_eq!((res.0).0, 0);

        let too_big = vec![0, 0, 0, 0, 0, 0, 0];
        assert_matches!(AacCodecInfo::try_from(&too_big[..]), Err(avdtp::Error::OutOfRange));
    }

    #[test]
    fn test_aac_codec_supports() {
        // All codec info supported case.
        let aac_codec_all = AacCodecInfo::new(
            AacObjectType::all(),
            AacSamplingFrequency::all(),
            AacChannels::all(),
            true,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");

        assert!(aac_codec_all.supports(&aac_codec_all));

        let aac_codec_441 = AacCodecInfo::new(
            AacObjectType::all(),
            AacSamplingFrequency::FREQ44100HZ,
            AacChannels::all(),
            true,
            50, // Lower than largest.
        )
        .expect("Error creating aac media codec info.");

        let aac_codec_48 = AacCodecInfo::new(
            AacObjectType::all(),
            AacSamplingFrequency::FREQ48000HZ,
            AacChannels::all(),
            true,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");

        assert!(aac_codec_all.supports(&aac_codec_441));
        assert!(aac_codec_all.supports(&aac_codec_48));

        // Frequencies
        assert!(!aac_codec_441.supports(&aac_codec_48));
        assert!(!aac_codec_48.supports(&aac_codec_441));

        // Max bitrate.
        assert!(!aac_codec_441.supports(&aac_codec_all));

        // Channels
        let aac_codec_chan_one = AacCodecInfo::new(
            AacObjectType::all(),
            AacSamplingFrequency::all(),
            AacChannels::ONE,
            true,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");

        let aac_codec_chan_two = AacCodecInfo::new(
            AacObjectType::all(),
            AacSamplingFrequency::all(),
            AacChannels::TWO,
            true,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");

        assert!(aac_codec_all.supports(&aac_codec_chan_one));
        assert!(aac_codec_all.supports(&aac_codec_chan_two));
        assert!(!aac_codec_chan_one.supports(&aac_codec_chan_two));
        assert!(!aac_codec_chan_two.supports(&aac_codec_chan_one));

        // object type
        let aac_codec_mpeg2 = AacCodecInfo::new(
            AacObjectType::MPEG2_AAC_LC,
            AacSamplingFrequency::all(),
            AacChannels::ONE,
            true,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");

        let aac_codec_mpeg4 = AacCodecInfo::new(
            AacObjectType::MPEG4_AAC_LC,
            AacSamplingFrequency::all(),
            AacChannels::ONE,
            true,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");

        assert!(aac_codec_all.supports(&aac_codec_mpeg2));
        assert!(aac_codec_all.supports(&aac_codec_mpeg4));
        assert!(!aac_codec_mpeg2.supports(&aac_codec_mpeg4));
        assert!(!aac_codec_mpeg4.supports(&aac_codec_mpeg2));

        let aac_codec_not_vbr = AacCodecInfo::new(
            AacObjectType::MPEG4_AAC_LC,
            AacSamplingFrequency::all(),
            AacChannels::ONE,
            false,
            8388607, // Largest 23-bit bit rate.
        )
        .expect("Error creating aac media codec info.");

        assert!(!aac_codec_not_vbr.supports(&aac_codec_mpeg4));

        let aac_codec_bitrate_not_known = AacCodecInfo::new(
            AacObjectType::MPEG4_AAC_LC,
            AacSamplingFrequency::all(),
            AacChannels::ONE,
            true,
            0, // Bitrate "Not known"
        )
        .expect("Error creating aac media codec info.");

        assert!(aac_codec_bitrate_not_known.supports(&aac_codec_not_vbr));
    }
}