/*
|
* 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
|
}
|
