| /* |
| * 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. |
| */ |
| |
| #define LOG_TAG "bluetooth" |
| |
| #include <gtest/gtest.h> |
| |
| #include "client_interface.h" |
| #include "codec_status.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::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::AudioCapabilities_2_1; |
| using ::bluetooth::audio::AudioConfiguration; |
| using ::bluetooth::audio::AudioConfiguration_2_1; |
| using ::bluetooth::audio::BluetoothAudioClientInterface; |
| using ::bluetooth::audio::BluetoothAudioSinkClientInterface; |
| using ::bluetooth::audio::BluetoothAudioSourceClientInterface; |
| using ::bluetooth::audio::BluetoothAudioStatus; |
| using ::bluetooth::audio::PcmParameters; |
| using ::bluetooth::audio::PcmParameters_2_1; |
| using ::bluetooth::audio::SampleRate; |
| using ::bluetooth::audio::SampleRate_2_1; |
| using ::bluetooth::audio::SessionType; |
| using ::bluetooth::audio::SessionType_2_1; |
| using ::bluetooth::audio::codec::A2dpCodecToHalBitsPerSample; |
| using ::bluetooth::audio::codec::A2dpCodecToHalChannelMode; |
| using ::bluetooth::audio::codec::A2dpCodecToHalSampleRate; |
| using ::bluetooth::audio::codec::BitsPerSample; |
| using ::bluetooth::audio::codec::ChannelMode; |
| using ::bluetooth::audio::codec::CodecConfiguration; |
| using ::bluetooth::audio::codec::IsCodecOffloadingEnabled; |
| using ::bluetooth::audio::codec::UpdateOffloadingCapabilities; |
| using ::testing::Test; |
| |
| struct SampleRatePair { |
| SampleRate hal_sample_rate_; |
| btav_a2dp_codec_sample_rate_t btav_sample_rate_; |
| }; |
| constexpr SampleRatePair kSampleRatePairs[9] = { |
| {.hal_sample_rate_ = SampleRate::RATE_UNKNOWN, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE}, |
| {.hal_sample_rate_ = SampleRate::RATE_44100, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_44100}, |
| {.hal_sample_rate_ = SampleRate::RATE_48000, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_48000}, |
| {.hal_sample_rate_ = SampleRate::RATE_88200, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_88200}, |
| {.hal_sample_rate_ = SampleRate::RATE_96000, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_96000}, |
| {.hal_sample_rate_ = SampleRate::RATE_176400, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_176400}, |
| {.hal_sample_rate_ = SampleRate::RATE_192000, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_192000}, |
| {.hal_sample_rate_ = SampleRate::RATE_16000, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_16000}, |
| {.hal_sample_rate_ = SampleRate::RATE_24000, |
| .btav_sample_rate_ = BTAV_A2DP_CODEC_SAMPLE_RATE_24000}}; |
| |
| constexpr SampleRate_2_1 kSampleRates_2_1[] = { |
| SampleRate_2_1::RATE_UNKNOWN, SampleRate_2_1::RATE_8000, |
| SampleRate_2_1::RATE_16000, SampleRate_2_1::RATE_24000, |
| SampleRate_2_1::RATE_32000, SampleRate_2_1::RATE_44100, |
| SampleRate_2_1::RATE_48000}; |
| |
| constexpr uint32_t kDataIntervalUs[] = {0 /* Invalid */, |
| 10000 /* Valid 10ms */}; |
| |
| struct BitsPerSamplePair { |
| BitsPerSample hal_bits_per_sample_; |
| btav_a2dp_codec_bits_per_sample_t btav_bits_per_sample_; |
| }; |
| constexpr BitsPerSamplePair kBitsPerSamplePairs[4] = { |
| {.hal_bits_per_sample_ = BitsPerSample::BITS_UNKNOWN, |
| .btav_bits_per_sample_ = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE}, |
| {.hal_bits_per_sample_ = BitsPerSample::BITS_16, |
| .btav_bits_per_sample_ = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16}, |
| {.hal_bits_per_sample_ = BitsPerSample::BITS_24, |
| .btav_bits_per_sample_ = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24}, |
| {.hal_bits_per_sample_ = BitsPerSample::BITS_32, |
| .btav_bits_per_sample_ = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32}}; |
| |
| struct ChannelModePair { |
| ChannelMode hal_channel_mode_; |
| btav_a2dp_codec_channel_mode_t btav_channel_mode_; |
| }; |
| constexpr ChannelModePair kChannelModePairs[3] = { |
| {.hal_channel_mode_ = ChannelMode::UNKNOWN, |
| .btav_channel_mode_ = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE}, |
| {.hal_channel_mode_ = ChannelMode::MONO, |
| .btav_channel_mode_ = BTAV_A2DP_CODEC_CHANNEL_MODE_MONO}, |
| {.hal_channel_mode_ = ChannelMode::STEREO, |
| .btav_channel_mode_ = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO}}; |
| |
| constexpr btav_a2dp_codec_index_t codec_indexes[] = { |
| BTAV_A2DP_CODEC_INDEX_SOURCE_SBC, BTAV_A2DP_CODEC_INDEX_SOURCE_AAC, |
| BTAV_A2DP_CODEC_INDEX_SOURCE_APTX, BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD, |
| BTAV_A2DP_CODEC_INDEX_SOURCE_LDAC, BTAV_A2DP_CODEC_INDEX_SINK_SBC, |
| BTAV_A2DP_CODEC_INDEX_SINK_AAC, BTAV_A2DP_CODEC_INDEX_SINK_LDAC}; |
| constexpr uint16_t kPeerMtus[5] = {660, 663, 883, 1005, 1500}; |
| |
| class TestSinkTransport |
| : public bluetooth::audio::IBluetoothSinkTransportInstance { |
| private: |
| static constexpr uint64_t kRemoteDelayReportMs = 200; |
| |
| public: |
| TestSinkTransport(SessionType session_type) |
| : bluetooth::audio::IBluetoothSinkTransportInstance(session_type, {}){}; |
| TestSinkTransport(SessionType_2_1 session_type_2_1) |
| : bluetooth::audio::IBluetoothSinkTransportInstance(session_type_2_1, |
| {}){}; |
| bluetooth::audio::BluetoothAudioCtrlAck StartRequest() override { |
| return bluetooth::audio::BluetoothAudioCtrlAck::SUCCESS_FINISHED; |
| } |
| bluetooth::audio::BluetoothAudioCtrlAck SuspendRequest() override { |
| return bluetooth::audio::BluetoothAudioCtrlAck::SUCCESS_FINISHED; |
| } |
| void StopRequest() override {} |
| bool GetPresentationPosition(uint64_t* remote_delay_report_ns, |
| uint64_t* total_bytes_readed, |
| timespec* data_position) override { |
| 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) override {} |
| void ResetPresentationPosition() override{}; |
| void LogBytesRead(size_t bytes_readed __unused) override{}; |
| }; |
| |
| class TestSourceTransport |
| : public bluetooth::audio::IBluetoothSourceTransportInstance { |
| private: |
| static constexpr uint64_t kRemoteDelayReportMs = 200; |
| |
| public: |
| TestSourceTransport(SessionType session_type) |
| : bluetooth::audio::IBluetoothSourceTransportInstance(session_type, {}){}; |
| TestSourceTransport(SessionType_2_1 session_type_2_1) |
| : bluetooth::audio::IBluetoothSourceTransportInstance(session_type_2_1, |
| {}){}; |
| bluetooth::audio::BluetoothAudioCtrlAck StartRequest() override { |
| return bluetooth::audio::BluetoothAudioCtrlAck::SUCCESS_FINISHED; |
| } |
| bluetooth::audio::BluetoothAudioCtrlAck SuspendRequest() override { |
| return bluetooth::audio::BluetoothAudioCtrlAck::SUCCESS_FINISHED; |
| } |
| void StopRequest() override {} |
| bool GetPresentationPosition(uint64_t* remote_delay_report_ns, |
| uint64_t* total_bytes_written, |
| timespec* data_position) override { |
| if (remote_delay_report_ns) { |
| *remote_delay_report_ns = kRemoteDelayReportMs * 1000000; |
| } |
| if (total_bytes_written) { |
| *total_bytes_written = 0; |
| } |
| if (data_position) { |
| clock_gettime(CLOCK_MONOTONIC, data_position); |
| } |
| return true; |
| } |
| void MetadataChanged( |
| const source_metadata_t& source_metadata __unused) override {} |
| void ResetPresentationPosition() override{}; |
| void LogBytesWritten(size_t bytes_written __unused) override{}; |
| }; |
| |
| class BluetoothAudioClientInterfaceTest : public Test { |
| protected: |
| TestSinkTransport* test_sink_transport_ = nullptr; |
| TestSourceTransport* test_source_transport_ = nullptr; |
| BluetoothAudioSinkClientInterface* clientif_sink_ = nullptr; |
| BluetoothAudioSourceClientInterface* clientif_source_ = nullptr; |
| |
| static constexpr int kClientIfReturnSuccess = 0; |
| |
| void SetUp() override {} |
| |
| void TearDown() override { |
| if (clientif_sink_ != nullptr) delete clientif_sink_; |
| clientif_sink_ = nullptr; |
| if (test_sink_transport_ != nullptr) delete test_sink_transport_; |
| test_sink_transport_ = nullptr; |
| |
| if (clientif_source_ != nullptr) delete clientif_source_; |
| clientif_source_ = nullptr; |
| if (test_source_transport_ != nullptr) delete test_source_transport_; |
| test_source_transport_ = nullptr; |
| } |
| |
| bool IsSoftwarePcmParametersSupported(const PcmParameters& pcm_config) { |
| const std::vector<AudioCapabilities>& capabilities = |
| clientif_sink_->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 IsSinkSoftwarePcmParameters_2_1_Supported( |
| const PcmParameters_2_1& pcm_config) { |
| return IsSoftwarePcmParameters_2_1_Supported(pcm_config, clientif_sink_); |
| } |
| |
| bool IsSourceSoftwarePcmParameters_2_1_Supported( |
| const PcmParameters_2_1& pcm_config) { |
| return IsSoftwarePcmParameters_2_1_Supported(pcm_config, clientif_source_); |
| } |
| |
| bool IsCodecOffloadingSupported(const CodecConfiguration& codec_config) { |
| CodecCapabilities codec_capability = {}; |
| for (auto audio_capability : clientif_sink_->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; |
| } |
| } |
| |
| private: |
| bool IsSoftwarePcmParameters_2_1_Supported( |
| const PcmParameters_2_1& pcm_config, |
| const BluetoothAudioClientInterface* clientif_) { |
| const std::vector<AudioCapabilities_2_1>& capabilities = |
| clientif_->GetAudioCapabilities_2_1(); |
| PcmParameters_2_1 pcm_capabilities = capabilities[0].pcmCapabilities(); |
| bool is_pcm_config_valid = |
| (pcm_config.sampleRate != SampleRate_2_1::RATE_UNKNOWN && |
| pcm_config.bitsPerSample != BitsPerSample::BITS_UNKNOWN && |
| pcm_config.channelMode != ChannelMode::UNKNOWN && |
| pcm_config.dataIntervalUs != 0); |
| 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); |
| } |
| }; |
| |
| } // namespace |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, A2dpCodecToHalPcmConfig) { |
| btav_a2dp_codec_config_t a2dp_codec_config = {}; |
| for (auto sample_rate_pair : kSampleRatePairs) { |
| a2dp_codec_config.sample_rate = sample_rate_pair.btav_sample_rate_; |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| a2dp_codec_config.bits_per_sample = |
| bits_per_sample_pair.btav_bits_per_sample_; |
| for (auto channel_mode_pair : kChannelModePairs) { |
| a2dp_codec_config.channel_mode = channel_mode_pair.btav_channel_mode_; |
| ASSERT_EQ(A2dpCodecToHalSampleRate(a2dp_codec_config), |
| sample_rate_pair.hal_sample_rate_); |
| ASSERT_EQ(A2dpCodecToHalBitsPerSample(a2dp_codec_config), |
| bits_per_sample_pair.hal_bits_per_sample_); |
| ASSERT_EQ(A2dpCodecToHalChannelMode(a2dp_codec_config), |
| channel_mode_pair.hal_channel_mode_); |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpSoftwareSession) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_SOFTWARE_ENCODING_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| PcmParameters pcm_config = {}; |
| for (auto sample_rate_pair : kSampleRatePairs) { |
| pcm_config.sampleRate = sample_rate_pair.hal_sample_rate_; |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| pcm_config.bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_; |
| for (auto channel_mode_pair : kChannelModePairs) { |
| pcm_config.channelMode = channel_mode_pair.hal_channel_mode_; |
| audio_config.pcmConfig(pcm_config); |
| clientif_sink_->UpdateAudioConfig(audio_config); |
| if (IsSoftwarePcmParametersSupported(pcm_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| struct CodecOffloadingPreference { |
| bool is_target_codec_included_; |
| std::vector<btav_a2dp_codec_config_t> preference_; |
| }; |
| |
| std::vector<CodecOffloadingPreference> CodecOffloadingPreferenceGenerator( |
| btav_a2dp_codec_index_t target_codec_index) { |
| std::vector<CodecOffloadingPreference> codec_offloading_preferences = { |
| {.is_target_codec_included_ = false, |
| .preference_ = std::vector<btav_a2dp_codec_config_t>(0)}}; |
| btav_a2dp_codec_config_t a2dp_codec_config = {}; |
| for (auto codec_index : codec_indexes) { |
| a2dp_codec_config.codec_type = codec_index; |
| auto duplicated_preferences = codec_offloading_preferences; |
| for (auto iter = duplicated_preferences.begin(); |
| iter != duplicated_preferences.end(); ++iter) { |
| if (codec_index == target_codec_index) { |
| iter->is_target_codec_included_ = true; |
| } |
| iter->preference_.push_back(a2dp_codec_config); |
| } |
| codec_offloading_preferences.insert(codec_offloading_preferences.end(), |
| duplicated_preferences.begin(), |
| duplicated_preferences.end()); |
| } |
| return codec_offloading_preferences; |
| } |
| |
| std::vector<CodecConfiguration> SbcCodecConfigurationsGenerator() { |
| std::vector<CodecConfiguration> sbc_codec_configs; |
| 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_pair : kSampleRatePairs) { |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| for (auto channel_mode_pair : kChannelModePairs) { |
| 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_pair.hal_sample_rate_, |
| .channelMode = (channel_mode_pair.hal_channel_mode_ == |
| ChannelMode::MONO |
| ? SbcChannelMode::MONO |
| : SbcChannelMode::JOINT_STEREO), |
| .blockLength = block_length, |
| .numSubbands = num_subband, |
| .allocMethod = alloc_method, |
| .bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_, |
| .minBitpool = 2, |
| .maxBitpool = 53}; |
| codec_config.config.sbcConfig(sbc); |
| sbc_codec_configs.push_back(codec_config); |
| } // SbcAllocMethod |
| } // SbcNumSubbands |
| } // SbcBlockLength |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| return sbc_codec_configs; |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, A2dpSbcCodecOffloadingState) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| auto sbc_codec_configs = SbcCodecConfigurationsGenerator(); |
| for (auto codec_offloading_preference : |
| CodecOffloadingPreferenceGenerator(BTAV_A2DP_CODEC_INDEX_SOURCE_SBC)) { |
| UpdateOffloadingCapabilities(codec_offloading_preference.preference_); |
| for (CodecConfiguration codec_config : sbc_codec_configs) { |
| if (IsCodecOffloadingSupported(codec_config) && |
| codec_offloading_preference.is_target_codec_included_) { |
| ASSERT_TRUE(IsCodecOffloadingEnabled(codec_config)); |
| } else { |
| ASSERT_FALSE(IsCodecOffloadingEnabled(codec_config)); |
| } |
| } |
| } |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadSbcSession) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| for (CodecConfiguration codec_config : SbcCodecConfigurationsGenerator()) { |
| audio_config.codecConfig(codec_config); |
| clientif_sink_->UpdateAudioConfig(audio_config); |
| if (IsCodecOffloadingSupported(codec_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } |
| } |
| |
| std::vector<CodecConfiguration> AacCodecConfigurationsGenerator() { |
| std::vector<CodecConfiguration> aac_codec_configs; |
| 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_pair : kSampleRatePairs) { |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| for (auto channel_mode_pair : kChannelModePairs) { |
| 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_pair.hal_sample_rate_, |
| .channelMode = channel_mode_pair.hal_channel_mode_, |
| .variableBitRateEnabled = variable_bitrate, |
| .bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_}; |
| codec_config.config.aacConfig(aac); |
| aac_codec_configs.push_back(codec_config); |
| } // AacVariableBitRate |
| } // AacObjectType |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| return aac_codec_configs; |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, A2dpAacCodecOffloadingState) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| auto aac_codec_configs = AacCodecConfigurationsGenerator(); |
| for (auto codec_offloading_preference : |
| CodecOffloadingPreferenceGenerator(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC)) { |
| UpdateOffloadingCapabilities(codec_offloading_preference.preference_); |
| for (CodecConfiguration codec_config : aac_codec_configs) { |
| if (IsCodecOffloadingSupported(codec_config) && |
| codec_offloading_preference.is_target_codec_included_) { |
| ASSERT_TRUE(IsCodecOffloadingEnabled(codec_config)); |
| } else { |
| ASSERT_FALSE(IsCodecOffloadingEnabled(codec_config)); |
| } |
| } |
| } |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadAacSession) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| for (CodecConfiguration codec_config : AacCodecConfigurationsGenerator()) { |
| audio_config.codecConfig(codec_config); |
| clientif_sink_->UpdateAudioConfig(audio_config); |
| if (IsCodecOffloadingSupported(codec_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } |
| } |
| |
| std::vector<CodecConfiguration> LdacCodecConfigurationsGenerator() { |
| std::vector<CodecConfiguration> ldac_codec_configs; |
| CodecConfiguration codec_config = {}; |
| LdacQualityIndex quality_indexes[4] = { |
| LdacQualityIndex::QUALITY_HIGH, LdacQualityIndex::QUALITY_MID, |
| LdacQualityIndex::QUALITY_LOW, LdacQualityIndex::QUALITY_ABR}; |
| for (auto sample_rate_pair : kSampleRatePairs) { |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| for (auto channel_mode_pair : kChannelModePairs) { |
| 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_pair.hal_sample_rate_, |
| .channelMode = |
| (channel_mode_pair.hal_channel_mode_ == ChannelMode::MONO |
| ? LdacChannelMode::MONO |
| : LdacChannelMode::STEREO), |
| .qualityIndex = quality_index, |
| .bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_}; |
| codec_config.config.ldacConfig(ldac); |
| ldac_codec_configs.push_back(codec_config); |
| } // LdacQualityIndex |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| return ldac_codec_configs; |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, A2dpLdacCodecOffloadingState) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| auto ldac_codec_configs = LdacCodecConfigurationsGenerator(); |
| for (auto codec_offloading_preference : |
| CodecOffloadingPreferenceGenerator(BTAV_A2DP_CODEC_INDEX_SOURCE_LDAC)) { |
| UpdateOffloadingCapabilities(codec_offloading_preference.preference_); |
| for (CodecConfiguration codec_config : ldac_codec_configs) { |
| if (IsCodecOffloadingSupported(codec_config) && |
| codec_offloading_preference.is_target_codec_included_) { |
| ASSERT_TRUE(IsCodecOffloadingEnabled(codec_config)); |
| } else { |
| ASSERT_FALSE(IsCodecOffloadingEnabled(codec_config)); |
| } |
| } |
| } |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadLdacSession) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| for (CodecConfiguration codec_config : LdacCodecConfigurationsGenerator()) { |
| audio_config.codecConfig(codec_config); |
| clientif_sink_->UpdateAudioConfig(audio_config); |
| if (IsCodecOffloadingSupported(codec_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } |
| } |
| |
| std::vector<CodecConfiguration> AptxCodecConfigurationsGenerator( |
| CodecType codec_type) { |
| std::vector<CodecConfiguration> aptx_codec_configs; |
| if (codec_type != CodecType::APTX && codec_type != CodecType::APTX_HD) |
| return aptx_codec_configs; |
| CodecConfiguration codec_config = {}; |
| for (auto sample_rate_pair : kSampleRatePairs) { |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| for (auto channel_mode_pair : kChannelModePairs) { |
| for (auto peer_mtu : kPeerMtus) { |
| codec_config.codecType = codec_type; |
| codec_config.peerMtu = peer_mtu; |
| codec_config.isScmstEnabled = false; |
| codec_config.encodedAudioBitrate = |
| (codec_type == CodecType::APTX ? 352000 : 576000); |
| AptxParameters aptx = { |
| .sampleRate = sample_rate_pair.hal_sample_rate_, |
| .channelMode = channel_mode_pair.hal_channel_mode_, |
| .bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_}; |
| codec_config.config.aptxConfig(aptx); |
| aptx_codec_configs.push_back(codec_config); |
| } // peerMtu |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| return aptx_codec_configs; |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, A2dpAptxCodecOffloadingState) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| auto aptx_codec_configs = AptxCodecConfigurationsGenerator(CodecType::APTX); |
| for (auto codec_offloading_preference : |
| CodecOffloadingPreferenceGenerator(BTAV_A2DP_CODEC_INDEX_SOURCE_APTX)) { |
| UpdateOffloadingCapabilities(codec_offloading_preference.preference_); |
| for (CodecConfiguration codec_config : aptx_codec_configs) { |
| if (IsCodecOffloadingSupported(codec_config) && |
| codec_offloading_preference.is_target_codec_included_) { |
| ASSERT_TRUE(IsCodecOffloadingEnabled(codec_config)); |
| } else { |
| ASSERT_FALSE(IsCodecOffloadingEnabled(codec_config)); |
| } |
| } |
| } |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadAptxSession) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| for (CodecConfiguration codec_config : |
| AptxCodecConfigurationsGenerator(CodecType::APTX)) { |
| audio_config.codecConfig(codec_config); |
| clientif_sink_->UpdateAudioConfig(audio_config); |
| if (IsCodecOffloadingSupported(codec_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, A2dpAptxHdCodecOffloadingState) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| auto aptx_hd_codec_configs = |
| AptxCodecConfigurationsGenerator(CodecType::APTX_HD); |
| for (auto codec_offloading_preference : CodecOffloadingPreferenceGenerator( |
| BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD)) { |
| UpdateOffloadingCapabilities(codec_offloading_preference.preference_); |
| for (CodecConfiguration codec_config : aptx_hd_codec_configs) { |
| if (IsCodecOffloadingSupported(codec_config) && |
| codec_offloading_preference.is_target_codec_included_) { |
| ASSERT_TRUE(IsCodecOffloadingEnabled(codec_config)); |
| } else { |
| ASSERT_FALSE(IsCodecOffloadingEnabled(codec_config)); |
| } |
| } |
| } |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, StartAndEndA2dpOffloadAptxHdSession) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| for (CodecConfiguration codec_config : |
| AptxCodecConfigurationsGenerator(CodecType::APTX_HD)) { |
| audio_config.codecConfig(codec_config); |
| clientif_sink_->UpdateAudioConfig(audio_config); |
| if (IsCodecOffloadingSupported(codec_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, |
| StartAndEndA2dpOffloadUnknownSession) { |
| test_sink_transport_ = |
| new TestSinkTransport(SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_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_sink_->UpdateAudioConfig(audio_config); |
| if (IsCodecOffloadingSupported(codec_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, |
| StartAndEndHearingAidSoftwareSession) { |
| test_sink_transport_ = new TestSinkTransport( |
| SessionType::HEARING_AID_SOFTWARE_ENCODING_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration audio_config = {}; |
| PcmParameters pcm_config = {}; |
| for (auto sample_rate_pair : kSampleRatePairs) { |
| pcm_config.sampleRate = sample_rate_pair.hal_sample_rate_; |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| pcm_config.bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_; |
| for (auto channel_mode_pair : kChannelModePairs) { |
| pcm_config.channelMode = channel_mode_pair.hal_channel_mode_; |
| audio_config.pcmConfig(pcm_config); |
| clientif_sink_->UpdateAudioConfig(audio_config); |
| if (IsSoftwarePcmParametersSupported(pcm_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession(), kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, |
| StartAndEndLeAudioEncodingSoftwareSession) { |
| test_sink_transport_ = new TestSinkTransport( |
| SessionType_2_1::LE_AUDIO_SOFTWARE_ENCODING_DATAPATH); |
| clientif_sink_ = |
| new BluetoothAudioSinkClientInterface(test_sink_transport_, nullptr); |
| AudioConfiguration_2_1 audio_config = {}; |
| PcmParameters_2_1 pcm_config = {}; |
| for (auto sample_rate : kSampleRates_2_1) { |
| pcm_config.sampleRate = sample_rate; |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| pcm_config.bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_; |
| for (auto channel_mode_pair : kChannelModePairs) { |
| pcm_config.channelMode = channel_mode_pair.hal_channel_mode_; |
| for (auto data_interval_us : kDataIntervalUs) { |
| pcm_config.dataIntervalUs = data_interval_us; |
| audio_config.pcmConfig(pcm_config); |
| clientif_sink_->UpdateAudioConfig_2_1(audio_config); |
| if (IsSinkSoftwarePcmParameters_2_1_Supported(pcm_config)) { |
| ASSERT_EQ(clientif_sink_->StartSession_2_1(), |
| kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_sink_->StartSession_2_1(), |
| kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_sink_->EndSession(), kClientIfReturnSuccess); |
| } // dataIntervalUs |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
| |
| TEST_F(BluetoothAudioClientInterfaceTest, |
| StartAndEndLeAudioDecodedSoftwareSession) { |
| test_source_transport_ = new TestSourceTransport( |
| SessionType_2_1::LE_AUDIO_SOFTWARE_DECODED_DATAPATH); |
| clientif_source_ = |
| new BluetoothAudioSourceClientInterface(test_source_transport_, nullptr); |
| AudioConfiguration_2_1 audio_config = {}; |
| PcmParameters_2_1 pcm_config = {}; |
| for (auto sample_rate : kSampleRates_2_1) { |
| pcm_config.sampleRate = sample_rate; |
| for (auto bits_per_sample_pair : kBitsPerSamplePairs) { |
| pcm_config.bitsPerSample = bits_per_sample_pair.hal_bits_per_sample_; |
| for (auto channel_mode_pair : kChannelModePairs) { |
| pcm_config.channelMode = channel_mode_pair.hal_channel_mode_; |
| for (auto data_interval_us : kDataIntervalUs) { |
| pcm_config.dataIntervalUs = data_interval_us; |
| audio_config.pcmConfig(pcm_config); |
| clientif_source_->UpdateAudioConfig_2_1(audio_config); |
| if (IsSourceSoftwarePcmParameters_2_1_Supported(pcm_config)) { |
| ASSERT_EQ(clientif_source_->StartSession_2_1(), |
| kClientIfReturnSuccess); |
| } else { |
| ASSERT_NE(clientif_source_->StartSession_2_1(), |
| kClientIfReturnSuccess); |
| } |
| ASSERT_EQ(clientif_source_->EndSession(), kClientIfReturnSuccess); |
| } // dataIntervalUs |
| } // ChannelMode |
| } // BitsPerSampple |
| } // SampleRate |
| } |
