978ccd40f9
On platform release T, the legacy `audio.a2dp.default` HAL no longer exists, and cannot be trivially restored for generic system-side A2DP audio support. Rather than trying to cling on to its existence (which does not even work anymore even if one did so), it is time to come up with a new solution. This commit introduces a system-side implementation of the generic bluetooth audio HAL. The HAL itself is modelled after the default bluetooth audio HAL, while substantial components of the default audio HAL are also included as it has to also implement the audio HAL interfaces. The audio HAL implementation is delegated to `audio.sysbta.default`, forked from `audio.bluetooth.default` from the Bluetooth apex package. It then communicates with the bluetooth audio HAL interfaces, which need to live in the same process (in this case, the process of the sysbta HAL). This is why we cannot just load `audio.sysbta.default` into the default audio HAL or the audioserver process directly, but rather have to include our own simplistic audio HAL implementation. For now, the audio HAL implementation only includes one for the 6.0 version, but technically, an interface for *every* audio HAL version needs to exist. This, along with other messiness in the sysbta implementation, will be addressed in a future commit. Note that to actually make use of the sysbta audio hal, patches in frameworks/av and packages/modules/Bluetooth are required to introduce support for the property `persist.bluetooth.system_audio_hal.enabled`.
416 lines
17 KiB
C++
416 lines
17 KiB
C++
/*
|
|
* Copyright 2018 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 "BTAudioProviderSessionCodecsDB"
|
|
|
|
#include "BluetoothAudioSupportedCodecsDB.h"
|
|
|
|
#include <android-base/logging.h>
|
|
|
|
namespace android {
|
|
namespace bluetooth {
|
|
namespace audio {
|
|
|
|
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::BitsPerSample;
|
|
using ::android::hardware::bluetooth::audio::V2_0::ChannelMode;
|
|
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::SampleRate;
|
|
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;
|
|
|
|
// Default Supported PCM Parameters
|
|
static const PcmParameters kDefaultSoftwarePcmCapabilities = {
|
|
.sampleRate = static_cast<SampleRate>(
|
|
SampleRate::RATE_44100 | SampleRate::RATE_48000 |
|
|
SampleRate::RATE_88200 | SampleRate::RATE_96000 |
|
|
SampleRate::RATE_16000 | SampleRate::RATE_24000),
|
|
.channelMode =
|
|
static_cast<ChannelMode>(ChannelMode::MONO | ChannelMode::STEREO),
|
|
.bitsPerSample = static_cast<BitsPerSample>(BitsPerSample::BITS_16 |
|
|
BitsPerSample::BITS_24 |
|
|
BitsPerSample::BITS_32)};
|
|
|
|
// Default Supported Codecs
|
|
// SBC: mSampleRate:(44100), mBitsPerSample:(16), mChannelMode:(MONO|STEREO)
|
|
// all blocks | subbands 8 | Loudness
|
|
static const SbcParameters kDefaultOffloadSbcCapability = {
|
|
.sampleRate = SampleRate::RATE_44100,
|
|
.channelMode = static_cast<SbcChannelMode>(SbcChannelMode::MONO |
|
|
SbcChannelMode::JOINT_STEREO),
|
|
.blockLength = static_cast<SbcBlockLength>(
|
|
SbcBlockLength::BLOCKS_4 | SbcBlockLength::BLOCKS_8 |
|
|
SbcBlockLength::BLOCKS_12 | SbcBlockLength::BLOCKS_16),
|
|
.numSubbands = SbcNumSubbands::SUBBAND_8,
|
|
.allocMethod = SbcAllocMethod::ALLOC_MD_L,
|
|
.bitsPerSample = BitsPerSample::BITS_16,
|
|
.minBitpool = 2,
|
|
.maxBitpool = 53};
|
|
|
|
// AAC: mSampleRate:(44100), mBitsPerSample:(16), mChannelMode:(STEREO)
|
|
static const AacParameters kDefaultOffloadAacCapability = {
|
|
.objectType = AacObjectType::MPEG2_LC,
|
|
.sampleRate = SampleRate::RATE_44100,
|
|
.channelMode = ChannelMode::STEREO,
|
|
.variableBitRateEnabled = AacVariableBitRate::ENABLED,
|
|
.bitsPerSample = BitsPerSample::BITS_16};
|
|
|
|
// LDAC: mSampleRate:(44100|48000|88200|96000), mBitsPerSample:(16|24|32),
|
|
// mChannelMode:(DUAL|STEREO)
|
|
static const LdacParameters kDefaultOffloadLdacCapability = {
|
|
.sampleRate = static_cast<SampleRate>(
|
|
SampleRate::RATE_44100 | SampleRate::RATE_48000 |
|
|
SampleRate::RATE_88200 | SampleRate::RATE_96000),
|
|
.channelMode = static_cast<LdacChannelMode>(LdacChannelMode::DUAL |
|
|
LdacChannelMode::STEREO),
|
|
.qualityIndex = LdacQualityIndex::QUALITY_HIGH,
|
|
.bitsPerSample = static_cast<BitsPerSample>(BitsPerSample::BITS_16 |
|
|
BitsPerSample::BITS_24 |
|
|
BitsPerSample::BITS_32)};
|
|
|
|
// aptX: mSampleRate:(44100|48000), mBitsPerSample:(16), mChannelMode:(STEREO)
|
|
static const AptxParameters kDefaultOffloadAptxCapability = {
|
|
.sampleRate = static_cast<SampleRate>(SampleRate::RATE_44100 |
|
|
SampleRate::RATE_48000),
|
|
.channelMode = ChannelMode::STEREO,
|
|
.bitsPerSample = BitsPerSample::BITS_16,
|
|
};
|
|
|
|
// aptX HD: mSampleRate:(44100|48000), mBitsPerSample:(24),
|
|
// mChannelMode:(STEREO)
|
|
static const AptxParameters kDefaultOffloadAptxHdCapability = {
|
|
.sampleRate = static_cast<SampleRate>(SampleRate::RATE_44100 |
|
|
SampleRate::RATE_48000),
|
|
.channelMode = ChannelMode::STEREO,
|
|
.bitsPerSample = BitsPerSample::BITS_24,
|
|
};
|
|
|
|
const std::vector<CodecCapabilities> kDefaultOffloadA2dpCodecCapabilities = {
|
|
{.codecType = CodecType::SBC, .capabilities = {}},
|
|
{.codecType = CodecType::AAC, .capabilities = {}},
|
|
{.codecType = CodecType::LDAC, .capabilities = {}},
|
|
{.codecType = CodecType::APTX, .capabilities = {}},
|
|
{.codecType = CodecType::APTX_HD, .capabilities = {}}};
|
|
|
|
static bool IsSingleBit(uint32_t bitmasks, uint32_t bitfield) {
|
|
bool single = false;
|
|
uint32_t test_bit = 0x00000001;
|
|
while (test_bit <= bitmasks && test_bit <= bitfield) {
|
|
if (bitfield & test_bit && bitmasks & test_bit) {
|
|
if (single) return false;
|
|
single = true;
|
|
}
|
|
if (test_bit == 0x80000000) break;
|
|
test_bit <<= 1;
|
|
}
|
|
return single;
|
|
}
|
|
|
|
static bool IsOffloadSbcConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific);
|
|
static bool IsOffloadAacConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific);
|
|
static bool IsOffloadLdacConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific);
|
|
static bool IsOffloadAptxConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific);
|
|
static bool IsOffloadAptxHdConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific);
|
|
|
|
static bool IsOffloadSbcConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific) {
|
|
if (codec_specific.getDiscriminator() !=
|
|
CodecConfiguration::CodecSpecific::hidl_discriminator::sbcConfig) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
const SbcParameters sbc_data = codec_specific.sbcConfig();
|
|
if (!IsSingleBit(static_cast<uint32_t>(sbc_data.sampleRate), 0xff) ||
|
|
!IsSingleBit(static_cast<uint32_t>(sbc_data.channelMode), 0x0f) ||
|
|
!IsSingleBit(static_cast<uint32_t>(sbc_data.blockLength), 0xf0) ||
|
|
!IsSingleBit(static_cast<uint32_t>(sbc_data.numSubbands), 0x0c) ||
|
|
!IsSingleBit(static_cast<uint32_t>(sbc_data.allocMethod), 0x03) ||
|
|
!IsSingleBit(static_cast<uint32_t>(sbc_data.bitsPerSample), 0x07) ||
|
|
sbc_data.minBitpool > sbc_data.maxBitpool) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
} else if ((sbc_data.sampleRate & kDefaultOffloadSbcCapability.sampleRate) &&
|
|
(sbc_data.channelMode &
|
|
kDefaultOffloadSbcCapability.channelMode) &&
|
|
(sbc_data.blockLength &
|
|
kDefaultOffloadSbcCapability.blockLength) &&
|
|
(sbc_data.numSubbands &
|
|
kDefaultOffloadSbcCapability.numSubbands) &&
|
|
(sbc_data.allocMethod &
|
|
kDefaultOffloadSbcCapability.allocMethod) &&
|
|
(sbc_data.bitsPerSample &
|
|
kDefaultOffloadSbcCapability.bitsPerSample) &&
|
|
(kDefaultOffloadSbcCapability.minBitpool <= sbc_data.minBitpool &&
|
|
sbc_data.maxBitpool <= kDefaultOffloadSbcCapability.maxBitpool)) {
|
|
return true;
|
|
}
|
|
LOG(WARNING) << __func__
|
|
<< ": Unsupported CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
|
|
static bool IsOffloadAacConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific) {
|
|
if (codec_specific.getDiscriminator() !=
|
|
CodecConfiguration::CodecSpecific::hidl_discriminator::aacConfig) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
const AacParameters aac_data = codec_specific.aacConfig();
|
|
if (!IsSingleBit(static_cast<uint32_t>(aac_data.objectType), 0xf0) ||
|
|
!IsSingleBit(static_cast<uint32_t>(aac_data.sampleRate), 0xff) ||
|
|
!IsSingleBit(static_cast<uint32_t>(aac_data.channelMode), 0x03) ||
|
|
!IsSingleBit(static_cast<uint32_t>(aac_data.bitsPerSample), 0x07)) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
} else if ((aac_data.objectType & kDefaultOffloadAacCapability.objectType) &&
|
|
(aac_data.sampleRate & kDefaultOffloadAacCapability.sampleRate) &&
|
|
(aac_data.channelMode &
|
|
kDefaultOffloadAacCapability.channelMode) &&
|
|
(aac_data.variableBitRateEnabled == AacVariableBitRate::DISABLED ||
|
|
kDefaultOffloadAacCapability.variableBitRateEnabled ==
|
|
AacVariableBitRate::ENABLED) &&
|
|
(aac_data.bitsPerSample &
|
|
kDefaultOffloadAacCapability.bitsPerSample)) {
|
|
return true;
|
|
}
|
|
LOG(WARNING) << __func__
|
|
<< ": Unsupported CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
|
|
static bool IsOffloadLdacConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific) {
|
|
if (codec_specific.getDiscriminator() !=
|
|
CodecConfiguration::CodecSpecific::hidl_discriminator::ldacConfig) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
const LdacParameters ldac_data = codec_specific.ldacConfig();
|
|
if (!IsSingleBit(static_cast<uint32_t>(ldac_data.sampleRate), 0xff) ||
|
|
!IsSingleBit(static_cast<uint32_t>(ldac_data.channelMode), 0x07) ||
|
|
(ldac_data.qualityIndex > LdacQualityIndex::QUALITY_LOW &&
|
|
ldac_data.qualityIndex != LdacQualityIndex::QUALITY_ABR) ||
|
|
!IsSingleBit(static_cast<uint32_t>(ldac_data.bitsPerSample), 0x07)) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
} else if ((ldac_data.sampleRate &
|
|
kDefaultOffloadLdacCapability.sampleRate) &&
|
|
(ldac_data.channelMode &
|
|
kDefaultOffloadLdacCapability.channelMode) &&
|
|
(ldac_data.bitsPerSample &
|
|
kDefaultOffloadLdacCapability.bitsPerSample)) {
|
|
return true;
|
|
}
|
|
LOG(WARNING) << __func__
|
|
<< ": Unsupported CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
|
|
static bool IsOffloadAptxConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific) {
|
|
if (codec_specific.getDiscriminator() !=
|
|
CodecConfiguration::CodecSpecific::hidl_discriminator::aptxConfig) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
const AptxParameters aptx_data = codec_specific.aptxConfig();
|
|
if (!IsSingleBit(static_cast<uint32_t>(aptx_data.sampleRate), 0xff) ||
|
|
!IsSingleBit(static_cast<uint32_t>(aptx_data.channelMode), 0x03) ||
|
|
!IsSingleBit(static_cast<uint32_t>(aptx_data.bitsPerSample), 0x07)) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
} else if ((aptx_data.sampleRate &
|
|
kDefaultOffloadAptxCapability.sampleRate) &&
|
|
(aptx_data.channelMode &
|
|
kDefaultOffloadAptxCapability.channelMode) &&
|
|
(aptx_data.bitsPerSample &
|
|
kDefaultOffloadAptxCapability.bitsPerSample)) {
|
|
return true;
|
|
}
|
|
LOG(WARNING) << __func__
|
|
<< ": Unsupported CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
|
|
static bool IsOffloadAptxHdConfigurationValid(
|
|
const CodecConfiguration::CodecSpecific& codec_specific) {
|
|
if (codec_specific.getDiscriminator() !=
|
|
CodecConfiguration::CodecSpecific::hidl_discriminator::aptxConfig) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
const AptxParameters aptx_data = codec_specific.aptxConfig();
|
|
if (!IsSingleBit(static_cast<uint32_t>(aptx_data.sampleRate), 0xff) ||
|
|
!IsSingleBit(static_cast<uint32_t>(aptx_data.channelMode), 0x03) ||
|
|
!IsSingleBit(static_cast<uint32_t>(aptx_data.bitsPerSample), 0x07)) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
} else if ((aptx_data.sampleRate &
|
|
kDefaultOffloadAptxHdCapability.sampleRate) &&
|
|
(aptx_data.channelMode &
|
|
kDefaultOffloadAptxHdCapability.channelMode) &&
|
|
(aptx_data.bitsPerSample &
|
|
kDefaultOffloadAptxHdCapability.bitsPerSample)) {
|
|
return true;
|
|
}
|
|
LOG(WARNING) << __func__
|
|
<< ": Unsupported CodecSpecific=" << toString(codec_specific);
|
|
return false;
|
|
}
|
|
|
|
std::vector<PcmParameters> GetSoftwarePcmCapabilities() {
|
|
return std::vector<PcmParameters>(1, kDefaultSoftwarePcmCapabilities);
|
|
}
|
|
|
|
std::vector<CodecCapabilities> GetOffloadCodecCapabilities(
|
|
const SessionType& session_type) {
|
|
if (session_type != SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH) {
|
|
return std::vector<CodecCapabilities>(0);
|
|
}
|
|
std::vector<CodecCapabilities> offload_a2dp_codec_capabilities =
|
|
kDefaultOffloadA2dpCodecCapabilities;
|
|
for (auto& codec_capability : offload_a2dp_codec_capabilities) {
|
|
switch (codec_capability.codecType) {
|
|
case CodecType::SBC:
|
|
codec_capability.capabilities.sbcCapabilities(
|
|
kDefaultOffloadSbcCapability);
|
|
break;
|
|
case CodecType::AAC:
|
|
codec_capability.capabilities.aacCapabilities(
|
|
kDefaultOffloadAacCapability);
|
|
break;
|
|
case CodecType::LDAC:
|
|
codec_capability.capabilities.ldacCapabilities(
|
|
kDefaultOffloadLdacCapability);
|
|
break;
|
|
case CodecType::APTX:
|
|
codec_capability.capabilities.aptxCapabilities(
|
|
kDefaultOffloadAptxCapability);
|
|
break;
|
|
case CodecType::APTX_HD:
|
|
codec_capability.capabilities.aptxCapabilities(
|
|
kDefaultOffloadAptxHdCapability);
|
|
break;
|
|
case CodecType::UNKNOWN:
|
|
codec_capability = {};
|
|
break;
|
|
}
|
|
}
|
|
return offload_a2dp_codec_capabilities;
|
|
}
|
|
|
|
bool IsSoftwarePcmConfigurationValid(const PcmParameters& pcm_config) {
|
|
if ((pcm_config.sampleRate != SampleRate::RATE_44100 &&
|
|
pcm_config.sampleRate != SampleRate::RATE_48000 &&
|
|
pcm_config.sampleRate != SampleRate::RATE_88200 &&
|
|
pcm_config.sampleRate != SampleRate::RATE_96000 &&
|
|
pcm_config.sampleRate != SampleRate::RATE_16000 &&
|
|
pcm_config.sampleRate != SampleRate::RATE_24000) ||
|
|
(pcm_config.bitsPerSample != BitsPerSample::BITS_16 &&
|
|
pcm_config.bitsPerSample != BitsPerSample::BITS_24 &&
|
|
pcm_config.bitsPerSample != BitsPerSample::BITS_32) ||
|
|
(pcm_config.channelMode != ChannelMode::MONO &&
|
|
pcm_config.channelMode != ChannelMode::STEREO)) {
|
|
LOG(WARNING) << __func__
|
|
<< ": Invalid PCM Configuration=" << toString(pcm_config);
|
|
return false;
|
|
} else if (pcm_config.sampleRate &
|
|
kDefaultSoftwarePcmCapabilities.sampleRate &&
|
|
pcm_config.bitsPerSample &
|
|
kDefaultSoftwarePcmCapabilities.bitsPerSample &&
|
|
pcm_config.channelMode &
|
|
kDefaultSoftwarePcmCapabilities.channelMode) {
|
|
return true;
|
|
}
|
|
LOG(WARNING) << __func__
|
|
<< ": Unsupported PCM Configuration=" << toString(pcm_config);
|
|
return false;
|
|
}
|
|
|
|
bool IsOffloadCodecConfigurationValid(const SessionType& session_type,
|
|
const CodecConfiguration& codec_config) {
|
|
if (session_type != SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH) {
|
|
LOG(ERROR) << __func__
|
|
<< ": Invalid SessionType=" << toString(session_type);
|
|
return false;
|
|
} else if (codec_config.encodedAudioBitrate < 0x00000001 ||
|
|
0x00ffffff < codec_config.encodedAudioBitrate) {
|
|
LOG(ERROR) << __func__ << ": Unsupported Codec Configuration="
|
|
<< toString(codec_config);
|
|
return false;
|
|
}
|
|
const CodecConfiguration::CodecSpecific& codec_specific = codec_config.config;
|
|
switch (codec_config.codecType) {
|
|
case CodecType::SBC:
|
|
if (IsOffloadSbcConfigurationValid(codec_specific)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case CodecType::AAC:
|
|
if (IsOffloadAacConfigurationValid(codec_specific)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case CodecType::LDAC:
|
|
if (IsOffloadLdacConfigurationValid(codec_specific)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case CodecType::APTX:
|
|
if (IsOffloadAptxConfigurationValid(codec_specific)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case CodecType::APTX_HD:
|
|
if (IsOffloadAptxHdConfigurationValid(codec_specific)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case CodecType::UNKNOWN:
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace audio
|
|
} // namespace bluetooth
|
|
} // namespace android
|