Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "BtAudio: Improve LE offload compatability" am: 62ae860671

Browse Source 
Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/1955933

Change-Id: I1217377214ad50425fe44734d185dd69a5aecd7e
This commit is contained in:
Treehugger Robot
2022-01-24 04:24:28 +00:00
committed by Automerger Merge Worker
parent 0bda60d835 62ae860671
commit ac87b223ff
6 changed files with 66 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.cpp
View File

@@ -78,7 +78,7 @@ static const AptxCapabilities kDefaultOffloadAptxHdCapability = {
.bitsPerSample = {24},
};
static const Lc3Capabilities kDefaultOffloadLc3Capability = {
static const Lc3Capabilities kDefaultA2dpOffloadLc3Capability = {
.samplingFrequencyHz = {44100, 48000},
.frameDurationUs = {7500, 10000},
.channelMode = {ChannelMode::MONO, ChannelMode::STEREO},
@@ -285,11 +285,11 @@ bool BluetoothAudioCodecs::IsOffloadLc3ConfigurationValid(
const Lc3Configuration lc3_data =
codec_specific.get<CodecConfiguration::CodecSpecific::lc3Config>();
if (ContainedInVector(kDefaultOffloadLc3Capability.samplingFrequencyHz,
if (ContainedInVector(kDefaultA2dpOffloadLc3Capability.samplingFrequencyHz,
lc3_data.samplingFrequencyHz) &&
ContainedInVector(kDefaultOffloadLc3Capability.frameDurationUs,
ContainedInVector(kDefaultA2dpOffloadLc3Capability.frameDurationUs,
lc3_data.frameDurationUs) &&
ContainedInVector(kDefaultOffloadLc3Capability.channelMode,
ContainedInVector(kDefaultA2dpOffloadLc3Capability.channelMode,
lc3_data.channelMode)) {
return true;
}
@@ -352,7 +352,7 @@ BluetoothAudioCodecs::GetA2dpOffloadCodecCapabilities(
case CodecType::LC3:
codec_capability.capabilities
.set<CodecCapabilities::Capabilities::lc3Capabilities>(
kDefaultOffloadLc3Capability);
kDefaultA2dpOffloadLc3Capability);
break;
case CodecType::UNKNOWN:
case CodecType::VENDOR:

8
bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.h
View File

@@ -45,11 +45,7 @@ class BluetoothAudioCodecs {
const SessionType& session_type, const CodecConfiguration& codec_config);
static bool IsOffloadLeAudioConfigurationValid(
const SessionType& session_type, const Lc3Configuration& codec_config);
static bool IsOffloadLeAudioConfigurationValid(
const SessionType& session_type,
const LeAudioConfiguration& codec_config);
const SessionType& session_type, const LeAudioConfiguration&);
static std::vector<LeAudioCodecCapabilitiesSetting>
GetLeAudioOffloadCodecCapabilities(const SessionType& session_type);
@@ -77,8 +73,6 @@ class BluetoothAudioCodecs {
const CodecConfiguration::CodecSpecific& codec_specific);
static bool IsOffloadLc3ConfigurationValid(
const CodecConfiguration::CodecSpecific& codec_specific);
static bool IsOffloadLeAudioConfigurationValid(
const SessionType& session_type, const LeAudioCodecConfiguration&);
};
} // namespace audio

42
bluetooth/audio/utils/aidl_session/BluetoothAudioSession.cpp
View File

@@ -35,22 +35,8 @@ static constexpr int kFmqReceiveTimeoutMs =
static constexpr int kWritePollMs = 1; // polled non-blocking interval
static constexpr int kReadPollMs = 1; // polled non-blocking interval
const CodecConfiguration BluetoothAudioSession::kInvalidCodecConfiguration = {};
const LeAudioConfiguration kInvalidLeAudioConfiguration = {};
AudioConfiguration BluetoothAudioSession::invalidSoftwareAudioConfiguration =
{};
AudioConfiguration BluetoothAudioSession::invalidOffloadAudioConfiguration = {};
AudioConfiguration BluetoothAudioSession::invalidLeOffloadAudioConfig = {};
BluetoothAudioSession::BluetoothAudioSession(const SessionType& session_type)
: session_type_(session_type), stack_iface_(nullptr), data_mq_(nullptr) {
invalidSoftwareAudioConfiguration.set<AudioConfiguration::pcmConfig>(
kInvalidPcmConfiguration);
invalidOffloadAudioConfiguration.set<AudioConfiguration::a2dpConfig>(
kInvalidCodecConfiguration);
invalidLeOffloadAudioConfig.set<AudioConfiguration::leAudioConfig>(
kInvalidLeAudioConfiguration);
}
: session_type_(session_type), stack_iface_(nullptr), data_mq_(nullptr) {}
/***
*
@@ -72,13 +58,7 @@ void BluetoothAudioSession::OnSessionStarted(
} else if (!UpdateDataPath(mq_desc)) {
LOG(ERROR) << __func__ << " - SessionType=" << toString(session_type_)
<< " MqDescriptor Invalid";
if (session_type_ == SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH) {
audio_config_ = std::make_unique<AudioConfiguration>(
invalidOffloadAudioConfiguration);
} else {
audio_config_ = std::make_unique<AudioConfiguration>(
invalidSoftwareAudioConfiguration);
}
audio_config_ = nullptr;
} else {
stack_iface_ = stack_iface;
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
@@ -91,13 +71,7 @@ void BluetoothAudioSession::OnSessionEnded() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
bool toggled = IsSessionReady();
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_);
if (session_type_ == SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH) {
audio_config_ =
std::make_unique<AudioConfiguration>(invalidOffloadAudioConfiguration);
} else {
audio_config_ =
std::make_unique<AudioConfiguration>(invalidSoftwareAudioConfiguration);
}
audio_config_ = nullptr;
stack_iface_ = nullptr;
UpdateDataPath(nullptr);
if (toggled) {
@@ -111,17 +85,17 @@ void BluetoothAudioSession::OnSessionEnded() {
*
***/
const AudioConfiguration& BluetoothAudioSession::GetAudioConfig() {
const AudioConfiguration BluetoothAudioSession::GetAudioConfig() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
if (!IsSessionReady()) {
switch (session_type_) {
case SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH:
return invalidOffloadAudioConfiguration;
return AudioConfiguration(CodecConfiguration{});
case SessionType::LE_AUDIO_HARDWARE_OFFLOAD_ENCODING_DATAPATH:
case SessionType::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH:
return invalidLeOffloadAudioConfig;
return AudioConfiguration(LeAudioConfiguration{});
default:
return invalidSoftwareAudioConfiguration;
return AudioConfiguration(PcmConfiguration{});
}
}
return *audio_config_;
@@ -164,7 +138,7 @@ bool BluetoothAudioSession::IsSessionReady() {
session_type_ ==
SessionType::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH ||
(data_mq_ != nullptr && data_mq_->isValid()));
return stack_iface_ != nullptr && is_mq_valid;
return stack_iface_ != nullptr && is_mq_valid && audio_config_ != nullptr;
}
/***

10
bluetooth/audio/utils/aidl_session/BluetoothAudioSession.h
View File

@@ -144,7 +144,7 @@ class BluetoothAudioSession {
* The control function is for the bluetooth_audio module to get the current
* AudioConfiguration
***/
const AudioConfiguration& GetAudioConfig();
const AudioConfiguration GetAudioConfig();
/***
* The report function is used to report that the Bluetooth stack has notified
@@ -173,14 +173,6 @@ class BluetoothAudioSession {
// Return if IBluetoothAudioProviderFactory implementation existed
static bool IsAidlAvailable();
static constexpr PcmConfiguration kInvalidPcmConfiguration = {};
// can't be constexpr because of non-literal type
static const CodecConfiguration kInvalidCodecConfiguration;
static AudioConfiguration invalidSoftwareAudioConfiguration;
static AudioConfiguration invalidOffloadAudioConfiguration;
static AudioConfiguration invalidLeOffloadAudioConfig;
private:
// using recursive_mutex to allow hwbinder to re-enter again.
std::recursive_mutex mutex_;

14
bluetooth/audio/utils/aidl_session/BluetoothAudioSessionControl.h
View File

@@ -79,11 +79,15 @@ class BluetoothAudioSessionControl {
BluetoothAudioSessionInstance::GetSessionInstance(session_type);
if (session_ptr != nullptr) {
return session_ptr->GetAudioConfig();
} else if (session_type ==
SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH) {
return BluetoothAudioSession::invalidOffloadAudioConfiguration;
} else {
return BluetoothAudioSession::invalidSoftwareAudioConfiguration;
}
switch (session_type) {
case SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH:
return AudioConfiguration(CodecConfiguration{});
case SessionType::LE_AUDIO_HARDWARE_OFFLOAD_ENCODING_DATAPATH:
case SessionType::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH:
return AudioConfiguration(LeAudioConfiguration{});
default:
return AudioConfiguration(PcmConfiguration{});
}
}

62
bluetooth/audio/utils/aidl_session/HidlToAidlMiddleware.cpp
View File

@@ -201,13 +201,6 @@ const static std::unordered_map<LdacQualityIndex, LdacQualityIndex_2_0>
{LdacQualityIndex::ABR, LdacQualityIndex_2_0::QUALITY_ABR},
};
const static std::unordered_map<LeAudioMode, LeAudioMode_2_2>
leaudio_mode_to_hidl_map{
{LeAudioMode::UNKNOWN, LeAudioMode_2_2::UNKNOWN},
{LeAudioMode::UNICAST, LeAudioMode_2_2::UNICAST},
{LeAudioMode::BROADCAST, LeAudioMode_2_2::BROADCAST},
};
inline SessionType from_session_type_2_1(
const SessionType_2_1& session_type_hidl) {
auto it = session_type_2_1_to_aidl_map.find(session_type_hidl);
@@ -437,18 +430,49 @@ inline Lc3Config_2_1 to_hidl_lc3_config_2_1(
inline Lc3CodecConfig_2_1 to_hidl_leaudio_config_2_1(
const LeAudioConfiguration& leaudio_config) {
auto& unicast_config =
leaudio_config.modeConfig
.get<LeAudioConfiguration::LeAudioModeConfig::unicastConfig>();
Lc3CodecConfig_2_1 hidl_lc3_codec_config = {
.audioChannelAllocation = 0,
};
if (leaudio_config.modeConfig.getTag() ==
LeAudioConfiguration::LeAudioModeConfig::unicastConfig) {
auto& unicast_config =
leaudio_config.modeConfig
.get<LeAudioConfiguration::LeAudioModeConfig::unicastConfig>();
if (unicast_config.leAudioCodecConfig.getTag() ==
LeAudioCodecConfiguration::lc3Config) {
LOG(FATAL) << __func__ << ": unexpected codec type(vendor?)";
}
auto& le_codec_config = unicast_config.leAudioCodecConfig
.get<LeAudioCodecConfiguration::lc3Config>();
auto& le_codec_config = unicast_config.leAudioCodecConfig
.get<LeAudioCodecConfiguration::lc3Config>();
hidl_lc3_codec_config.lc3Config = to_hidl_lc3_config_2_1(le_codec_config);
Lc3CodecConfig_2_1 hidl_lc3_codec_config;
hidl_lc3_codec_config.lc3Config = to_hidl_lc3_config_2_1(le_codec_config);
for (const auto& map : unicast_config.streamMap) {
hidl_lc3_codec_config.audioChannelAllocation |=
map.audioChannelAllocation;
}
} else {
// NOTE: Broadcast is not officially supported in HIDL
auto& bcast_config =
leaudio_config.modeConfig
.get<LeAudioConfiguration::LeAudioModeConfig::broadcastConfig>();
if (bcast_config.streamMap.empty()) {
return hidl_lc3_codec_config;
}
if (bcast_config.streamMap[0].leAudioCodecConfig.getTag() !=
LeAudioCodecConfiguration::lc3Config) {
LOG(FATAL) << __func__ << ": unexpected codec type(vendor?)";
}
auto& le_codec_config =
bcast_config.streamMap[0]
.leAudioCodecConfig.get<LeAudioCodecConfiguration::lc3Config>();
hidl_lc3_codec_config.lc3Config = to_hidl_lc3_config_2_1(le_codec_config);
hidl_lc3_codec_config.audioChannelAllocation =
unicast_config.streamMap.size();
for (const auto& map : bcast_config.streamMap) {
hidl_lc3_codec_config.audioChannelAllocation |=
map.audioChannelAllocation;
}
}
return hidl_lc3_codec_config;
}
@@ -456,13 +480,10 @@ inline Lc3CodecConfig_2_1 to_hidl_leaudio_config_2_1(
inline LeAudioConfig_2_2 to_hidl_leaudio_config_2_2(
const LeAudioConfiguration& leaudio_config) {
LeAudioConfig_2_2 hidl_leaudio_config;
if (leaudio_mode_to_hidl_map.find(leaudio_config.mode) !=
leaudio_mode_to_hidl_map.end()) {
hidl_leaudio_config.mode = leaudio_mode_to_hidl_map.at(leaudio_config.mode);
}
if (leaudio_config.modeConfig.getTag() ==
LeAudioConfiguration::LeAudioModeConfig::unicastConfig) {
hidl_leaudio_config.mode = LeAudioMode_2_2::UNICAST;
auto& unicast_config =
leaudio_config.modeConfig
.get<LeAudioConfiguration::LeAudioModeConfig::unicastConfig>();
@@ -485,6 +506,7 @@ inline LeAudioConfig_2_2 to_hidl_leaudio_config_2_2(
}
} else if (leaudio_config.modeConfig.getTag() ==
LeAudioConfiguration::LeAudioModeConfig::broadcastConfig) {
hidl_leaudio_config.mode = LeAudioMode_2_2::BROADCAST;
auto bcast_config =
leaudio_config.modeConfig
.get<LeAudioConfiguration::LeAudioModeConfig::broadcastConfig>();