sysbta: Updates for aosp 14 r50

Synchronize with hardware/interfaces
This commit is contained in:
Peter Cai 2024-06-15 13:23:26 -04:00
parent a7dd2aba2a
commit f3878aa7e3
15 changed files with 128 additions and 73 deletions

View file

@ -23,7 +23,8 @@ class A2dpBits {
uint8_t* data_;
public:
A2dpBits(const std::vector<uint8_t>& vector) : cdata_(vector.data()) {}
A2dpBits(const std::vector<uint8_t>& vector)
: cdata_(vector.data()), data_(nullptr) {}
A2dpBits(std::vector<uint8_t>& vector)
: cdata_(vector.data()), data_(vector.data()) {}

View file

@ -23,7 +23,6 @@
#include <android-base/logging.h>
#include "A2dpOffloadCodecAac.h"
#include "A2dpOffloadCodecFactory.h"
#include "A2dpOffloadCodecSbc.h"
namespace aidl {
@ -32,17 +31,21 @@ namespace hardware {
namespace bluetooth {
namespace audio {
A2dpOffloadEncodingAudioProvider::A2dpOffloadEncodingAudioProvider()
: A2dpOffloadAudioProvider() {
A2dpOffloadEncodingAudioProvider::A2dpOffloadEncodingAudioProvider(
const A2dpOffloadCodecFactory& codec_factory)
: A2dpOffloadAudioProvider(codec_factory) {
session_type_ = SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH;
}
A2dpOffloadDecodingAudioProvider::A2dpOffloadDecodingAudioProvider()
: A2dpOffloadAudioProvider() {
A2dpOffloadDecodingAudioProvider::A2dpOffloadDecodingAudioProvider(
const A2dpOffloadCodecFactory& codec_factory)
: A2dpOffloadAudioProvider(codec_factory) {
session_type_ = SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH;
}
A2dpOffloadAudioProvider::A2dpOffloadAudioProvider() {}
A2dpOffloadAudioProvider::A2dpOffloadAudioProvider(
const A2dpOffloadCodecFactory& codec_factory)
: codec_factory_(codec_factory) {}
bool A2dpOffloadAudioProvider::isValid(const SessionType& session_type) {
return (session_type == session_type_);
@ -56,17 +59,29 @@ ndk::ScopedAStatus A2dpOffloadAudioProvider::startSession(
auto a2dp_config = audio_config.get<AudioConfiguration::Tag::a2dp>();
A2dpStatus a2dp_status = A2dpStatus::NOT_SUPPORTED_CODEC_TYPE;
if (a2dp_config.codecId ==
A2dpOffloadCodecSbc::GetInstance()->GetCodecId()) {
SbcParameters sbc_parameters;
a2dp_status = A2dpOffloadCodecSbc::GetInstance()->ParseConfiguration(
a2dp_config.configuration, &sbc_parameters);
auto codec = codec_factory_.GetCodec(a2dp_config.codecId);
if (!codec) {
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
<< " - CodecId=" << a2dp_config.codecId.toString()
<< " is not found";
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
} else if (a2dp_config.codecId ==
A2dpOffloadCodecAac::GetInstance()->GetCodecId()) {
if (codec->info.id == CodecId(CodecId::A2dp::SBC)) {
SbcParameters sbc_parameters;
auto codec_sbc =
std::static_pointer_cast<const A2dpOffloadCodecSbc>(codec);
a2dp_status = codec_sbc->ParseConfiguration(a2dp_config.configuration,
&sbc_parameters);
} else if (codec->info.id == CodecId(CodecId::A2dp::AAC)) {
AacParameters aac_parameters;
a2dp_status = A2dpOffloadCodecAac::GetInstance()->ParseConfiguration(
a2dp_config.configuration, &aac_parameters);
auto codec_aac =
std::static_pointer_cast<const A2dpOffloadCodecAac>(codec);
a2dp_status = codec_aac->ParseConfiguration(a2dp_config.configuration,
&aac_parameters);
}
if (a2dp_status != A2dpStatus::OK) {
LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
@ -105,7 +120,13 @@ ndk::ScopedAStatus A2dpOffloadAudioProvider::onSessionReady(
ndk::ScopedAStatus A2dpOffloadAudioProvider::parseA2dpConfiguration(
const CodecId& codec_id, const std::vector<uint8_t>& configuration,
CodecParameters* codec_parameters, A2dpStatus* _aidl_return) {
auto codec = A2dpOffloadCodecFactory::GetInstance()->GetCodec(codec_id);
if (!kEnableA2dpCodecExtensibility) {
// parseA2dpConfiguration must not be implemented if A2dp codec
// extensibility is not supported.
return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_TRANSACTION);
}
auto codec = codec_factory_.GetCodec(codec_id);
if (!codec) {
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
<< " - CodecId=" << codec_id.toString() << " is not found";
@ -121,11 +142,17 @@ ndk::ScopedAStatus A2dpOffloadAudioProvider::getA2dpConfiguration(
const std::vector<A2dpRemoteCapabilities>& remote_a2dp_capabilities,
const A2dpConfigurationHint& hint,
std::optional<audio::A2dpConfiguration>* _aidl_return) {
if (!kEnableA2dpCodecExtensibility) {
// getA2dpConfiguration must not be implemented if A2dp codec
// extensibility is not supported.
return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_TRANSACTION);
}
*_aidl_return = std::nullopt;
A2dpConfiguration avdtp_configuration;
if (A2dpOffloadCodecFactory::GetInstance()->GetConfiguration(
remote_a2dp_capabilities, hint, &avdtp_configuration))
if (codec_factory_.GetConfiguration(remote_a2dp_capabilities, hint,
&avdtp_configuration))
*_aidl_return =
std::make_optional<A2dpConfiguration>(std::move(avdtp_configuration));

View file

@ -16,6 +16,7 @@
#pragma once
#include "A2dpOffloadCodecFactory.h"
#include "BluetoothAudioProvider.h"
namespace aidl {
@ -26,8 +27,6 @@ namespace audio {
class A2dpOffloadAudioProvider : public BluetoothAudioProvider {
public:
A2dpOffloadAudioProvider();
bool isValid(const SessionType& session_type) override;
ndk::ScopedAStatus startSession(
@ -45,18 +44,23 @@ class A2dpOffloadAudioProvider : public BluetoothAudioProvider {
const A2dpConfigurationHint& hint,
std::optional<audio::A2dpConfiguration>* _aidl_return) override;
protected:
A2dpOffloadAudioProvider(const A2dpOffloadCodecFactory&);
private:
const A2dpOffloadCodecFactory& codec_factory_;
ndk::ScopedAStatus onSessionReady(DataMQDesc* _aidl_return) override;
};
class A2dpOffloadEncodingAudioProvider : public A2dpOffloadAudioProvider {
public:
A2dpOffloadEncodingAudioProvider();
A2dpOffloadEncodingAudioProvider(const A2dpOffloadCodecFactory&);
};
class A2dpOffloadDecodingAudioProvider : public A2dpOffloadAudioProvider {
public:
A2dpOffloadDecodingAudioProvider();
A2dpOffloadDecodingAudioProvider(const A2dpOffloadCodecFactory&);
};
} // namespace audio

View file

@ -18,10 +18,9 @@
#include <aidl/android/hardware/bluetooth/audio/A2dpStatus.h>
#include <aidl/android/hardware/bluetooth/audio/ChannelMode.h>
#include <aidl/android/hardware/bluetooth/audio/CodecInfo.h>
#include <aidl/android/hardware/bluetooth/audio/CodecParameters.h>
#include "BluetoothAudioProviderFactory.h"
namespace aidl::android::hardware::bluetooth::audio {
class A2dpOffloadCodec {

View file

@ -194,11 +194,6 @@ static ChannelMode GetChannelModeEnum(int channel_mode) {
* AAC Class implementation
*/
const A2dpOffloadCodecAac* A2dpOffloadCodecAac::GetInstance() {
static A2dpOffloadCodecAac instance;
return &instance;
}
A2dpOffloadCodecAac::A2dpOffloadCodecAac()
: A2dpOffloadCodec(info_),
info_({.id = CodecId(CodecId::A2dp::AAC), .name = "AAC"}) {

View file

@ -29,14 +29,12 @@ struct AacParameters : public CodecParameters {
class A2dpOffloadCodecAac : public A2dpOffloadCodec {
CodecInfo info_;
A2dpOffloadCodecAac();
A2dpStatus ParseConfiguration(const std::vector<uint8_t>& configuration,
CodecParameters* codec_parameters,
AacParameters* aac_parameters) const;
public:
static const A2dpOffloadCodecAac* GetInstance();
A2dpOffloadCodecAac();
A2dpStatus ParseConfiguration(
const std::vector<uint8_t>& configuration,

View file

@ -37,20 +37,18 @@ enum : bool {
* Class implementation
*/
const A2dpOffloadCodecFactory* A2dpOffloadCodecFactory::GetInstance() {
static A2dpOffloadCodecFactory instance;
return &instance;
}
A2dpOffloadCodecFactory::A2dpOffloadCodecFactory()
: name("Offload"), codecs(ranked_codecs_) {
ranked_codecs_.reserve(kEnableAac + kEnableSbc);
if (kEnableAac) ranked_codecs_.push_back(A2dpOffloadCodecAac::GetInstance());
if (kEnableSbc) ranked_codecs_.push_back(A2dpOffloadCodecSbc::GetInstance());
if (kEnableAac)
ranked_codecs_.push_back(std::make_shared<A2dpOffloadCodecAac>());
if (kEnableSbc)
ranked_codecs_.push_back(std::make_shared<A2dpOffloadCodecSbc>());
}
const A2dpOffloadCodec* A2dpOffloadCodecFactory::GetCodec(CodecId id) const {
std::shared_ptr<const A2dpOffloadCodec> A2dpOffloadCodecFactory::GetCodec(
CodecId id) const {
auto codec = std::find_if(begin(ranked_codecs_), end(ranked_codecs_),
[&](auto c) { return id == c->info.id; });

View file

@ -16,22 +16,26 @@
#pragma once
#include <aidl/android/hardware/bluetooth/audio/A2dpConfiguration.h>
#include <aidl/android/hardware/bluetooth/audio/A2dpConfigurationHint.h>
#include <aidl/android/hardware/bluetooth/audio/A2dpRemoteCapabilities.h>
#include <memory>
#include "A2dpOffloadCodec.h"
namespace aidl::android::hardware::bluetooth::audio {
class A2dpOffloadCodecFactory {
std::vector<const A2dpOffloadCodec*> ranked_codecs_;
A2dpOffloadCodecFactory();
std::vector<std::shared_ptr<const A2dpOffloadCodec>> ranked_codecs_;
public:
const std::string name;
const std::vector<const A2dpOffloadCodec*>& codecs;
const std::vector<std::shared_ptr<const A2dpOffloadCodec>>& codecs;
static const A2dpOffloadCodecFactory* GetInstance();
A2dpOffloadCodecFactory();
const A2dpOffloadCodec* GetCodec(CodecId id) const;
std::shared_ptr<const A2dpOffloadCodec> GetCodec(CodecId id) const;
bool GetConfiguration(const std::vector<A2dpRemoteCapabilities>&,
const A2dpConfigurationHint& hint,

View file

@ -257,11 +257,6 @@ static uint8_t GetBitpool(const A2dpBits& configuration, int bitrate) {
* SBC Class implementation
*/
const A2dpOffloadCodecSbc* A2dpOffloadCodecSbc::GetInstance() {
static A2dpOffloadCodecSbc instance;
return &instance;
}
A2dpOffloadCodecSbc::A2dpOffloadCodecSbc()
: A2dpOffloadCodec(info_),
info_({.id = CodecId(CodecId::A2dp::SBC), .name = "SBC"}) {

View file

@ -33,14 +33,12 @@ struct SbcParameters : public CodecParameters {
class A2dpOffloadCodecSbc : public A2dpOffloadCodec {
CodecInfo info_;
A2dpOffloadCodecSbc();
A2dpStatus ParseConfiguration(const std::vector<uint8_t>& configuration,
CodecParameters* codec_parameters,
SbcParameters* sbc_parameters) const;
public:
static const A2dpOffloadCodecSbc* GetInstance();
A2dpOffloadCodecSbc();
A2dpStatus ParseConfiguration(
const std::vector<uint8_t>& configuration,

View file

@ -229,14 +229,17 @@ ndk::ScopedAStatus BluetoothAudioProvider::getLeAudioAseQosConfiguration(
};
ndk::ScopedAStatus BluetoothAudioProvider::getLeAudioAseDatapathConfiguration(
const ::aidl::android::hardware::bluetooth::audio::AudioContext& in_context,
const std::vector<::aidl::android::hardware::bluetooth::audio::
LeAudioConfiguration::StreamMap>& in_streamMap,
const std::optional<::aidl::android::hardware::bluetooth::audio::
IBluetoothAudioProvider::StreamConfig>&
in_sinkConfig,
const std::optional<::aidl::android::hardware::bluetooth::audio::
IBluetoothAudioProvider::StreamConfig>&
in_sourceConfig,
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
LeAudioDataPathConfigurationPair* _aidl_return) {
/* TODO: Implement */
(void)in_context;
(void)in_streamMap;
(void)in_sinkConfig;
(void)in_sourceConfig;
(void)_aidl_return;
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}

View file

@ -35,6 +35,23 @@ namespace hardware {
namespace bluetooth {
namespace audio {
/// Enable flag for the reference implementation for A2dp Codec
/// Extensibility.
///
/// A2dp Codec extensibility cannot be enabled until the following
/// requirements are fulfilled.
///
/// 1. The Bluetooth controller must support the HCI Requirements
/// v1.04 or later, and must support the vendor HCI command
/// A2DP Offload Start (v2), A2DP Offload Stop (v2) as indicated
/// by the field a2dp_offload_v2 of the vendor capabilities.
///
/// 2. The implementation of the provider must be completed with
/// DSP configuration for streaming.
enum : bool {
kEnableA2dpCodecExtensibility = false,
};
class BluetoothAudioProvider : public BnBluetoothAudioProvider {
public:
BluetoothAudioProvider();
@ -71,10 +88,12 @@ class BluetoothAudioProvider : public BnBluetoothAudioProvider {
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
LeAudioAseQosConfigurationPair* _aidl_return) override;
ndk::ScopedAStatus getLeAudioAseDatapathConfiguration(
const ::aidl::android::hardware::bluetooth::audio::AudioContext&
in_context,
const std::vector<::aidl::android::hardware::bluetooth::audio::
LeAudioConfiguration::StreamMap>& in_streamMap,
const std::optional<::aidl::android::hardware::bluetooth::audio::
IBluetoothAudioProvider::StreamConfig>&
in_sinkConfig,
const std::optional<::aidl::android::hardware::bluetooth::audio::
IBluetoothAudioProvider::StreamConfig>&
in_sourceConfig,
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
LeAudioDataPathConfigurationPair* _aidl_return) override;
ndk::ScopedAStatus onSinkAseMetadataChanged(

View file

@ -22,7 +22,6 @@
#include <android-base/logging.h>
#include "A2dpOffloadAudioProvider.h"
#include "A2dpOffloadCodecFactory.h"
#include "A2dpSoftwareAudioProvider.h"
#include "BluetoothAudioProvider.h"
#include "HearingAidAudioProvider.h"
@ -53,7 +52,8 @@ ndk::ScopedAStatus BluetoothAudioProviderFactory::openProvider(
provider = ndk::SharedRefBase::make<A2dpSoftwareEncodingAudioProvider>();
break;
case SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH:
provider = ndk::SharedRefBase::make<A2dpOffloadEncodingAudioProvider>();
provider = ndk::SharedRefBase::make<A2dpOffloadEncodingAudioProvider>(
a2dp_offload_codec_factory_);
break;
case SessionType::HEARING_AID_SOFTWARE_ENCODING_DATAPATH:
provider = ndk::SharedRefBase::make<HearingAidAudioProvider>();
@ -82,7 +82,8 @@ ndk::ScopedAStatus BluetoothAudioProviderFactory::openProvider(
provider = ndk::SharedRefBase::make<A2dpSoftwareDecodingAudioProvider>();
break;
case SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH:
provider = ndk::SharedRefBase::make<A2dpOffloadDecodingAudioProvider>();
provider = ndk::SharedRefBase::make<A2dpOffloadDecodingAudioProvider>(
a2dp_offload_codec_factory_);
break;
case SessionType::HFP_SOFTWARE_ENCODING_DATAPATH:
provider = ndk::SharedRefBase::make<HfpSoftwareOutputAudioProvider>();
@ -158,10 +159,16 @@ ndk::ScopedAStatus BluetoothAudioProviderFactory::getProviderInfo(
if (session_type == SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH ||
session_type == SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH) {
if (!kEnableA2dpCodecExtensibility) {
// Implementing getProviderInfo equates supporting
// A2dp codec extensibility.
return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_TRANSACTION);
}
auto& provider_info = _aidl_return->emplace();
provider_info.name = A2dpOffloadCodecFactory::GetInstance()->name;
for (auto codec : A2dpOffloadCodecFactory::GetInstance()->codecs)
provider_info.name = a2dp_offload_codec_factory_.name;
for (auto codec : a2dp_offload_codec_factory_.codecs)
provider_info.codecInfos.push_back(codec->info);
}

View file

@ -18,6 +18,8 @@
#include <aidl/android/hardware/bluetooth/audio/BnBluetoothAudioProviderFactory.h>
#include "A2dpOffloadCodecFactory.h"
namespace aidl {
namespace android {
namespace hardware {
@ -25,6 +27,8 @@ namespace bluetooth {
namespace audio {
class BluetoothAudioProviderFactory : public BnBluetoothAudioProviderFactory {
const A2dpOffloadCodecFactory a2dp_offload_codec_factory_;
public:
BluetoothAudioProviderFactory();

View file

@ -157,8 +157,11 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::setCodecPriority(
bool LeAudioOffloadAudioProvider::isMatchedValidCodec(CodecId cfg_codec,
CodecId req_codec) {
auto priority = codec_priority_map_.find(cfg_codec);
if (priority != codec_priority_map_.end() && priority->second == -1)
if (priority != codec_priority_map_.end() &&
priority->second ==
LeAudioOffloadAudioProvider::CODEC_PRIORITY_DISABLED) {
return false;
}
return cfg_codec == req_codec;
}
@ -222,8 +225,8 @@ bool LeAudioOffloadAudioProvider::isMatchedOctetsPerCodecFrame(
CodecSpecificConfigurationLtv::OctetsPerCodecFrame& cfg_octets,
CodecSpecificCapabilitiesLtv::SupportedOctetsPerCodecFrame&
capability_octets) {
return cfg_octets.value >= capability_octets.minimum &&
cfg_octets.value <= capability_octets.maximum;
return cfg_octets.value >= capability_octets.min &&
cfg_octets.value <= capability_octets.max;
}
bool LeAudioOffloadAudioProvider::isCapabilitiesMatchedCodecConfiguration(
@ -568,7 +571,7 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseQosConfiguration(
for (auto& setting : ase_configuration_settings) {
// Context matching
if (setting.audioContext != in_qosRequirement.contextType) continue;
if (setting.audioContext != in_qosRequirement.audioContext) continue;
// Match configuration flags
// Currently configuration flags are not populated, ignore.