| /* |
| * Copyright 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <gtest/gtest.h> |
| |
| #include "client_interface.h" |
| |
| namespace { |
| |
| using ::android::hardware::bluetooth::audio::V2_0::AacObjectType; |
| using ::android::hardware::bluetooth::audio::V2_0::AacParameters; |
| using ::android::hardware::bluetooth::audio::V2_0::AacVariableBitRate; |
| using ::android::hardware::bluetooth::audio::V2_0::AptxParameters; |
| using ::android::hardware::bluetooth::audio::V2_0::CodecCapabilities; |
| using ::android::hardware::bluetooth::audio::V2_0::CodecConfiguration; |
| using ::android::hardware::bluetooth::audio::V2_0::CodecType; |
| using ::android::hardware::bluetooth::audio::V2_0::LdacChannelMode; |
| using ::android::hardware::bluetooth::audio::V2_0::LdacParameters; |
| using ::android::hardware::bluetooth::audio::V2_0::LdacQualityIndex; |
| using ::android::hardware::bluetooth::audio::V2_0::SbcAllocMethod; |
| using ::android::hardware::bluetooth::audio::V2_0::SbcBlockLength; |
| using ::android::hardware::bluetooth::audio::V2_0::SbcChannelMode; |
| using ::android::hardware::bluetooth::audio::V2_0::SbcNumSubbands; |
| using ::android::hardware::bluetooth::audio::V2_0::SbcParameters; |
| |
| using ::bluetooth::audio::AudioCapabilities; |
| using ::bluetooth::audio::AudioConfiguration; |
| using ::bluetooth::audio::BitsPerSample; |
| using ::bluetooth::audio::BluetoothAudioClientInterface; |
| using ::bluetooth::audio::BluetoothAudioStatus; |
| using ::bluetooth::audio::ChannelMode; |
| using ::bluetooth::audio::PcmParameters; |
| using ::bluetooth::audio::SampleRate; |
| using ::bluetooth::audio::SessionType; |
| using ::testing::Test; |
| |
| constexpr SampleRate kSampleRates[9] = { |
| SampleRate::RATE_UNKNOWN, SampleRate::RATE_44100, SampleRate::RATE_48000, |
| SampleRate::RATE_88200, SampleRate::RATE_96000, SampleRate::RATE_176400, |
| SampleRate::RATE_192000, SampleRate::RATE_16000, SampleRate::RATE_24000}; |
| constexpr BitsPerSample kBitsPerSamples[4] = { |
| BitsPerSample::BITS_UNKNOWN, BitsPerSample::BITS_16, BitsPerSample::BITS_24, |
| BitsPerSample::BITS_32}; |
| constexpr ChannelMode kChannelModes[3] = { |
| ChannelMode::UNKNOWN, ChannelMode::MONO, ChannelMode::STEREO}; |
| constexpr uint16_t kPeerMtus[5] = {660, 663, 883, 1005, 1500}; |
| |
| class TestTransport : public bluetooth::audio::IBluetoothTransportInstance { |
| private: |
| static constexpr uint64_t kRemoteDelayReportMs = 200; |
| |
| public: |
| TestTransport(SessionType session_type) |
| : bluetooth::audio::IBluetoothTransportInstance(session_type, {}){}; |
| bluetooth::audio::BluetoothAudioCtrlAck StartRequest() { |
| return bluetooth::audio::BluetoothAudioCtrlAck::SUCCESS_FINISHED; |
| } |
| bluetooth::audio::BluetoothAudioCtrlAck SuspendRequest() { |
| return bluetooth::audio::BluetoothAudioCtrlAck::SUCCESS_FINISHED; |
| } |
| void StopRequest() {} |
| bool GetPresentationPosition(uint64_t* remote_delay_report_ns, |
| uint64_t* total_bytes_readed, |
| timespec* data_position) { |
| if (remote_delay_report_ns) { |
| *remote_delay_report_ns = kRemoteDelayReportMs * 1000000; |
| } |
| if (total_bytes_readed) { |
| *total_bytes_readed = 0; |
| } |
| if (data_position) { |
| clock_gettime(CLOCK_MONOTONIC, data_position); |
| } |
| return true; |
| } |
| void MetadataChanged(const source_metadata_t& source_metadata __unused) {} |
| void ResetPresentationPosition(){}; |
| void LogBytesRead(size_t bytes_readed __unused){}; |
| }; |
| |
| class BluetoothAudioClientInterfaceTest : public Test { |
| protected: |
| TestTransport* test_transport_; |
| BluetoothAudioClientInterface* clientif_; |
| |
| static constexpr int kClientIfReturnSuccess = 0; |
| |
| virtual void SetUp() override {} |
| |
| virtual void TearDown() override { |
| clientif_ = nullptr; |
| test_transport_ = nullptr; |
| } |
| |
| bool IsSoftwarePcmParametersSupported(const PcmParameters& pcm_config) { |
| const std::vector<AudioCapabilities>& capabilities = |
| clientif_->GetAudioCapabilities(); |
| PcmParameters pcm_capabilities = capabilities[0].pcmCapabilities(); |
| bool is_pcm_config_valid = |
| (pcm_config.sampleRate != SampleRate::RATE_UNKNOWN && |
| pcm_config.bitsPerSample != BitsPerSample::BITS_UNKNOWN && |
| pcm_config.channelMode != ChannelMode::UNKNOWN); |
| bool is_pcm_config_supported = |
| (pcm_config.sampleRate & pcm_capabilities.sampleRate && |
| pcm_config.bitsPerSample & pcm_capabilities.bitsPerSample && |
| pcm_config.channelMode & pcm_capabilities.channelMode); |
| return (is_pcm_config_valid && is_pcm_config_supported); |
| } |
| |
| bool IsOffloadCodecConfigurationSupported( |
| const CodecConfiguration& codec_config) { |
| CodecCapabilities codec_capability = {}; |
| for (auto audio_capability : clientif_->GetAudioCapabilities()) { |
| if (audio_capability.codecCapabilities().codecType == |
| codec_config.codecType) { |
| codec_capability = audio_capability.codecCapabilities(); |
| } |
| } |
| if (codec_capability.codecType != codec_config.codecType) { |
| // codec is unsupported |
| return false; |
| } |
| bool is_codec_config_supported = false; |
| switch (codec_config.codecType) { |
| case CodecType::SBC: { |
| SbcParameters sbc_config = codec_config.config.sbcConfig(); |
| SbcParameters sbc_capability = |
| codec_capability.capabilities.sbcCapabilities(); |
| is_codec_config_supported = |
| (sbc_config.sampleRate & sbc_capability.sampleRate && |
| sbc_config.channelMode & sbc_capability.channelMode && |
| sbc_config.blockLength & sbc_capability.blockLength && |
| sbc_config.numSubbands & sbc_capability.numSubbands && |
| sbc_config.allocMethod & sbc_capability.allocMethod && |
| sbc_config.bitsPerSample & sbc_capability.bitsPerSample && |
| (sbc_capability.minBitpool <= sbc_config.minBitpool && |
| sbc_config.minBitpool <= sbc_config.maxBitpool && |
| sbc_config.maxBitpool <= sbc_capability.maxBitpool)); |
| return is_codec_config_supported; |
| } |
| case CodecType::AAC: { |
| AacParameters aac_config = codec_config.config.aacConfig(); |
| AacParameters aac_capability = |
| codec_capability.capabilities.aacCapabilities(); |
| is_codec_config_supported = |
| (aac_config.objectType & aac_capability.objectType && |
| aac_config.sampleRate & aac_capability.sampleRate && |
| aac_config.channelMode & aac_capability.channelMode && |
| (aac_config.variableBitRateEnabled == |
| AacVariableBitRate::DISABLED || |
| aac_capability.variableBitRateEnabled == |
| AacVariableBitRate::ENABLED) && |
| aac_config.bitsPerSample & aac_capability.bitsPerSample); |
| return is_codec_config_supported; |
| } |
| case CodecType::LDAC: { |
| LdacParameters ldac_config = codec_config.config.ldacConfig(); |
| LdacParameters ldac_capability = |
| codec_capability.capabilities.ldacCapabilities(); |
| is_codec_config_supported = |
| (ldac_config.sampleRate & ldac_capability.sampleRate && |
| ldac_config.channelMode & ldac_capability.channelMode && |
| ldac_config.bitsPerSample & ldac_capability.bitsPerSample); |
| return is_codec_config_supported; |
| } |
| case CodecType::APTX: |
| [[fallthrough]]; |
| case CodecType::APTX_HD: { |
| AptxParameters aptx_config = codec_config.config.aptxConfig(); |
| AptxParameters aptx_capability = |
| codec_capability.capabilities.aptxCapabilities(); |
| is_codec_config_supported = |
| (aptx_config.sampleRate & aptx_capability.sampleRate && |
| aptx_config.channelMode & aptx_capability.channelMode && |
| aptx_config.bitsPerSample & aptx_capability.bitsPerSample); |
| return is_codec_config_supported; |
| } |
| case CodecType::UNKNOWN: |
| return false; |
| } |
| } |
| }; |
| |
| } // namespace |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpSoftwareSession) { |
| test_transport_ = |
| new TestTransport(SessionType::A2DP_SOFTWARE_ENCODING_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| PcmParameters pcm_config = {}; |
| for (auto sample_rate : kSampleRates) { |
| pcm_config.sampleRate = sample_rate; |
| for (auto bits_per_sample : kBitsPerSamples) { |
| pcm_config.bitsPerSample = bits_per_sample; |
| for (auto channel_mode : kChannelModes) { |
| pcm_config.channelMode = channel_mode; |
| audio_config.pcmConfig(pcm_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsSoftwarePcmParametersSupported(pcm_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadSbcSession) { |
| test_transport_ = |
| new TestTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| CodecConfiguration codec_config = {}; |
| SbcBlockLength block_lengths[4] = { |
| SbcBlockLength::BLOCKS_4, SbcBlockLength::BLOCKS_8, |
| SbcBlockLength::BLOCKS_12, SbcBlockLength::BLOCKS_16}; |
| SbcNumSubbands num_subbands[2] = {SbcNumSubbands::SUBBAND_4, |
| SbcNumSubbands::SUBBAND_8}; |
| SbcAllocMethod alloc_methods[2] = {SbcAllocMethod::ALLOC_MD_S, |
| SbcAllocMethod::ALLOC_MD_L}; |
| for (auto sample_rate : kSampleRates) { |
| for (auto bits_per_sample : kBitsPerSamples) { |
| for (auto channel_mode : kChannelModes) { |
| for (auto peer_mtu : kPeerMtus) { |
| for (auto block_length : block_lengths) { |
| for (auto num_subband : num_subbands) { |
| for (auto alloc_method : alloc_methods) { |
| codec_config.codecType = CodecType::SBC; |
| codec_config.peerMtu = peer_mtu; |
| codec_config.isScmstEnabled = false; |
| // A2DP_SBC_DEFAULT_BITRATE |
| codec_config.encodedAudioBitrate = 328000; |
| SbcParameters sbc = { |
| .sampleRate = sample_rate, |
| .channelMode = (channel_mode == ChannelMode::MONO |
| ? SbcChannelMode::MONO |
| : SbcChannelMode::JOINT_STEREO), |
| .blockLength = block_length, |
| .numSubbands = num_subband, |
| .allocMethod = alloc_method, |
| .bitsPerSample = bits_per_sample, |
| .minBitpool = 2, |
| .maxBitpool = 53}; |
| codec_config.config.sbcConfig(sbc); |
| audio_config.codecConfig(codec_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsOffloadCodecConfigurationSupported(codec_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } // SbcAllocMethod |
| } // SbcNumSubbands |
| } // SbcBlockLength |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadAacSession) { |
| test_transport_ = |
| new TestTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| CodecConfiguration codec_config = {}; |
| AacObjectType object_types[4] = { |
| AacObjectType::MPEG2_LC, AacObjectType::MPEG4_LC, |
| AacObjectType::MPEG4_LTP, AacObjectType::MPEG4_SCALABLE}; |
| AacVariableBitRate variable_bitrates[2] = {AacVariableBitRate::DISABLED, |
| AacVariableBitRate::ENABLED}; |
| for (auto sample_rate : kSampleRates) { |
| for (auto bits_per_sample : kBitsPerSamples) { |
| for (auto channel_mode : kChannelModes) { |
| for (auto peer_mtu : kPeerMtus) { |
| for (auto object_type : object_types) { |
| for (auto variable_bitrate : variable_bitrates) { |
| codec_config.codecType = CodecType::AAC; |
| codec_config.peerMtu = peer_mtu; |
| codec_config.isScmstEnabled = false; |
| // A2DP_AAC_DEFAULT_BITRATE |
| codec_config.encodedAudioBitrate = 320000; |
| AacParameters aac = {.objectType = object_type, |
| .sampleRate = sample_rate, |
| .channelMode = channel_mode, |
| .variableBitRateEnabled = variable_bitrate, |
| .bitsPerSample = bits_per_sample}; |
| codec_config.config.aacConfig(aac); |
| audio_config.codecConfig(codec_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsOffloadCodecConfigurationSupported(codec_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } // AacVariableBitRate |
| } // AacObjectType |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadLdacSession) { |
| test_transport_ = |
| new TestTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| CodecConfiguration codec_config = {}; |
| LdacQualityIndex quality_indexes[4] = { |
| LdacQualityIndex::QUALITY_HIGH, LdacQualityIndex::QUALITY_MID, |
| LdacQualityIndex::QUALITY_LOW, LdacQualityIndex::QUALITY_ABR}; |
| for (auto sample_rate : kSampleRates) { |
| for (auto bits_per_sample : kBitsPerSamples) { |
| for (auto channel_mode : kChannelModes) { |
| for (auto peer_mtu : kPeerMtus) { |
| for (auto quality_index : quality_indexes) { |
| codec_config.codecType = CodecType::LDAC; |
| codec_config.peerMtu = peer_mtu; |
| codec_config.isScmstEnabled = false; |
| codec_config.encodedAudioBitrate = 990000; |
| LdacParameters ldac = { |
| .sampleRate = sample_rate, |
| .channelMode = (channel_mode == ChannelMode::MONO |
| ? LdacChannelMode::MONO |
| : LdacChannelMode::STEREO), |
| .qualityIndex = quality_index, |
| .bitsPerSample = bits_per_sample}; |
| codec_config.config.ldacConfig(ldac); |
| audio_config.codecConfig(codec_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsOffloadCodecConfigurationSupported(codec_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } // LdacQualityIndex |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadAptxSession) { |
| test_transport_ = |
| new TestTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| CodecConfiguration codec_config = {}; |
| for (auto sample_rate : kSampleRates) { |
| for (auto bits_per_sample : kBitsPerSamples) { |
| for (auto channel_mode : kChannelModes) { |
| for (auto peer_mtu : kPeerMtus) { |
| codec_config.codecType = CodecType::APTX; |
| codec_config.peerMtu = peer_mtu; |
| codec_config.isScmstEnabled = false; |
| codec_config.encodedAudioBitrate = 352000; |
| AptxParameters aptx = {.sampleRate = sample_rate, |
| .channelMode = channel_mode, |
| .bitsPerSample = bits_per_sample}; |
| codec_config.config.aptxConfig(aptx); |
| audio_config.codecConfig(codec_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsOffloadCodecConfigurationSupported(codec_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadAptxHdSession) { |
| test_transport_ = |
| new TestTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| CodecConfiguration codec_config = {}; |
| for (auto sample_rate : kSampleRates) { |
| for (auto bits_per_sample : kBitsPerSamples) { |
| for (auto channel_mode : kChannelModes) { |
| for (auto peer_mtu : kPeerMtus) { |
| codec_config.codecType = CodecType::APTX_HD; |
| codec_config.peerMtu = peer_mtu; |
| codec_config.isScmstEnabled = false; |
| codec_config.encodedAudioBitrate = 576000; |
| AptxParameters aptx = {.sampleRate = sample_rate, |
| .channelMode = channel_mode, |
| .bitsPerSample = bits_per_sample}; |
| codec_config.config.aptxConfig(aptx); |
| audio_config.codecConfig(codec_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsOffloadCodecConfigurationSupported(codec_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, |
| StartAndEndA2dpOffloadUnknownSession) { |
| test_transport_ = |
| new TestTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| CodecConfiguration codec_config = {}; |
| codec_config.codecType = CodecType::UNKNOWN; |
| codec_config.peerMtu = 1005; |
| codec_config.isScmstEnabled = false; |
| codec_config.encodedAudioBitrate = 328000; |
| codec_config.config = {}; |
| audio_config.codecConfig(codec_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsOffloadCodecConfigurationSupported(codec_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, |
| StartAndEndHearingAidSoftwareSession) { |
| test_transport_ = |
| new TestTransport(SessionType::HEARING_AID_SOFTWARE_ENCODING_DATAPATH); |
| clientif_ = new BluetoothAudioClientInterface(test_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| PcmParameters pcm_config = {}; |
| for (auto sample_rate : kSampleRates) { |
| pcm_config.sampleRate = sample_rate; |
| for (auto bits_per_sample : kBitsPerSamples) { |
| pcm_config.bitsPerSample = bits_per_sample; |
| for (auto channel_mode : kChannelModes) { |
| pcm_config.channelMode = channel_mode; |
| audio_config.pcmConfig(pcm_config); |
| clientif_->UpdateAudioConfig(audio_config); |
| if (IsSoftwarePcmParametersSupported(pcm_config)) { |
| EXPECT_EQ(clientif_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| EXPECT_NE(clientif_->StartSession(), kClientIfReturnSuccess); |
| } |
| EXPECT_EQ(clientif_->EndSession(), kClientIfReturnSuccess); |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
