795 lines
33 KiB
C++
795 lines
33 KiB
C++
/*
|
|
* Copyright (C) 2022 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 "BTAudioProviderLeAudioHW"
|
|
|
|
#include "LeAudioOffloadAudioProvider.h"
|
|
|
|
#include <BluetoothAudioCodecs.h>
|
|
#include <BluetoothAudioSessionReport.h>
|
|
#include <android-base/logging.h>
|
|
|
|
namespace aidl {
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace bluetooth {
|
|
namespace audio {
|
|
|
|
constexpr uint8_t kLeAudioDirectionSink = 0x01;
|
|
constexpr uint8_t kLeAudioDirectionSource = 0x02;
|
|
|
|
const std::map<CodecSpecificConfigurationLtv::SamplingFrequency, uint32_t>
|
|
freq_to_support_bitmask_map = {
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ8000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ8000},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ11025,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ11025},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ16000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ16000},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ22050,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ22050},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ24000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ24000},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ32000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ32000},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ48000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ48000},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ88200,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ88200},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ96000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ96000},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ176400,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ176400},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ192000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ192000},
|
|
{CodecSpecificConfigurationLtv::SamplingFrequency::HZ384000,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies::HZ384000},
|
|
};
|
|
|
|
// Helper map from capability's tag to configuration's tag
|
|
std::map<CodecSpecificCapabilitiesLtv::Tag, CodecSpecificConfigurationLtv::Tag>
|
|
cap_to_cfg_tag_map = {
|
|
{CodecSpecificCapabilitiesLtv::Tag::supportedSamplingFrequencies,
|
|
CodecSpecificConfigurationLtv::Tag::samplingFrequency},
|
|
{CodecSpecificCapabilitiesLtv::Tag::supportedMaxCodecFramesPerSDU,
|
|
CodecSpecificConfigurationLtv::Tag::codecFrameBlocksPerSDU},
|
|
{CodecSpecificCapabilitiesLtv::Tag::supportedFrameDurations,
|
|
CodecSpecificConfigurationLtv::Tag::frameDuration},
|
|
{CodecSpecificCapabilitiesLtv::Tag::supportedAudioChannelCounts,
|
|
CodecSpecificConfigurationLtv::Tag::audioChannelAllocation},
|
|
{CodecSpecificCapabilitiesLtv::Tag::supportedOctetsPerCodecFrame,
|
|
CodecSpecificConfigurationLtv::Tag::octetsPerCodecFrame},
|
|
};
|
|
|
|
const std::map<CodecSpecificConfigurationLtv::FrameDuration, uint32_t>
|
|
fduration_to_support_fduration_map = {
|
|
{CodecSpecificConfigurationLtv::FrameDuration::US7500,
|
|
CodecSpecificCapabilitiesLtv::SupportedFrameDurations::US7500},
|
|
{CodecSpecificConfigurationLtv::FrameDuration::US10000,
|
|
CodecSpecificCapabilitiesLtv::SupportedFrameDurations::US10000},
|
|
};
|
|
|
|
std::map<int32_t, CodecSpecificConfigurationLtv::SamplingFrequency>
|
|
sampling_freq_map = {
|
|
{16000, CodecSpecificConfigurationLtv::SamplingFrequency::HZ16000},
|
|
{48000, CodecSpecificConfigurationLtv::SamplingFrequency::HZ48000},
|
|
{96000, CodecSpecificConfigurationLtv::SamplingFrequency::HZ96000},
|
|
};
|
|
|
|
std::map<int32_t, CodecSpecificConfigurationLtv::FrameDuration>
|
|
frame_duration_map = {
|
|
{7500, CodecSpecificConfigurationLtv::FrameDuration::US7500},
|
|
{10000, CodecSpecificConfigurationLtv::FrameDuration::US10000},
|
|
};
|
|
|
|
LeAudioOffloadOutputAudioProvider::LeAudioOffloadOutputAudioProvider()
|
|
: LeAudioOffloadAudioProvider() {
|
|
session_type_ = SessionType::LE_AUDIO_HARDWARE_OFFLOAD_ENCODING_DATAPATH;
|
|
}
|
|
|
|
LeAudioOffloadInputAudioProvider::LeAudioOffloadInputAudioProvider()
|
|
: LeAudioOffloadAudioProvider() {
|
|
session_type_ = SessionType::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH;
|
|
}
|
|
|
|
LeAudioOffloadBroadcastAudioProvider::LeAudioOffloadBroadcastAudioProvider()
|
|
: LeAudioOffloadAudioProvider() {
|
|
session_type_ =
|
|
SessionType::LE_AUDIO_BROADCAST_HARDWARE_OFFLOAD_ENCODING_DATAPATH;
|
|
}
|
|
|
|
LeAudioOffloadAudioProvider::LeAudioOffloadAudioProvider()
|
|
: BluetoothAudioProvider() {}
|
|
|
|
bool LeAudioOffloadAudioProvider::isValid(const SessionType& sessionType) {
|
|
return (sessionType == session_type_);
|
|
}
|
|
|
|
ndk::ScopedAStatus LeAudioOffloadAudioProvider::startSession(
|
|
const std::shared_ptr<IBluetoothAudioPort>& host_if,
|
|
const AudioConfiguration& audio_config,
|
|
const std::vector<LatencyMode>& latency_modes, DataMQDesc* _aidl_return) {
|
|
if (session_type_ ==
|
|
SessionType::LE_AUDIO_BROADCAST_HARDWARE_OFFLOAD_ENCODING_DATAPATH) {
|
|
if (audio_config.getTag() != AudioConfiguration::leAudioBroadcastConfig) {
|
|
LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
|
|
<< audio_config.toString();
|
|
*_aidl_return = DataMQDesc();
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
} else if (audio_config.getTag() != AudioConfiguration::leAudioConfig) {
|
|
LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
|
|
<< audio_config.toString();
|
|
*_aidl_return = DataMQDesc();
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
return BluetoothAudioProvider::startSession(host_if, audio_config,
|
|
latency_modes, _aidl_return);
|
|
}
|
|
|
|
ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSessionReady(
|
|
DataMQDesc* _aidl_return) {
|
|
BluetoothAudioSessionReport::OnSessionStarted(
|
|
session_type_, stack_iface_, nullptr, *audio_config_, latency_modes_);
|
|
*_aidl_return = DataMQDesc();
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
ndk::ScopedAStatus LeAudioOffloadAudioProvider::setCodecPriority(
|
|
const CodecId& in_codecId, int32_t in_priority) {
|
|
codec_priority_map_[in_codecId] = in_priority;
|
|
return ndk::ScopedAStatus::ok();
|
|
};
|
|
|
|
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)
|
|
return false;
|
|
return cfg_codec == req_codec;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isCapabilitiesMatchedContext(
|
|
AudioContext setting_context,
|
|
const IBluetoothAudioProvider::LeAudioDeviceCapabilities& capabilities) {
|
|
// If has no metadata, assume match
|
|
if (!capabilities.metadata.has_value()) return true;
|
|
|
|
for (auto metadata : capabilities.metadata.value()) {
|
|
if (!metadata.has_value()) continue;
|
|
if (metadata.value().getTag() == MetadataLtv::Tag::preferredAudioContexts) {
|
|
// Check all pref audio context to see if anything matched
|
|
auto& context = metadata.value()
|
|
.get<MetadataLtv::Tag::preferredAudioContexts>()
|
|
.values;
|
|
if (setting_context.bitmask & context.bitmask) return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedSamplingFreq(
|
|
CodecSpecificConfigurationLtv::SamplingFrequency& cfg_freq,
|
|
CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies&
|
|
capability_freq) {
|
|
for (auto [freq, bitmask] : freq_to_support_bitmask_map)
|
|
if (cfg_freq == freq) return (capability_freq.bitmask & bitmask);
|
|
return false;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedFrameDuration(
|
|
CodecSpecificConfigurationLtv::FrameDuration& cfg_fduration,
|
|
CodecSpecificCapabilitiesLtv::SupportedFrameDurations&
|
|
capability_fduration) {
|
|
for (auto [fduration, bitmask] : fduration_to_support_fduration_map)
|
|
if (cfg_fduration == fduration)
|
|
return (capability_fduration.bitmask & bitmask);
|
|
return false;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedAudioChannel(
|
|
CodecSpecificConfigurationLtv::AudioChannelAllocation&
|
|
/*cfg_channel*/,
|
|
CodecSpecificCapabilitiesLtv::SupportedAudioChannelCounts&
|
|
/*capability_channel*/) {
|
|
bool isMatched = true;
|
|
// TODO: how to match?
|
|
return isMatched;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedCodecFramesPerSDU(
|
|
CodecSpecificConfigurationLtv::CodecFrameBlocksPerSDU& cfg_frame_sdu,
|
|
CodecSpecificCapabilitiesLtv::SupportedMaxCodecFramesPerSDU&
|
|
capability_frame_sdu) {
|
|
return cfg_frame_sdu.value <= capability_frame_sdu.value;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedOctetsPerCodecFrame(
|
|
CodecSpecificConfigurationLtv::OctetsPerCodecFrame& cfg_octets,
|
|
CodecSpecificCapabilitiesLtv::SupportedOctetsPerCodecFrame&
|
|
capability_octets) {
|
|
return cfg_octets.value >= capability_octets.minimum &&
|
|
cfg_octets.value <= capability_octets.maximum;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isCapabilitiesMatchedCodecConfiguration(
|
|
std::vector<CodecSpecificConfigurationLtv>& codec_cfg,
|
|
std::vector<CodecSpecificCapabilitiesLtv> codec_capabilities) {
|
|
// Convert all codec_cfg into a map of tags -> correct data
|
|
std::map<CodecSpecificConfigurationLtv::Tag, CodecSpecificConfigurationLtv>
|
|
cfg_tag_map;
|
|
for (auto codec_cfg_data : codec_cfg)
|
|
cfg_tag_map[codec_cfg_data.getTag()] = codec_cfg_data;
|
|
|
|
for (auto& codec_capability : codec_capabilities) {
|
|
auto cfg = cfg_tag_map.find(cap_to_cfg_tag_map[codec_capability.getTag()]);
|
|
// Cannot find tag for the capability:
|
|
if (cfg == cfg_tag_map.end()) return false;
|
|
|
|
// Matching logic for sampling frequency
|
|
if (codec_capability.getTag() ==
|
|
CodecSpecificCapabilitiesLtv::Tag::supportedSamplingFrequencies) {
|
|
if (!isMatchedSamplingFreq(
|
|
cfg->second
|
|
.get<CodecSpecificConfigurationLtv::Tag::samplingFrequency>(),
|
|
codec_capability.get<CodecSpecificCapabilitiesLtv::Tag::
|
|
supportedSamplingFrequencies>()))
|
|
return false;
|
|
} else if (codec_capability.getTag() ==
|
|
CodecSpecificCapabilitiesLtv::Tag::supportedFrameDurations) {
|
|
if (!isMatchedFrameDuration(
|
|
cfg->second
|
|
.get<CodecSpecificConfigurationLtv::Tag::frameDuration>(),
|
|
codec_capability.get<CodecSpecificCapabilitiesLtv::Tag::
|
|
supportedFrameDurations>()))
|
|
return false;
|
|
} else if (codec_capability.getTag() ==
|
|
CodecSpecificCapabilitiesLtv::Tag::supportedAudioChannelCounts) {
|
|
if (!isMatchedAudioChannel(
|
|
cfg->second.get<
|
|
CodecSpecificConfigurationLtv::Tag::audioChannelAllocation>(),
|
|
codec_capability.get<CodecSpecificCapabilitiesLtv::Tag::
|
|
supportedAudioChannelCounts>()))
|
|
return false;
|
|
} else if (codec_capability.getTag() == CodecSpecificCapabilitiesLtv::Tag::
|
|
supportedMaxCodecFramesPerSDU) {
|
|
if (!isMatchedCodecFramesPerSDU(
|
|
cfg->second.get<
|
|
CodecSpecificConfigurationLtv::Tag::codecFrameBlocksPerSDU>(),
|
|
codec_capability.get<CodecSpecificCapabilitiesLtv::Tag::
|
|
supportedMaxCodecFramesPerSDU>()))
|
|
return false;
|
|
} else if (codec_capability.getTag() == CodecSpecificCapabilitiesLtv::Tag::
|
|
supportedOctetsPerCodecFrame) {
|
|
if (!isMatchedOctetsPerCodecFrame(
|
|
cfg->second.get<
|
|
CodecSpecificConfigurationLtv::Tag::octetsPerCodecFrame>(),
|
|
codec_capability.get<CodecSpecificCapabilitiesLtv::Tag::
|
|
supportedOctetsPerCodecFrame>()))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedAseConfiguration(
|
|
LeAudioAseConfiguration setting_cfg,
|
|
LeAudioAseConfiguration requirement_cfg) {
|
|
// Check matching for codec configuration <=> requirement ASE codec
|
|
// Also match if no CodecId requirement
|
|
if (requirement_cfg.codecId.has_value()) {
|
|
if (!setting_cfg.codecId.has_value()) return false;
|
|
if (!isMatchedValidCodec(setting_cfg.codecId.value(),
|
|
requirement_cfg.codecId.value()))
|
|
return false;
|
|
}
|
|
|
|
if (setting_cfg.targetLatency != requirement_cfg.targetLatency) return false;
|
|
// Ignore PHY requirement
|
|
|
|
// Check all codec configuration
|
|
std::map<CodecSpecificConfigurationLtv::Tag, CodecSpecificConfigurationLtv>
|
|
cfg_tag_map;
|
|
for (auto cfg : setting_cfg.codecConfiguration)
|
|
cfg_tag_map[cfg.getTag()] = cfg;
|
|
|
|
for (auto requirement_cfg : requirement_cfg.codecConfiguration) {
|
|
// Directly compare CodecSpecificConfigurationLtv
|
|
auto cfg = cfg_tag_map.find(requirement_cfg.getTag());
|
|
if (cfg == cfg_tag_map.end()) return false;
|
|
|
|
if (cfg->second != requirement_cfg) return false;
|
|
}
|
|
// Ignore vendor configuration and metadata requirement
|
|
|
|
return true;
|
|
}
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedBISConfiguration(
|
|
LeAudioBisConfiguration bis_cfg,
|
|
const IBluetoothAudioProvider::LeAudioDeviceCapabilities& capabilities) {
|
|
if (!isMatchedValidCodec(bis_cfg.codecId, capabilities.codecId)) return false;
|
|
if (!isCapabilitiesMatchedCodecConfiguration(
|
|
bis_cfg.codecConfiguration, capabilities.codecSpecificCapabilities))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void LeAudioOffloadAudioProvider::filterCapabilitiesAseDirectionConfiguration(
|
|
std::vector<std::optional<AseDirectionConfiguration>>&
|
|
direction_configurations,
|
|
const IBluetoothAudioProvider::LeAudioDeviceCapabilities& capabilities,
|
|
std::vector<std::optional<AseDirectionConfiguration>>&
|
|
valid_direction_configurations) {
|
|
for (auto direction_configuration : direction_configurations) {
|
|
if (!direction_configuration.has_value()) continue;
|
|
if (!direction_configuration.value().aseConfiguration.codecId.has_value())
|
|
continue;
|
|
if (!isMatchedValidCodec(
|
|
direction_configuration.value().aseConfiguration.codecId.value(),
|
|
capabilities.codecId))
|
|
continue;
|
|
// Check matching for codec configuration <=> codec capabilities
|
|
if (!isCapabilitiesMatchedCodecConfiguration(
|
|
direction_configuration.value().aseConfiguration.codecConfiguration,
|
|
capabilities.codecSpecificCapabilities))
|
|
continue;
|
|
valid_direction_configurations.push_back(direction_configuration);
|
|
}
|
|
}
|
|
|
|
void LeAudioOffloadAudioProvider::filterRequirementAseDirectionConfiguration(
|
|
std::vector<std::optional<AseDirectionConfiguration>>&
|
|
direction_configurations,
|
|
const std::optional<std::vector<std::optional<AseDirectionRequirement>>>&
|
|
requirements,
|
|
std::vector<std::optional<AseDirectionConfiguration>>&
|
|
valid_direction_configurations) {
|
|
for (auto direction_configuration : direction_configurations) {
|
|
if (!requirements.has_value()) {
|
|
// If there's no requirement, all are valid
|
|
valid_direction_configurations.push_back(direction_configuration);
|
|
continue;
|
|
}
|
|
if (!direction_configuration.has_value()) continue;
|
|
|
|
for (auto& requirement : requirements.value()) {
|
|
if (!requirement.has_value()) continue;
|
|
if (!isMatchedAseConfiguration(
|
|
direction_configuration.value().aseConfiguration,
|
|
requirement.value().aseConfiguration))
|
|
continue;
|
|
// Valid if match any requirement.
|
|
valid_direction_configurations.push_back(direction_configuration);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Get a new LeAudioAseConfigurationSetting by matching a setting with a
|
|
* capabilities. The new setting will have a filtered list of
|
|
* AseDirectionConfiguration that matched the capabilities */
|
|
std::optional<LeAudioAseConfigurationSetting>
|
|
LeAudioOffloadAudioProvider::getCapabilitiesMatchedAseConfigurationSettings(
|
|
IBluetoothAudioProvider::LeAudioAseConfigurationSetting& setting,
|
|
const IBluetoothAudioProvider::LeAudioDeviceCapabilities& capabilities,
|
|
uint8_t direction) {
|
|
// Try to match context in metadata.
|
|
if (!isCapabilitiesMatchedContext(setting.audioContext, capabilities))
|
|
return std::nullopt;
|
|
|
|
// Get a list of all matched AseDirectionConfiguration
|
|
// for the input direction
|
|
std::vector<std::optional<AseDirectionConfiguration>>*
|
|
direction_configuration = nullptr;
|
|
if (direction == kLeAudioDirectionSink) {
|
|
if (!setting.sinkAseConfiguration.has_value()) return std::nullopt;
|
|
direction_configuration = &setting.sinkAseConfiguration.value();
|
|
} else {
|
|
if (!setting.sourceAseConfiguration.has_value()) return std::nullopt;
|
|
direction_configuration = &setting.sourceAseConfiguration.value();
|
|
}
|
|
std::vector<std::optional<AseDirectionConfiguration>>
|
|
valid_direction_configuration;
|
|
filterCapabilitiesAseDirectionConfiguration(
|
|
*direction_configuration, capabilities, valid_direction_configuration);
|
|
if (valid_direction_configuration.empty()) return std::nullopt;
|
|
|
|
// Create a new LeAudioAseConfigurationSetting and return
|
|
LeAudioAseConfigurationSetting filtered_setting;
|
|
filtered_setting.audioContext = setting.audioContext;
|
|
filtered_setting.packing = setting.packing;
|
|
if (direction == kLeAudioDirectionSink) {
|
|
filtered_setting.sinkAseConfiguration = valid_direction_configuration;
|
|
} else {
|
|
filtered_setting.sourceAseConfiguration = valid_direction_configuration;
|
|
}
|
|
filtered_setting.flags = setting.flags;
|
|
|
|
return filtered_setting;
|
|
}
|
|
|
|
/* Get a new LeAudioAseConfigurationSetting by matching a setting with a
|
|
* requirement. The new setting will have a filtered list of
|
|
* AseDirectionConfiguration that matched the requirement */
|
|
std::optional<LeAudioAseConfigurationSetting>
|
|
LeAudioOffloadAudioProvider::getRequirementMatchedAseConfigurationSettings(
|
|
IBluetoothAudioProvider::LeAudioAseConfigurationSetting& setting,
|
|
const IBluetoothAudioProvider::LeAudioConfigurationRequirement&
|
|
requirement) {
|
|
// Try to match context in metadata.
|
|
if (setting.audioContext != requirement.audioContext) return std::nullopt;
|
|
|
|
// Check requirement for the correct direction
|
|
const std::optional<std::vector<std::optional<AseDirectionRequirement>>>*
|
|
direction_requirement;
|
|
std::vector<std::optional<AseDirectionConfiguration>>*
|
|
direction_configuration;
|
|
if (setting.sinkAseConfiguration.has_value()) {
|
|
direction_configuration = &setting.sinkAseConfiguration.value();
|
|
direction_requirement = &requirement.sinkAseRequirement;
|
|
} else {
|
|
direction_configuration = &setting.sourceAseConfiguration.value();
|
|
direction_requirement = &requirement.sourceAseRequirement;
|
|
}
|
|
|
|
std::vector<std::optional<AseDirectionConfiguration>>
|
|
valid_direction_configuration;
|
|
filterRequirementAseDirectionConfiguration(*direction_configuration,
|
|
*direction_requirement,
|
|
valid_direction_configuration);
|
|
if (valid_direction_configuration.empty()) return std::nullopt;
|
|
|
|
// Create a new LeAudioAseConfigurationSetting and return
|
|
LeAudioAseConfigurationSetting filtered_setting;
|
|
filtered_setting.audioContext = setting.audioContext;
|
|
filtered_setting.packing = setting.packing;
|
|
if (setting.sinkAseConfiguration.has_value())
|
|
filtered_setting.sinkAseConfiguration = valid_direction_configuration;
|
|
else
|
|
filtered_setting.sourceAseConfiguration = valid_direction_configuration;
|
|
filtered_setting.flags = setting.flags;
|
|
|
|
return filtered_setting;
|
|
}
|
|
|
|
ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration(
|
|
const std::optional<std::vector<
|
|
std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&
|
|
in_remoteSinkAudioCapabilities,
|
|
const std::optional<std::vector<
|
|
std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&
|
|
in_remoteSourceAudioCapabilities,
|
|
const std::vector<IBluetoothAudioProvider::LeAudioConfigurationRequirement>&
|
|
in_requirements,
|
|
std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>*
|
|
_aidl_return) {
|
|
// Get all configuration settings
|
|
std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>
|
|
ase_configuration_settings =
|
|
BluetoothAudioCodecs::GetLeAudioAseConfigurationSettings();
|
|
|
|
// Currently won't handle case where both sink and source capabilities
|
|
// are passed in. Only handle one of them.
|
|
const std::optional<std::vector<
|
|
std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>*
|
|
in_remoteAudioCapabilities;
|
|
uint8_t direction = 0;
|
|
if (in_remoteSinkAudioCapabilities.has_value()) {
|
|
direction = kLeAudioDirectionSink;
|
|
in_remoteAudioCapabilities = &in_remoteSinkAudioCapabilities;
|
|
} else {
|
|
direction = kLeAudioDirectionSource;
|
|
in_remoteAudioCapabilities = &in_remoteSourceAudioCapabilities;
|
|
}
|
|
|
|
std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>
|
|
capability_matched_ase_configuration_settings;
|
|
// Matching with remote capabilities
|
|
for (auto& setting : ase_configuration_settings) {
|
|
for (auto& capability : in_remoteAudioCapabilities->value()) {
|
|
if (!capability.has_value()) continue;
|
|
auto filtered_ase_configuration_setting =
|
|
getCapabilitiesMatchedAseConfigurationSettings(
|
|
setting, capability.value(), direction);
|
|
if (filtered_ase_configuration_setting.has_value()) {
|
|
capability_matched_ase_configuration_settings.push_back(
|
|
filtered_ase_configuration_setting.value());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Matching with requirements
|
|
std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting> result;
|
|
for (auto& setting : capability_matched_ase_configuration_settings) {
|
|
for (auto& requirement : in_requirements) {
|
|
auto filtered_ase_configuration_setting =
|
|
getRequirementMatchedAseConfigurationSettings(setting, requirement);
|
|
if (filtered_ase_configuration_setting.has_value()) {
|
|
result.push_back(filtered_ase_configuration_setting.value());
|
|
}
|
|
}
|
|
}
|
|
|
|
*_aidl_return = result;
|
|
return ndk::ScopedAStatus::ok();
|
|
};
|
|
|
|
bool LeAudioOffloadAudioProvider::isMatchedQosRequirement(
|
|
LeAudioAseQosConfiguration setting_qos,
|
|
AseQosDirectionRequirement requirement_qos) {
|
|
if (setting_qos.retransmissionNum !=
|
|
requirement_qos.preferredRetransmissionNum)
|
|
return false;
|
|
if (setting_qos.maxTransportLatencyMs > requirement_qos.maxTransportLatencyMs)
|
|
return false;
|
|
// Ignore other parameters, as they are not populated in the setting_qos
|
|
return true;
|
|
}
|
|
|
|
ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseQosConfiguration(
|
|
const IBluetoothAudioProvider::LeAudioAseQosConfigurationRequirement&
|
|
in_qosRequirement,
|
|
IBluetoothAudioProvider::LeAudioAseQosConfigurationPair* _aidl_return) {
|
|
IBluetoothAudioProvider::LeAudioAseQosConfigurationPair result;
|
|
// Get all configuration settings
|
|
std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>
|
|
ase_configuration_settings =
|
|
BluetoothAudioCodecs::GetLeAudioAseConfigurationSettings();
|
|
|
|
// Direction QoS matching
|
|
// Only handle one direction input case
|
|
uint8_t direction = 0;
|
|
std::optional<AseQosDirectionRequirement> direction_qos_requirement =
|
|
std::nullopt;
|
|
if (in_qosRequirement.sinkAseQosRequirement.has_value()) {
|
|
direction_qos_requirement = in_qosRequirement.sinkAseQosRequirement.value();
|
|
direction = kLeAudioDirectionSink;
|
|
} else if (in_qosRequirement.sourceAseQosRequirement.has_value()) {
|
|
direction_qos_requirement =
|
|
in_qosRequirement.sourceAseQosRequirement.value();
|
|
direction = kLeAudioDirectionSource;
|
|
}
|
|
|
|
for (auto& setting : ase_configuration_settings) {
|
|
// Context matching
|
|
if (setting.audioContext != in_qosRequirement.contextType) continue;
|
|
|
|
// Match configuration flags
|
|
// Currently configuration flags are not populated, ignore.
|
|
|
|
// Get a list of all matched AseDirectionConfiguration
|
|
// for the input direction
|
|
std::vector<std::optional<AseDirectionConfiguration>>*
|
|
direction_configuration = nullptr;
|
|
if (direction == kLeAudioDirectionSink) {
|
|
if (!setting.sinkAseConfiguration.has_value()) continue;
|
|
direction_configuration = &setting.sinkAseConfiguration.value();
|
|
} else {
|
|
if (!setting.sourceAseConfiguration.has_value()) continue;
|
|
direction_configuration = &setting.sourceAseConfiguration.value();
|
|
}
|
|
|
|
for (auto cfg : *direction_configuration) {
|
|
if (!cfg.has_value()) continue;
|
|
// If no requirement, return the first QoS
|
|
if (!direction_qos_requirement.has_value()) {
|
|
result.sinkQosConfiguration = cfg.value().qosConfiguration;
|
|
result.sourceQosConfiguration = cfg.value().qosConfiguration;
|
|
*_aidl_return = result;
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
// If has requirement, return the first matched QoS
|
|
// Try to match the ASE configuration
|
|
// and QoS with requirement
|
|
if (!cfg.value().qosConfiguration.has_value()) continue;
|
|
if (isMatchedAseConfiguration(
|
|
cfg.value().aseConfiguration,
|
|
direction_qos_requirement.value().aseConfiguration) &&
|
|
isMatchedQosRequirement(cfg.value().qosConfiguration.value(),
|
|
direction_qos_requirement.value())) {
|
|
if (direction == kLeAudioDirectionSink)
|
|
result.sinkQosConfiguration = cfg.value().qosConfiguration;
|
|
else
|
|
result.sourceQosConfiguration = cfg.value().qosConfiguration;
|
|
*_aidl_return = result;
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
}
|
|
}
|
|
|
|
// No match, return empty QoS
|
|
*_aidl_return = result;
|
|
return ndk::ScopedAStatus::ok();
|
|
};
|
|
|
|
ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSinkAseMetadataChanged(
|
|
IBluetoothAudioProvider::AseState in_state, int32_t /*in_cigId*/,
|
|
int32_t /*in_cisId*/,
|
|
const std::optional<std::vector<std::optional<MetadataLtv>>>& in_metadata) {
|
|
(void)in_state;
|
|
(void)in_metadata;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
};
|
|
|
|
ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSourceAseMetadataChanged(
|
|
IBluetoothAudioProvider::AseState in_state, int32_t /*in_cigId*/,
|
|
int32_t /*in_cisId*/,
|
|
const std::optional<std::vector<std::optional<MetadataLtv>>>& in_metadata) {
|
|
(void)in_state;
|
|
(void)in_metadata;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
};
|
|
|
|
void LeAudioOffloadAudioProvider::getBroadcastSettings() {
|
|
if (!broadcast_settings.empty()) return;
|
|
|
|
LOG(INFO) << __func__ << ": Loading broadcast settings from provider info";
|
|
|
|
std::vector<CodecInfo> db_codec_info =
|
|
BluetoothAudioCodecs::GetLeAudioOffloadCodecInfo(
|
|
SessionType::LE_AUDIO_BROADCAST_HARDWARE_OFFLOAD_ENCODING_DATAPATH);
|
|
broadcast_settings.clear();
|
|
CodecSpecificConfigurationLtv::AudioChannelAllocation default_allocation;
|
|
default_allocation.bitmask =
|
|
CodecSpecificConfigurationLtv::AudioChannelAllocation::FRONT_CENTER;
|
|
|
|
for (auto& codec_info : db_codec_info) {
|
|
if (codec_info.transport.getTag() != CodecInfo::Transport::leAudio)
|
|
continue;
|
|
auto& transport = codec_info.transport.get<CodecInfo::Transport::leAudio>();
|
|
LeAudioBroadcastConfigurationSetting setting;
|
|
// Default setting
|
|
setting.numBis = 1;
|
|
setting.phy = {Phy::TWO_M};
|
|
// Populate BIS configuration info using codec_info
|
|
LeAudioBisConfiguration bis_cfg;
|
|
bis_cfg.codecId = codec_info.id;
|
|
|
|
CodecSpecificConfigurationLtv::OctetsPerCodecFrame octets;
|
|
octets.value = transport.bitdepth[0];
|
|
|
|
bis_cfg.codecConfiguration = {
|
|
sampling_freq_map[transport.samplingFrequencyHz[0]], octets,
|
|
frame_duration_map[transport.frameDurationUs[0]], default_allocation};
|
|
|
|
// Add information to structure
|
|
IBluetoothAudioProvider::LeAudioSubgroupBisConfiguration sub_bis_cfg;
|
|
sub_bis_cfg.numBis = 1;
|
|
sub_bis_cfg.bisConfiguration = bis_cfg;
|
|
IBluetoothAudioProvider::LeAudioBroadcastSubgroupConfiguration sub_cfg;
|
|
sub_cfg.bisConfigurations = {sub_bis_cfg};
|
|
setting.subgroupsConfigurations = {sub_cfg};
|
|
|
|
broadcast_settings.push_back(setting);
|
|
}
|
|
|
|
LOG(INFO) << __func__
|
|
<< ": Done loading broadcast settings from provider info";
|
|
}
|
|
|
|
/* Get a new LeAudioAseConfigurationSetting by matching a setting with a
|
|
* capabilities. The new setting will have a filtered list of
|
|
* AseDirectionConfiguration that matched the capabilities */
|
|
std::optional<LeAudioBroadcastConfigurationSetting>
|
|
LeAudioOffloadAudioProvider::
|
|
getCapabilitiesMatchedBroadcastConfigurationSettings(
|
|
LeAudioBroadcastConfigurationSetting& setting,
|
|
const IBluetoothAudioProvider::LeAudioDeviceCapabilities&
|
|
capabilities) {
|
|
std::vector<IBluetoothAudioProvider::LeAudioBroadcastSubgroupConfiguration>
|
|
filter_subgroup;
|
|
for (auto& sub_cfg : setting.subgroupsConfigurations) {
|
|
std::vector<IBluetoothAudioProvider::LeAudioSubgroupBisConfiguration>
|
|
filtered_bis_cfg;
|
|
for (auto& bis_cfg : sub_cfg.bisConfigurations)
|
|
if (isMatchedBISConfiguration(bis_cfg.bisConfiguration, capabilities)) {
|
|
filtered_bis_cfg.push_back(bis_cfg);
|
|
}
|
|
if (!filtered_bis_cfg.empty()) {
|
|
IBluetoothAudioProvider::LeAudioBroadcastSubgroupConfiguration
|
|
subgroup_cfg;
|
|
subgroup_cfg.bisConfigurations = filtered_bis_cfg;
|
|
filter_subgroup.push_back(subgroup_cfg);
|
|
}
|
|
}
|
|
if (filter_subgroup.empty()) return std::nullopt;
|
|
|
|
// Create a new LeAudioAseConfigurationSetting and return
|
|
LeAudioBroadcastConfigurationSetting filtered_setting(setting);
|
|
filtered_setting.subgroupsConfigurations = filter_subgroup;
|
|
|
|
return filtered_setting;
|
|
}
|
|
|
|
ndk::ScopedAStatus
|
|
LeAudioOffloadAudioProvider::getLeAudioBroadcastConfiguration(
|
|
const std::optional<std::vector<
|
|
std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&
|
|
in_remoteSinkAudioCapabilities,
|
|
const IBluetoothAudioProvider::LeAudioBroadcastConfigurationRequirement&
|
|
in_requirement,
|
|
LeAudioBroadcastConfigurationSetting* _aidl_return) {
|
|
getBroadcastSettings();
|
|
_aidl_return = nullptr;
|
|
|
|
// Match and filter capability
|
|
std::vector<LeAudioBroadcastConfigurationSetting> filtered_settings;
|
|
if (!in_remoteSinkAudioCapabilities.has_value()) {
|
|
LOG(WARNING) << __func__ << ": Empty capability";
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
for (auto& setting : broadcast_settings) {
|
|
for (auto& capability : in_remoteSinkAudioCapabilities.value()) {
|
|
if (!capability.has_value()) continue;
|
|
auto filtered_setting =
|
|
getCapabilitiesMatchedBroadcastConfigurationSettings(
|
|
setting, capability.value());
|
|
if (filtered_setting.has_value())
|
|
filtered_settings.push_back(filtered_setting.value());
|
|
}
|
|
}
|
|
|
|
if (filtered_settings.empty()) {
|
|
LOG(WARNING) << __func__ << ": Cannot match any remote capability";
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
// Match and return the first matched requirement
|
|
if (in_requirement.subgroupConfigurationRequirements.empty()) {
|
|
LOG(INFO) << __func__ << ": Empty requirement";
|
|
*_aidl_return = filtered_settings[0];
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
for (auto& setting : filtered_settings) {
|
|
// Further filter out bis configuration
|
|
LeAudioBroadcastConfigurationSetting filtered_setting(setting);
|
|
filtered_setting.subgroupsConfigurations.clear();
|
|
for (auto& sub_cfg : setting.subgroupsConfigurations) {
|
|
bool isMatched = false;
|
|
for (auto& sub_req : in_requirement.subgroupConfigurationRequirements) {
|
|
// Matching number of BIS
|
|
if (sub_req.bisNumPerSubgroup != sub_cfg.bisConfigurations.size())
|
|
continue;
|
|
// Currently will ignore quality and context hint.
|
|
isMatched = true;
|
|
break;
|
|
}
|
|
if (isMatched)
|
|
filtered_setting.subgroupsConfigurations.push_back(sub_cfg);
|
|
}
|
|
// Return the first match
|
|
if (!filtered_setting.subgroupsConfigurations.empty()) {
|
|
LOG(INFO) << __func__ << ": Matched requirement";
|
|
*_aidl_return = filtered_setting;
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
}
|
|
|
|
LOG(WARNING) << __func__ << ": Cannot match any requirement";
|
|
return ndk::ScopedAStatus::ok();
|
|
};
|
|
|
|
} // namespace audio
|
|
} // namespace bluetooth
|
|
} // namespace hardware
|
|
} // namespace android
|
|
} // namespace aidl
|