| /* |
| * Copyright 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. |
| */ |
| |
| #include "codec_manager.h" |
| |
| #include <bluetooth/log.h> |
| #include <com_android_bluetooth_flags.h> |
| |
| #include <bitset> |
| #include <sstream> |
| #include <vector> |
| |
| #include "audio_hal_client/audio_hal_client.h" |
| #include "broadcaster/broadcast_configuration_provider.h" |
| #include "broadcaster/broadcaster_types.h" |
| #include "hci/controller_interface.h" |
| #include "le_audio/le_audio_types.h" |
| #include "le_audio_set_configuration_provider.h" |
| #include "le_audio_utils.h" |
| #include "main/shim/entry.h" |
| #include "os/log.h" |
| #include "osi/include/properties.h" |
| #include "stack/include/hcimsgs.h" |
| |
| namespace { |
| |
| using bluetooth::hci::iso_manager::kIsoDataPathHci; |
| using bluetooth::hci::iso_manager::kIsoDataPathPlatformDefault; |
| using bluetooth::le_audio::CodecManager; |
| using bluetooth::le_audio::types::CodecLocation; |
| using bluetooth::legacy::hci::GetInterface; |
| |
| using bluetooth::le_audio::AudioSetConfigurationProvider; |
| using bluetooth::le_audio::btle_audio_codec_config_t; |
| using bluetooth::le_audio::btle_audio_codec_index_t; |
| using bluetooth::le_audio::set_configurations::AseConfiguration; |
| using bluetooth::le_audio::set_configurations::AudioSetConfiguration; |
| using bluetooth::le_audio::set_configurations::AudioSetConfigurations; |
| |
| typedef struct offloader_stream_maps { |
| std::vector<bluetooth::le_audio::stream_map_info> streams_map_target; |
| std::vector<bluetooth::le_audio::stream_map_info> streams_map_current; |
| bool has_changed; |
| bool is_initial; |
| } offloader_stream_maps_t; |
| } // namespace |
| |
| namespace bluetooth::le_audio { |
| template <> |
| offloader_stream_maps_t& types::BidirectionalPair<offloader_stream_maps_t>::get( |
| uint8_t direction) { |
| log::assert_that(direction < types::kLeAudioDirectionBoth, |
| "Unsupported complex direction. Reference to a single " |
| "complex direction value is not supported."); |
| return (direction == types::kLeAudioDirectionSink) ? sink : source; |
| } |
| |
| // The mapping for sampling rate, frame duration, and the QoS config |
| static std::unordered_map< |
| int, std::unordered_map< |
| int, bluetooth::le_audio::broadcaster::BroadcastQosConfig>> |
| bcast_high_reliability_qos = { |
| {LeAudioCodecConfiguration::kSampleRate16000, |
| {{LeAudioCodecConfiguration::kInterval7500Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_45}, |
| {LeAudioCodecConfiguration::kInterval10000Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_60}}}, |
| {LeAudioCodecConfiguration::kSampleRate24000, |
| {{LeAudioCodecConfiguration::kInterval7500Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_45}, |
| {LeAudioCodecConfiguration::kInterval10000Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_60}}}, |
| {LeAudioCodecConfiguration::kSampleRate32000, |
| {{LeAudioCodecConfiguration::kInterval7500Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_45}, |
| {LeAudioCodecConfiguration::kInterval10000Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_60}}}, |
| {LeAudioCodecConfiguration::kSampleRate48000, |
| {{LeAudioCodecConfiguration::kInterval7500Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_50}, |
| {LeAudioCodecConfiguration::kInterval10000Us, |
| bluetooth::le_audio::broadcaster::qos_config_4_65}}}}; |
| |
| struct codec_manager_impl { |
| public: |
| codec_manager_impl() { |
| offload_enable_ = osi_property_get_bool( |
| "ro.bluetooth.leaudio_offload.supported", false) && |
| !osi_property_get_bool( |
| "persist.bluetooth.leaudio_offload.disabled", true); |
| if (offload_enable_ == false) { |
| log::info("offload disabled"); |
| return; |
| } |
| |
| if (!LeAudioHalVerifier::SupportsLeAudioHardwareOffload()) { |
| log::warn("HAL not support hardware offload"); |
| return; |
| } |
| |
| if (!bluetooth::shim::GetController()->IsSupported( |
| bluetooth::hci::OpCode::CONFIGURE_DATA_PATH)) { |
| log::warn("Controller does not support config data path command"); |
| return; |
| } |
| |
| log::info("LeAudioCodecManagerImpl: configure_data_path for encode"); |
| GetInterface().ConfigureDataPath(hci_data_direction_t::HOST_TO_CONTROLLER, |
| kIsoDataPathPlatformDefault, {}); |
| GetInterface().ConfigureDataPath(hci_data_direction_t::CONTROLLER_TO_HOST, |
| kIsoDataPathPlatformDefault, {}); |
| SetCodecLocation(CodecLocation::ADSP); |
| } |
| void start( |
| const std::vector<btle_audio_codec_config_t>& offloading_preference) { |
| dual_bidirection_swb_supported_ = osi_property_get_bool( |
| "bluetooth.leaudio.dual_bidirection_swb.supported", false); |
| bluetooth::le_audio::AudioSetConfigurationProvider::Initialize( |
| GetCodecLocation()); |
| UpdateOffloadCapability(offloading_preference); |
| } |
| ~codec_manager_impl() { |
| if (GetCodecLocation() != CodecLocation::HOST) { |
| GetInterface().ConfigureDataPath(hci_data_direction_t::HOST_TO_CONTROLLER, |
| kIsoDataPathHci, {}); |
| GetInterface().ConfigureDataPath(hci_data_direction_t::CONTROLLER_TO_HOST, |
| kIsoDataPathHci, {}); |
| } |
| bluetooth::le_audio::AudioSetConfigurationProvider::Cleanup(); |
| } |
| CodecLocation GetCodecLocation(void) const { return codec_location_; } |
| |
| bool IsDualBiDirSwbSupported(void) const { |
| if (GetCodecLocation() == CodecLocation::ADSP) { |
| // Whether dual bidirection swb is supported by property and for offload |
| return offload_dual_bidirection_swb_supported_; |
| } else if (GetCodecLocation() == CodecLocation::HOST) { |
| // Whether dual bidirection swb is supported for software |
| return dual_bidirection_swb_supported_; |
| } |
| |
| return false; |
| } |
| |
| std::vector<bluetooth::le_audio::btle_audio_codec_config_t> |
| GetLocalAudioOutputCodecCapa() { |
| return codec_output_capa; |
| } |
| |
| std::vector<bluetooth::le_audio::btle_audio_codec_config_t> |
| GetLocalAudioInputCodecCapa() { |
| return codec_input_capa; |
| } |
| |
| void UpdateActiveAudioConfig( |
| const types::BidirectionalPair<stream_parameters>& stream_params, |
| types::BidirectionalPair<uint16_t> delays_ms, |
| std::function<void(const offload_config& config, uint8_t direction)> |
| update_receiver) { |
| if (GetCodecLocation() != bluetooth::le_audio::types::CodecLocation::ADSP) { |
| return; |
| } |
| |
| for (auto direction : |
| {bluetooth::le_audio::types::kLeAudioDirectionSink, |
| bluetooth::le_audio::types::kLeAudioDirectionSource}) { |
| auto& stream_map = offloader_stream_maps.get(direction); |
| if (!stream_map.has_changed && !stream_map.is_initial) { |
| continue; |
| } |
| if (stream_params.get(direction).stream_locations.empty()) { |
| continue; |
| } |
| |
| bluetooth::le_audio::offload_config unicast_cfg = { |
| .stream_map = (stream_map.is_initial || |
| LeAudioHalVerifier::SupportsStreamActiveApi()) |
| ? stream_map.streams_map_target |
| : stream_map.streams_map_current, |
| // TODO: set the default value 16 for now, would change it if we |
| // support mode bits_per_sample |
| .bits_per_sample = 16, |
| .sampling_rate = stream_params.get(direction).sample_frequency_hz, |
| .frame_duration = stream_params.get(direction).frame_duration_us, |
| .octets_per_frame = |
| stream_params.get(direction).octets_per_codec_frame, |
| .blocks_per_sdu = |
| stream_params.get(direction).codec_frames_blocks_per_sdu, |
| .peer_delay_ms = delays_ms.get(direction), |
| }; |
| update_receiver(unicast_cfg, direction); |
| stream_map.is_initial = false; |
| } |
| } |
| |
| bool UpdateActiveUnicastAudioHalClient( |
| LeAudioSourceAudioHalClient* source_unicast_client, |
| LeAudioSinkAudioHalClient* sink_unicast_client, bool is_active) { |
| log::debug("local_source: {}, local_sink: {}, is_active: {}", |
| fmt::ptr(source_unicast_client), fmt::ptr(sink_unicast_client), |
| is_active); |
| |
| if (source_unicast_client == nullptr && sink_unicast_client == nullptr) { |
| return false; |
| } |
| |
| if (is_active) { |
| if (source_unicast_client && unicast_local_source_hal_client != nullptr) { |
| log::error("Trying to override previous source hal client {}", |
| fmt::ptr(unicast_local_source_hal_client)); |
| return false; |
| } |
| |
| if (sink_unicast_client && unicast_local_sink_hal_client != nullptr) { |
| log::error("Trying to override previous sink hal client {}", |
| fmt::ptr(unicast_local_sink_hal_client)); |
| return false; |
| } |
| |
| if (source_unicast_client) { |
| unicast_local_source_hal_client = source_unicast_client; |
| } |
| |
| if (sink_unicast_client) { |
| unicast_local_sink_hal_client = sink_unicast_client; |
| } |
| |
| return true; |
| } |
| |
| if (source_unicast_client && |
| source_unicast_client != unicast_local_source_hal_client) { |
| log::error("local source session does not match {} != {}", |
| fmt::ptr(source_unicast_client), |
| fmt::ptr(unicast_local_source_hal_client)); |
| return false; |
| } |
| |
| if (sink_unicast_client && |
| sink_unicast_client != unicast_local_sink_hal_client) { |
| log::error("local source session does not match {} != {}", |
| fmt::ptr(sink_unicast_client), |
| fmt::ptr(unicast_local_sink_hal_client)); |
| return false; |
| } |
| |
| if (source_unicast_client) { |
| unicast_local_source_hal_client = nullptr; |
| } |
| |
| if (sink_unicast_client) { |
| unicast_local_sink_hal_client = nullptr; |
| } |
| |
| return true; |
| } |
| |
| bool UpdateActiveBroadcastAudioHalClient( |
| LeAudioSourceAudioHalClient* source_broadcast_client, bool is_active) { |
| log::debug("local_source: {},is_active: {}", |
| fmt::ptr(source_broadcast_client), is_active); |
| |
| if (source_broadcast_client == nullptr) { |
| return false; |
| } |
| |
| if (is_active) { |
| if (broadcast_local_source_hal_client != nullptr) { |
| log::error("Trying to override previous source hal client {}", |
| fmt::ptr(broadcast_local_source_hal_client)); |
| return false; |
| } |
| broadcast_local_source_hal_client = source_broadcast_client; |
| return true; |
| } |
| |
| if (source_broadcast_client != broadcast_local_source_hal_client) { |
| log::error("local source session does not match {} != {}", |
| fmt::ptr(source_broadcast_client), |
| fmt::ptr(broadcast_local_source_hal_client)); |
| return false; |
| } |
| |
| broadcast_local_source_hal_client = nullptr; |
| |
| return true; |
| } |
| |
| AudioSetConfigurations GetSupportedCodecConfigurations( |
| const CodecManager::UnicastConfigurationRequirements& requirements) |
| const { |
| if (GetCodecLocation() == le_audio::types::CodecLocation::ADSP) { |
| log::verbose("Get offload config for the context type: {}", |
| (int)requirements.audio_context_type); |
| |
| // TODO: Need to have a mechanism to switch to software session if offload |
| // doesn't support. |
| return context_type_offload_config_map_.count( |
| requirements.audio_context_type) |
| ? context_type_offload_config_map_.at( |
| requirements.audio_context_type) |
| : AudioSetConfigurations(); |
| } |
| |
| log::verbose("Get software config for the context type: {}", |
| (int)requirements.audio_context_type); |
| return *AudioSetConfigurationProvider::Get()->GetConfigurations( |
| requirements.audio_context_type); |
| } |
| |
| void PrintDebugState() const { |
| for (types::LeAudioContextType ctx_type : |
| types::kLeAudioContextAllTypesArray) { |
| std::stringstream os; |
| os << ctx_type << ": "; |
| if (context_type_offload_config_map_.count(ctx_type) == 0) { |
| os << "{empty}"; |
| } else { |
| os << "{"; |
| for (const auto& conf : context_type_offload_config_map_.at(ctx_type)) { |
| os << conf->name << ", "; |
| } |
| os << "}"; |
| } |
| log::info("Offload configs for {}", os.str()); |
| } |
| } |
| |
| bool IsUsingCodecExtensibility() const { |
| auto codec_ext_status = |
| osi_property_get_bool( |
| "bluetooth.core.le_audio.codec_extension_aidl.enabled", false) && |
| com::android::bluetooth::flags::leaudio_multicodec_aidl_support(); |
| |
| log::debug("Using codec extensibility AIDL: {}", codec_ext_status); |
| return codec_ext_status; |
| } |
| |
| std::unique_ptr<AudioSetConfiguration> GetCodecConfig( |
| const CodecManager::UnicastConfigurationRequirements& requirements, |
| CodecManager::UnicastConfigurationVerifier verifier) { |
| if (IsUsingCodecExtensibility()) { |
| auto hal_config = |
| unicast_local_source_hal_client->GetUnicastConfig(requirements); |
| if (hal_config) { |
| return std::make_unique<AudioSetConfiguration>(*hal_config); |
| } |
| log::debug( |
| "No configuration received from AIDL, fall back to static " |
| "configuration."); |
| } |
| |
| auto configs = GetSupportedCodecConfigurations(requirements); |
| if (configs.empty()) { |
| log::error("No valid configuration matching the requirements: {}", |
| requirements); |
| PrintDebugState(); |
| return nullptr; |
| } |
| |
| // Remove the dual bidir SWB config if not supported |
| if (!IsDualBiDirSwbSupported()) { |
| configs.erase( |
| std::remove_if(configs.begin(), configs.end(), |
| [](auto const& el) { |
| if (el->confs.source.empty()) return false; |
| return AudioSetConfigurationProvider::Get() |
| ->CheckConfigurationIsDualBiDirSwb(*el); |
| }), |
| configs.end()); |
| } |
| |
| // Note: For the only supported right now legacy software configuration |
| // provider, we use the device group logic to match the proper |
| // configuration with group capabilities. Note that this path only |
| // supports the LC3 codec format. For the multicodec support we should |
| // rely on the configuration matcher behind the AIDL interface. |
| auto conf = verifier(requirements, &configs); |
| return conf ? std::make_unique<AudioSetConfiguration>(*conf) : nullptr; |
| } |
| |
| bool CheckCodecConfigIsBiDirSwb(const AudioSetConfiguration& config) { |
| return AudioSetConfigurationProvider::Get()->CheckConfigurationIsBiDirSwb( |
| config); |
| } |
| |
| bool CheckCodecConfigIsDualBiDirSwb(const AudioSetConfiguration& config) { |
| return AudioSetConfigurationProvider::Get() |
| ->CheckConfigurationIsDualBiDirSwb(config); |
| } |
| |
| void UpdateSupportedBroadcastConfig( |
| const std::vector<AudioSetConfiguration>& adsp_capabilities) { |
| log::info("UpdateSupportedBroadcastConfig"); |
| |
| for (const auto& adsp_audio_set_conf : adsp_capabilities) { |
| if (adsp_audio_set_conf.confs.sink.empty() || |
| !adsp_audio_set_conf.confs.source.empty()) { |
| continue; |
| } |
| |
| auto& adsp_config = adsp_audio_set_conf.confs.sink[0]; |
| |
| const types::LeAudioCoreCodecConfig core_config = |
| adsp_config.codec.params.GetAsCoreCodecConfig(); |
| bluetooth::le_audio::broadcast_offload_config broadcast_config; |
| broadcast_config.stream_map.resize(adsp_audio_set_conf.confs.sink.size()); |
| |
| // Enable the individual channels per BIS in the stream map |
| auto all_channels = adsp_config.codec.channel_count_per_iso_stream; |
| uint8_t channel_alloc_idx = 0; |
| for (auto& [_, channels] : broadcast_config.stream_map) { |
| if (all_channels) { |
| channels |= (0b1 << channel_alloc_idx++); |
| --all_channels; |
| } |
| } |
| |
| broadcast_config.bits_per_sample = |
| LeAudioCodecConfiguration::kBitsPerSample16; |
| broadcast_config.sampling_rate = core_config.GetSamplingFrequencyHz(); |
| broadcast_config.frame_duration = core_config.GetFrameDurationUs(); |
| broadcast_config.octets_per_frame = *(core_config.octets_per_codec_frame); |
| broadcast_config.blocks_per_sdu = 1; |
| |
| int sample_rate = broadcast_config.sampling_rate; |
| int frame_duration = broadcast_config.frame_duration; |
| |
| if (bcast_high_reliability_qos.find(sample_rate) != |
| bcast_high_reliability_qos.end() && |
| bcast_high_reliability_qos[sample_rate].find(frame_duration) != |
| bcast_high_reliability_qos[sample_rate].end()) { |
| auto qos = bcast_high_reliability_qos[sample_rate].at(frame_duration); |
| broadcast_config.retransmission_number = qos.getRetransmissionNumber(); |
| broadcast_config.max_transport_latency = qos.getMaxTransportLatency(); |
| supported_broadcast_config.push_back(broadcast_config); |
| } else { |
| log::error( |
| "Cannot find the correspoding QoS config for the sampling_rate: " |
| "{}, frame_duration: {}", |
| sample_rate, frame_duration); |
| } |
| |
| log::info("broadcast_config sampling_rate: {}", |
| broadcast_config.sampling_rate); |
| } |
| } |
| |
| const broadcast_offload_config* GetBroadcastOffloadConfig( |
| uint8_t preferred_quality) { |
| if (supported_broadcast_config.empty()) { |
| log::error("There is no valid broadcast offload config"); |
| return nullptr; |
| } |
| /* Broadcast audio config selection based on source broadcast capability |
| * |
| * If the preferred_quality is HIGH, the configs ranking is |
| * 48_4 > 48_2 > 24_2(sink mandatory) > 16_2(source & sink mandatory) |
| * |
| * If the preferred_quality is STANDARD, the configs ranking is |
| * 24_2(sink mandatory) > 16_2(source & sink mandatory) |
| */ |
| broadcast_target_config = -1; |
| for (int i = 0; i < (int)supported_broadcast_config.size(); i++) { |
| if (preferred_quality == bluetooth::le_audio::QUALITY_STANDARD) { |
| if (supported_broadcast_config[i].sampling_rate == 24000u && |
| supported_broadcast_config[i].octets_per_frame == 60) { // 24_2 |
| broadcast_target_config = i; |
| break; |
| } |
| |
| if (supported_broadcast_config[i].sampling_rate == 16000u && |
| supported_broadcast_config[i].octets_per_frame == 40) { // 16_2 |
| broadcast_target_config = i; |
| } |
| |
| continue; |
| } |
| |
| // perferred_quality = bluetooth::le_audio::QUALITY_HIGH |
| if (supported_broadcast_config[i].sampling_rate == 48000u && |
| supported_broadcast_config[i].octets_per_frame == 120) { // 48_4 |
| broadcast_target_config = i; |
| break; |
| } |
| |
| if ((supported_broadcast_config[i].sampling_rate == 48000u && |
| supported_broadcast_config[i].octets_per_frame == 100) || // 48_2 |
| (supported_broadcast_config[i].sampling_rate == 24000u && |
| supported_broadcast_config[i].octets_per_frame == 60) || // 24_2 |
| (supported_broadcast_config[i].sampling_rate == 16000u && |
| supported_broadcast_config[i].octets_per_frame == 40)) { // 16_2 |
| if (broadcast_target_config == -1 || |
| (supported_broadcast_config[i].sampling_rate > |
| supported_broadcast_config[broadcast_target_config].sampling_rate)) |
| broadcast_target_config = i; |
| } |
| } |
| |
| if (broadcast_target_config == -1) { |
| log::error( |
| "There is no valid broadcast offload config with preferred_quality"); |
| return nullptr; |
| } |
| |
| log::info( |
| "stream_map.size(): {}, sampling_rate: {}, frame_duration(us): {}, " |
| "octets_per_frame: {}, blocks_per_sdu {}, retransmission_number: {}, " |
| "max_transport_latency: {}", |
| supported_broadcast_config[broadcast_target_config].stream_map.size(), |
| supported_broadcast_config[broadcast_target_config].sampling_rate, |
| supported_broadcast_config[broadcast_target_config].frame_duration, |
| supported_broadcast_config[broadcast_target_config].octets_per_frame, |
| (int)supported_broadcast_config[broadcast_target_config].blocks_per_sdu, |
| (int)supported_broadcast_config[broadcast_target_config] |
| .retransmission_number, |
| supported_broadcast_config[broadcast_target_config] |
| .max_transport_latency); |
| |
| return &supported_broadcast_config[broadcast_target_config]; |
| } |
| |
| void UpdateBroadcastOffloadConfig( |
| const broadcaster::BroadcastConfiguration& config) { |
| if (config.subgroups.empty()) { |
| broadcast_target_config = -1; |
| return; |
| } |
| |
| // Use the first configuration slot |
| broadcast_target_config = 0; |
| auto& offload_cfg = supported_broadcast_config[broadcast_target_config]; |
| |
| // Note: Currently only a single subgroup offloading is supported |
| auto const& subgroup = config.subgroups.at(0); |
| auto subgroup_config = |
| subgroup.GetCommonBisCodecSpecData().GetAsCoreCodecConfig(); |
| |
| offload_cfg.sampling_rate = subgroup_config.GetSamplingFrequencyHz(); |
| offload_cfg.frame_duration = subgroup_config.GetFrameDurationUs(); |
| offload_cfg.octets_per_frame = subgroup_config.GetOctectsPerFrame(); |
| offload_cfg.blocks_per_sdu = 1; |
| offload_cfg.stream_map.resize(subgroup.GetNumBis()); |
| |
| log::info( |
| "stream_map.size(): {}, sampling_rate: {}, frame_duration(us): {}, " |
| "octets_per_frame: {}, blocks_per_sdu {}, retransmission_number: {}, " |
| "max_transport_latency: {}", |
| supported_broadcast_config[broadcast_target_config].stream_map.size(), |
| supported_broadcast_config[broadcast_target_config].sampling_rate, |
| supported_broadcast_config[broadcast_target_config].frame_duration, |
| supported_broadcast_config[broadcast_target_config].octets_per_frame, |
| (int)supported_broadcast_config[broadcast_target_config].blocks_per_sdu, |
| (int)supported_broadcast_config[broadcast_target_config] |
| .retransmission_number, |
| supported_broadcast_config[broadcast_target_config] |
| .max_transport_latency); |
| } |
| |
| std::unique_ptr<broadcaster::BroadcastConfiguration> GetBroadcastConfig( |
| const CodecManager::BroadcastConfigurationRequirements& requirements) { |
| if (GetCodecLocation() != types::CodecLocation::ADSP) { |
| // Get the software supported broadcast configuration |
| return std::make_unique<broadcaster::BroadcastConfiguration>( |
| ::bluetooth::le_audio::broadcaster::GetBroadcastConfig( |
| requirements.subgroup_quality)); |
| } |
| |
| /* Subgroups with different audio qualities is not being supported now, |
| * if any subgroup preferred to use standard audio config, choose |
| * the standard audio config instead |
| */ |
| uint8_t BIG_audio_quality = bluetooth::le_audio::QUALITY_HIGH; |
| for (const auto& [_, quality] : requirements.subgroup_quality) { |
| if (quality == bluetooth::le_audio::QUALITY_STANDARD) { |
| BIG_audio_quality = bluetooth::le_audio::QUALITY_STANDARD; |
| } |
| } |
| |
| if (IsUsingCodecExtensibility()) { |
| log::assert_that(broadcast_local_source_hal_client != nullptr, |
| "audio source hal client is NULL"); |
| auto hal_config = broadcast_local_source_hal_client->GetBroadcastConfig( |
| requirements.subgroup_quality, requirements.sink_pacs); |
| if (hal_config.has_value()) { |
| UpdateBroadcastOffloadConfig(hal_config.value()); |
| return std::make_unique<broadcaster::BroadcastConfiguration>( |
| hal_config.value()); |
| } |
| |
| log::debug( |
| "No configuration received from AIDL, fall back to static " |
| "configuration."); |
| } |
| |
| auto offload_config = GetBroadcastOffloadConfig(BIG_audio_quality); |
| if (offload_config == nullptr) { |
| log::error("No Offload configuration supported for quality index: {}.", |
| BIG_audio_quality); |
| return nullptr; |
| } |
| |
| types::LeAudioLtvMap codec_params; |
| // Map sample freq. value to LE Audio codec specific config value |
| if (types::LeAudioCoreCodecConfig::sample_rate_map.count( |
| offload_config->sampling_rate)) { |
| codec_params.Add(codec_spec_conf::kLeAudioLtvTypeSamplingFreq, |
| types::LeAudioCoreCodecConfig::sample_rate_map.at( |
| offload_config->sampling_rate)); |
| } |
| // Map data interval value to LE Audio codec specific config value |
| if (types::LeAudioCoreCodecConfig::data_interval_map.count( |
| offload_config->frame_duration)) { |
| codec_params.Add(codec_spec_conf::kLeAudioLtvTypeFrameDuration, |
| types::LeAudioCoreCodecConfig::data_interval_map.at( |
| offload_config->frame_duration)); |
| } |
| codec_params.Add(codec_spec_conf::kLeAudioLtvTypeOctetsPerCodecFrame, |
| offload_config->octets_per_frame); |
| |
| // Note: We do not support a different channel count on each BIS within the |
| // same subgroup. |
| uint8_t allocated_channel_count = |
| offload_config->stream_map.size() |
| ? std::bitset<32>{offload_config->stream_map.at(0).second}.count() |
| : 1; |
| bluetooth::le_audio::broadcaster::BroadcastSubgroupCodecConfig codec_config( |
| bluetooth::le_audio::broadcaster::kLeAudioCodecIdLc3, |
| {bluetooth::le_audio::broadcaster::BroadcastSubgroupBisCodecConfig( |
| static_cast<uint8_t>(offload_config->stream_map.size()), |
| allocated_channel_count, codec_params)}, |
| offload_config->bits_per_sample); |
| |
| bluetooth::le_audio::broadcaster::BroadcastQosConfig qos_config( |
| offload_config->retransmission_number, |
| offload_config->max_transport_latency); |
| |
| // Change the default software encoder config data path ID |
| auto data_path = broadcaster::lc3_data_path; |
| data_path.dataPathId = |
| bluetooth::hci::iso_manager::kIsoDataPathPlatformDefault; |
| |
| uint16_t max_sdu_octets = 0; |
| for (auto [_, allocation] : offload_config->stream_map) { |
| auto alloc_channels_per_bis = std::bitset<32>{allocation}.count() ?: 1; |
| auto sdu_octets = offload_config->octets_per_frame * |
| offload_config->blocks_per_sdu * alloc_channels_per_bis; |
| if (max_sdu_octets < sdu_octets) max_sdu_octets = sdu_octets; |
| } |
| |
| if (requirements.subgroup_quality.size() > 1) { |
| log::error("More than one subgroup is not supported!"); |
| } |
| |
| return std::make_unique<broadcaster::BroadcastConfiguration>( |
| broadcaster::BroadcastConfiguration({ |
| .subgroups = {codec_config}, |
| .qos = qos_config, |
| .data_path = data_path, |
| .sduIntervalUs = offload_config->frame_duration, |
| .maxSduOctets = max_sdu_octets, |
| .phy = 0x02, // PHY_LE_2M |
| .packing = 0, // Sequential |
| .framing = 0 // Unframed, |
| })); |
| } |
| |
| void UpdateBroadcastConnHandle( |
| const std::vector<uint16_t>& conn_handle, |
| std::function< |
| void(const ::bluetooth::le_audio::broadcast_offload_config& config)> |
| update_receiver) { |
| if (GetCodecLocation() != le_audio::types::CodecLocation::ADSP) { |
| return; |
| } |
| |
| if (broadcast_target_config == -1 || |
| broadcast_target_config >= (int)supported_broadcast_config.size()) { |
| log::error("There is no valid broadcast offload config"); |
| return; |
| } |
| |
| auto broadcast_config = supported_broadcast_config[broadcast_target_config]; |
| log::assert_that(conn_handle.size() == broadcast_config.stream_map.size(), |
| "assert failed: conn_handle.size() == " |
| "broadcast_config.stream_map.size()"); |
| |
| if (broadcast_config.stream_map.size() == |
| LeAudioCodecConfiguration::kChannelNumberStereo) { |
| broadcast_config.stream_map[0] = std::pair<uint16_t, uint32_t>{ |
| conn_handle[0], codec_spec_conf::kLeAudioLocationFrontLeft}; |
| broadcast_config.stream_map[1] = std::pair<uint16_t, uint32_t>{ |
| conn_handle[1], codec_spec_conf::kLeAudioLocationFrontRight}; |
| } else if (broadcast_config.stream_map.size() == |
| LeAudioCodecConfiguration::kChannelNumberMono) { |
| broadcast_config.stream_map[0] = std::pair<uint16_t, uint32_t>{ |
| conn_handle[0], codec_spec_conf::kLeAudioLocationFrontCenter}; |
| } |
| |
| update_receiver(broadcast_config); |
| } |
| |
| void ClearCisConfiguration(uint8_t direction) { |
| if (GetCodecLocation() != bluetooth::le_audio::types::CodecLocation::ADSP) { |
| return; |
| } |
| |
| auto& stream_map = offloader_stream_maps.get(direction); |
| stream_map.streams_map_target.clear(); |
| stream_map.streams_map_current.clear(); |
| } |
| |
| static uint32_t AdjustAllocationForOffloader(uint32_t allocation) { |
| if ((allocation & codec_spec_conf::kLeAudioLocationAnyLeft) && |
| (allocation & codec_spec_conf::kLeAudioLocationAnyRight)) { |
| return codec_spec_conf::kLeAudioLocationStereo; |
| } |
| if (allocation & codec_spec_conf::kLeAudioLocationAnyLeft) { |
| return codec_spec_conf::kLeAudioLocationFrontLeft; |
| } |
| if (allocation & codec_spec_conf::kLeAudioLocationAnyRight) { |
| return codec_spec_conf::kLeAudioLocationFrontRight; |
| } |
| return 0; |
| } |
| |
| void UpdateCisConfiguration(const std::vector<struct types::cis>& cises, |
| const stream_parameters& stream_params, |
| uint8_t direction) { |
| if (GetCodecLocation() != bluetooth::le_audio::types::CodecLocation::ADSP) { |
| return; |
| } |
| |
| auto available_allocations = |
| AdjustAllocationForOffloader(stream_params.audio_channel_allocation); |
| if (available_allocations == 0) { |
| log::error("There is no CIS connected"); |
| return; |
| } |
| |
| auto& stream_map = offloader_stream_maps.get(direction); |
| if (stream_map.streams_map_target.empty()) { |
| stream_map.is_initial = true; |
| } else if (stream_map.is_initial || |
| LeAudioHalVerifier::SupportsStreamActiveApi()) { |
| /* As multiple CISes phone call case, the target_allocation already have |
| * the previous data, but the is_initial flag not be cleared. We need to |
| * clear here to avoid make duplicated target allocation stream map. */ |
| stream_map.streams_map_target.clear(); |
| } |
| |
| stream_map.streams_map_current.clear(); |
| stream_map.has_changed = true; |
| bool all_cises_connected = |
| (available_allocations == codec_spec_conf::kLeAudioLocationStereo); |
| |
| /* If all the cises are connected as stream started, reset changed_flag that |
| * the bt stack wouldn't send another audio configuration for the connection |
| * status. */ |
| if (stream_map.is_initial && all_cises_connected) { |
| stream_map.has_changed = false; |
| } |
| |
| const std::string tag = types::BidirectionalPair<std::string>( |
| {.sink = "Sink", .source = "Source"}) |
| .get(direction); |
| |
| constexpr types::BidirectionalPair<types::CisType> cis_types = { |
| .sink = types::CisType::CIS_TYPE_UNIDIRECTIONAL_SINK, |
| .source = types::CisType::CIS_TYPE_UNIDIRECTIONAL_SOURCE}; |
| auto cis_type = cis_types.get(direction); |
| |
| for (auto const& cis_entry : cises) { |
| if ((cis_entry.type == types::CisType::CIS_TYPE_BIDIRECTIONAL || |
| cis_entry.type == cis_type) && |
| cis_entry.conn_handle != 0) { |
| uint32_t target_allocation = 0; |
| uint32_t current_allocation = 0; |
| bool is_active = false; |
| for (const auto& s : stream_params.stream_locations) { |
| if (s.first == cis_entry.conn_handle) { |
| is_active = true; |
| target_allocation = AdjustAllocationForOffloader(s.second); |
| current_allocation = target_allocation; |
| if (!all_cises_connected) { |
| /* Tell offloader to mix on this CIS.*/ |
| current_allocation = codec_spec_conf::kLeAudioLocationStereo; |
| } |
| break; |
| } |
| } |
| |
| if (target_allocation == 0) { |
| /* Take missing allocation for that one .*/ |
| target_allocation = |
| codec_spec_conf::kLeAudioLocationStereo & ~available_allocations; |
| } |
| |
| log::info( |
| "{}: Cis handle 0x{:04x}, target allocation 0x{:08x}, current " |
| "allocation 0x{:08x}, active: {}", |
| tag, cis_entry.conn_handle, target_allocation, current_allocation, |
| is_active); |
| |
| if (stream_map.is_initial || |
| LeAudioHalVerifier::SupportsStreamActiveApi()) { |
| stream_map.streams_map_target.emplace_back(stream_map_info( |
| cis_entry.conn_handle, target_allocation, is_active)); |
| } |
| stream_map.streams_map_current.emplace_back(stream_map_info( |
| cis_entry.conn_handle, current_allocation, is_active)); |
| } |
| } |
| } |
| |
| private: |
| void SetCodecLocation(CodecLocation location) { |
| if (offload_enable_ == false) return; |
| codec_location_ = location; |
| } |
| |
| bool IsLc3ConfigMatched( |
| const set_configurations::CodecConfigSetting& target_config, |
| const set_configurations::CodecConfigSetting& adsp_config) { |
| if (adsp_config.id.coding_format != types::kLeAudioCodingFormatLC3 || |
| target_config.id.coding_format != types::kLeAudioCodingFormatLC3) { |
| return false; |
| } |
| |
| const types::LeAudioCoreCodecConfig adsp_lc3_config = |
| adsp_config.params.GetAsCoreCodecConfig(); |
| const types::LeAudioCoreCodecConfig target_lc3_config = |
| target_config.params.GetAsCoreCodecConfig(); |
| |
| if (adsp_lc3_config.sampling_frequency != |
| target_lc3_config.sampling_frequency || |
| adsp_lc3_config.frame_duration != target_lc3_config.frame_duration || |
| adsp_config.GetChannelCountPerIsoStream() != |
| target_config.GetChannelCountPerIsoStream() || |
| adsp_lc3_config.octets_per_codec_frame != |
| target_lc3_config.octets_per_codec_frame) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool IsAseConfigurationMatched(const AseConfiguration& software_ase_config, |
| const AseConfiguration& adsp_ase_config) { |
| // Skip the check of strategy due to ADSP doesn't have the info |
| return IsLc3ConfigMatched(software_ase_config.codec, adsp_ase_config.codec); |
| } |
| |
| bool IsAudioSetConfigurationMatched( |
| const AudioSetConfiguration* software_audio_set_conf, |
| std::unordered_set<uint8_t>& offload_preference_set, |
| const std::vector<AudioSetConfiguration>& adsp_capabilities) { |
| if (software_audio_set_conf->confs.sink.empty() && |
| software_audio_set_conf->confs.source.empty()) { |
| return false; |
| } |
| |
| // No match if the codec is not on the preference list |
| for (auto direction : {le_audio::types::kLeAudioDirectionSink, |
| le_audio::types::kLeAudioDirectionSource}) { |
| for (auto const& conf : software_audio_set_conf->confs.get(direction)) { |
| if (offload_preference_set.find(conf.codec.id.coding_format) == |
| offload_preference_set.end()) { |
| return false; |
| } |
| } |
| } |
| |
| // Checks any of offload config matches the input audio set config |
| for (const auto& adsp_audio_set_conf : adsp_capabilities) { |
| size_t match_cnt = 0; |
| size_t expected_match_cnt = 0; |
| |
| for (auto direction : {le_audio::types::kLeAudioDirectionSink, |
| le_audio::types::kLeAudioDirectionSource}) { |
| auto const& software_set_ase_confs = |
| software_audio_set_conf->confs.get(direction); |
| auto const& adsp_set_ase_confs = |
| adsp_audio_set_conf.confs.get(direction); |
| |
| if (!software_set_ase_confs.size() || !adsp_set_ase_confs.size()) { |
| continue; |
| } |
| |
| // Check for number of ASEs mismatch |
| if (adsp_set_ase_confs.size() != software_set_ase_confs.size()) { |
| log::error( |
| "{}: ADSP config size mismatches the software: {} != {}", |
| direction == types::kLeAudioDirectionSink ? "Sink" : "Source", |
| adsp_set_ase_confs.size(), software_set_ase_confs.size()); |
| continue; |
| } |
| |
| // The expected number of ASE configs, the ADSP config needs to match |
| expected_match_cnt += software_set_ase_confs.size(); |
| if (expected_match_cnt == 0) { |
| continue; |
| } |
| |
| // Check for matching configs |
| for (auto const& adsp_set_conf : adsp_set_ase_confs) { |
| for (auto const& software_set_conf : software_set_ase_confs) { |
| if (IsAseConfigurationMatched(software_set_conf, adsp_set_conf)) { |
| match_cnt++; |
| // Check the next adsp config if the first software config matches |
| break; |
| } |
| } |
| } |
| if (match_cnt != expected_match_cnt) { |
| break; |
| } |
| } |
| |
| // Check the match count |
| if (match_cnt == expected_match_cnt) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| std::string getStrategyString(types::LeAudioConfigurationStrategy strategy) { |
| switch (strategy) { |
| case types::LeAudioConfigurationStrategy::MONO_ONE_CIS_PER_DEVICE: |
| return "MONO_ONE_CIS_PER_DEVICE"; |
| case types::LeAudioConfigurationStrategy::STEREO_TWO_CISES_PER_DEVICE: |
| return "STEREO_TWO_CISES_PER_DEVICE"; |
| case types::LeAudioConfigurationStrategy::STEREO_ONE_CIS_PER_DEVICE: |
| return "STEREO_ONE_CIS_PER_DEVICE"; |
| default: |
| return "RFU"; |
| } |
| } |
| |
| uint8_t sampleFreqToBluetoothSigBitMask(int sample_freq) { |
| switch (sample_freq) { |
| case 8000: |
| return bluetooth::le_audio::codec_spec_caps::kLeAudioSamplingFreq8000Hz; |
| case 16000: |
| return bluetooth::le_audio::codec_spec_caps:: |
| kLeAudioSamplingFreq16000Hz; |
| case 24000: |
| return bluetooth::le_audio::codec_spec_caps:: |
| kLeAudioSamplingFreq24000Hz; |
| case 32000: |
| return bluetooth::le_audio::codec_spec_caps:: |
| kLeAudioSamplingFreq32000Hz; |
| case 44100: |
| return bluetooth::le_audio::codec_spec_caps:: |
| kLeAudioSamplingFreq44100Hz; |
| case 48000: |
| return bluetooth::le_audio::codec_spec_caps:: |
| kLeAudioSamplingFreq48000Hz; |
| } |
| return bluetooth::le_audio::codec_spec_caps::kLeAudioSamplingFreq8000Hz; |
| } |
| |
| void storeLocalCapa( |
| std::vector< |
| ::bluetooth::le_audio::set_configurations::AudioSetConfiguration>& |
| adsp_capabilities, |
| const std::vector<btle_audio_codec_config_t>& offload_preference_set) { |
| log::debug("Print adsp_capabilities:"); |
| |
| for (auto& adsp : adsp_capabilities) { |
| log::debug("'{}':", adsp.name); |
| for (auto direction : {le_audio::types::kLeAudioDirectionSink, |
| le_audio::types::kLeAudioDirectionSource}) { |
| log::debug( |
| "dir: {}: number of confs {}:", |
| direction == types::kLeAudioDirectionSink ? "sink" : "source", |
| (int)(adsp.confs.get(direction).size())); |
| for (auto conf : adsp.confs.sink) { |
| log::debug( |
| "codecId: {}, sample_freq: {}, interval {}, channel_cnt: {}", |
| conf.codec.id.coding_format, conf.codec.GetSamplingFrequencyHz(), |
| conf.codec.GetDataIntervalUs(), |
| conf.codec.GetChannelCountPerIsoStream()); |
| |
| /* TODO: How to get bits_per_sample ? */ |
| btle_audio_codec_config_t capa_to_add = { |
| .codec_type = (conf.codec.id.coding_format == |
| types::kLeAudioCodingFormatLC3) |
| ? btle_audio_codec_index_t:: |
| LE_AUDIO_CODEC_INDEX_SOURCE_LC3 |
| : btle_audio_codec_index_t:: |
| LE_AUDIO_CODEC_INDEX_SOURCE_INVALID, |
| .sample_rate = utils::translateToBtLeAudioCodecConfigSampleRate( |
| conf.codec.GetSamplingFrequencyHz()), |
| .bits_per_sample = |
| utils::translateToBtLeAudioCodecConfigBitPerSample(16), |
| .channel_count = |
| utils::translateToBtLeAudioCodecConfigChannelCount( |
| conf.codec.GetChannelCountPerIsoStream()), |
| .frame_duration = |
| utils::translateToBtLeAudioCodecConfigFrameDuration( |
| conf.codec.GetDataIntervalUs()), |
| }; |
| |
| auto& capa_container = (direction == types::kLeAudioDirectionSink) |
| ? codec_output_capa |
| : codec_input_capa; |
| if (std::find(capa_container.begin(), capa_container.end(), |
| capa_to_add) == capa_container.end()) { |
| log::debug("Adding {} capa {}", |
| (direction == types::kLeAudioDirectionSink) ? "output" |
| : "input", |
| static_cast<int>(capa_container.size())); |
| capa_container.push_back(capa_to_add); |
| } |
| } |
| } |
| } |
| |
| log::debug("Output capa: {}, Input capa: {}", |
| static_cast<int>(codec_output_capa.size()), |
| static_cast<int>(codec_input_capa.size())); |
| |
| log::debug("Print offload_preference_set: {}", |
| (int)(offload_preference_set.size())); |
| |
| int i = 0; |
| for (auto set : offload_preference_set) { |
| log::debug("set {}, {}", i++, set.ToString()); |
| } |
| } |
| |
| void UpdateOffloadCapability( |
| const std::vector<btle_audio_codec_config_t>& offloading_preference) { |
| log::info(""); |
| std::unordered_set<uint8_t> offload_preference_set; |
| |
| if (AudioSetConfigurationProvider::Get() == nullptr) { |
| log::error("Audio set configuration provider is not available."); |
| return; |
| } |
| |
| auto adsp_capabilities = |
| ::bluetooth::audio::le_audio::get_offload_capabilities(); |
| |
| storeLocalCapa(adsp_capabilities.unicast_offload_capabilities, |
| offloading_preference); |
| |
| for (auto codec : offloading_preference) { |
| auto it = btle_audio_codec_type_map_.find(codec.codec_type); |
| |
| if (it != btle_audio_codec_type_map_.end()) { |
| offload_preference_set.insert(it->second); |
| } |
| } |
| |
| for (types::LeAudioContextType ctx_type : |
| types::kLeAudioContextAllTypesArray) { |
| // Gets the software supported context type and the corresponding config |
| // priority |
| const AudioSetConfigurations* software_audio_set_confs = |
| AudioSetConfigurationProvider::Get()->GetConfigurations(ctx_type); |
| |
| for (const auto& software_audio_set_conf : *software_audio_set_confs) { |
| if (IsAudioSetConfigurationMatched( |
| software_audio_set_conf, offload_preference_set, |
| adsp_capabilities.unicast_offload_capabilities)) { |
| log::info("Offload supported conf, context type: {}, settings -> {}", |
| (int)ctx_type, software_audio_set_conf->name); |
| if (dual_bidirection_swb_supported_ && |
| AudioSetConfigurationProvider::Get() |
| ->CheckConfigurationIsDualBiDirSwb( |
| *software_audio_set_conf)) { |
| offload_dual_bidirection_swb_supported_ = true; |
| } |
| context_type_offload_config_map_[ctx_type].push_back( |
| software_audio_set_conf); |
| } |
| } |
| } |
| UpdateSupportedBroadcastConfig( |
| adsp_capabilities.broadcast_offload_capabilities); |
| } |
| |
| CodecLocation codec_location_ = CodecLocation::HOST; |
| bool offload_enable_ = false; |
| bool offload_dual_bidirection_swb_supported_ = false; |
| bool dual_bidirection_swb_supported_ = false; |
| types::BidirectionalPair<offloader_stream_maps_t> offloader_stream_maps; |
| std::vector<bluetooth::le_audio::broadcast_offload_config> |
| supported_broadcast_config; |
| std::unordered_map<types::LeAudioContextType, AudioSetConfigurations> |
| context_type_offload_config_map_; |
| std::unordered_map<btle_audio_codec_index_t, uint8_t> |
| btle_audio_codec_type_map_ = { |
| {::bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3, |
| types::kLeAudioCodingFormatLC3}}; |
| |
| std::vector<btle_audio_codec_config_t> codec_input_capa = {}; |
| std::vector<btle_audio_codec_config_t> codec_output_capa = {}; |
| int broadcast_target_config = -1; |
| |
| LeAudioSourceAudioHalClient* unicast_local_source_hal_client = nullptr; |
| LeAudioSinkAudioHalClient* unicast_local_sink_hal_client = nullptr; |
| LeAudioSourceAudioHalClient* broadcast_local_source_hal_client = nullptr; |
| }; |
| |
| std::ostream& operator<<( |
| std::ostream& os, |
| const CodecManager::UnicastConfigurationRequirements& req) { |
| os << "{audio context type: " << req.audio_context_type; |
| if (req.sink_pacs.has_value()) { |
| os << ", sink_pacs: ["; |
| for (auto const& pac : req.sink_pacs.value()) { |
| os << "sink_pac: {"; |
| os << ", codec_id: " << pac.codec_id; |
| os << ", caps size: " << pac.codec_spec_caps.Size(); |
| os << ", caps_raw size: " << pac.codec_spec_caps_raw.size(); |
| os << ", caps_raw size: " << pac.metadata.size(); |
| os << "}, "; |
| } |
| os << "\b\b]"; |
| } else { |
| os << ", sink_pacs: " |
| << "None"; |
| } |
| |
| if (req.source_pacs.has_value()) { |
| os << ", source_pacs: ["; |
| for (auto const& pac : req.source_pacs.value()) { |
| os << "source_pac: {"; |
| os << ", codec_id: " << pac.codec_id; |
| os << ", caps size: " << pac.codec_spec_caps.Size(); |
| os << ", caps_raw size: " << pac.codec_spec_caps_raw.size(); |
| os << ", caps_raw size: " << pac.metadata.size(); |
| os << "}, "; |
| } |
| os << "\b\b]"; |
| } else { |
| os << ", source_pacs: " |
| << "None"; |
| } |
| |
| if (req.sink_requirements.has_value()) { |
| for (auto const& sink_req : req.sink_requirements.value()) { |
| os << "sink_req: {"; |
| os << ", target_latency: " << +sink_req.target_latency; |
| os << ", target_Phy: " << +sink_req.target_Phy; |
| // os << sink_req.params.GetAsCoreCodecCapabilities(); |
| os << "}"; |
| } |
| } else { |
| os << "sink_req: None"; |
| } |
| |
| if (req.source_requirements.has_value()) { |
| for (auto const& source_req : req.source_requirements.value()) { |
| os << "source_req: {"; |
| os << ", target_latency: " << +source_req.target_latency; |
| os << ", target_Phy: " << +source_req.target_Phy; |
| // os << source_req.params.GetAsCoreCodecCapabilities(); |
| os << "}"; |
| } |
| } else { |
| os << "source_req: None"; |
| } |
| |
| os << "}"; |
| return os; |
| } |
| |
| struct CodecManager::impl { |
| impl(const CodecManager& codec_manager) : codec_manager_(codec_manager) {} |
| |
| void Start( |
| const std::vector<btle_audio_codec_config_t>& offloading_preference) { |
| log::assert_that(!codec_manager_impl_, |
| "assert failed: !codec_manager_impl_"); |
| codec_manager_impl_ = std::make_unique<codec_manager_impl>(); |
| codec_manager_impl_->start(offloading_preference); |
| } |
| |
| void Stop() { |
| log::assert_that(codec_manager_impl_ != nullptr, |
| "assert failed: codec_manager_impl_ != nullptr"); |
| codec_manager_impl_.reset(); |
| } |
| |
| bool IsRunning() { return codec_manager_impl_ ? true : false; } |
| |
| const CodecManager& codec_manager_; |
| std::unique_ptr<codec_manager_impl> codec_manager_impl_; |
| }; |
| |
| CodecManager::CodecManager() : pimpl_(std::make_unique<impl>(*this)) {} |
| |
| void CodecManager::Start( |
| const std::vector<btle_audio_codec_config_t>& offloading_preference) { |
| if (!pimpl_->IsRunning()) pimpl_->Start(offloading_preference); |
| } |
| |
| void CodecManager::Stop() { |
| if (pimpl_->IsRunning()) pimpl_->Stop(); |
| } |
| |
| types::CodecLocation CodecManager::GetCodecLocation(void) const { |
| if (!pimpl_->IsRunning()) { |
| return CodecLocation::HOST; |
| } |
| |
| return pimpl_->codec_manager_impl_->GetCodecLocation(); |
| } |
| |
| bool CodecManager::IsDualBiDirSwbSupported(void) const { |
| if (!pimpl_->IsRunning()) { |
| return false; |
| } |
| |
| return pimpl_->codec_manager_impl_->IsDualBiDirSwbSupported(); |
| } |
| |
| std::vector<bluetooth::le_audio::btle_audio_codec_config_t> |
| CodecManager::GetLocalAudioOutputCodecCapa() { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->GetLocalAudioOutputCodecCapa(); |
| } |
| |
| std::vector<bluetooth::le_audio::btle_audio_codec_config_t> empty{}; |
| return empty; |
| } |
| |
| std::vector<bluetooth::le_audio::btle_audio_codec_config_t> |
| CodecManager::GetLocalAudioInputCodecCapa() { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->GetLocalAudioOutputCodecCapa(); |
| } |
| std::vector<bluetooth::le_audio::btle_audio_codec_config_t> empty{}; |
| return empty; |
| } |
| |
| void CodecManager::UpdateActiveAudioConfig( |
| const types::BidirectionalPair<stream_parameters>& stream_params, |
| types::BidirectionalPair<uint16_t> delays_ms, |
| std::function<void(const offload_config& config, uint8_t direction)> |
| update_receiver) { |
| if (pimpl_->IsRunning()) |
| pimpl_->codec_manager_impl_->UpdateActiveAudioConfig( |
| stream_params, delays_ms, update_receiver); |
| } |
| |
| bool CodecManager::UpdateActiveUnicastAudioHalClient( |
| LeAudioSourceAudioHalClient* source_unicast_client, |
| LeAudioSinkAudioHalClient* sink_unicast_client, bool is_active) { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->UpdateActiveUnicastAudioHalClient( |
| source_unicast_client, sink_unicast_client, is_active); |
| } |
| return false; |
| } |
| |
| bool CodecManager::UpdateActiveBroadcastAudioHalClient( |
| LeAudioSourceAudioHalClient* source_broadcast_client, bool is_active) { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->UpdateActiveBroadcastAudioHalClient( |
| source_broadcast_client, is_active); |
| } |
| return false; |
| } |
| |
| std::unique_ptr<AudioSetConfiguration> CodecManager::GetCodecConfig( |
| const CodecManager::UnicastConfigurationRequirements& requirements, |
| CodecManager::UnicastConfigurationVerifier verifier) { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->GetCodecConfig(requirements, verifier); |
| } |
| |
| return nullptr; |
| } |
| |
| bool CodecManager::CheckCodecConfigIsBiDirSwb( |
| const set_configurations::AudioSetConfiguration& config) const { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->CheckCodecConfigIsBiDirSwb(config); |
| } |
| return false; |
| } |
| |
| bool CodecManager::CheckCodecConfigIsDualBiDirSwb( |
| const set_configurations::AudioSetConfiguration& config) const { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->CheckCodecConfigIsDualBiDirSwb(config); |
| } |
| return false; |
| } |
| |
| std::unique_ptr<broadcaster::BroadcastConfiguration> |
| CodecManager::GetBroadcastConfig( |
| const CodecManager::BroadcastConfigurationRequirements& requirements) |
| const { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->GetBroadcastConfig(requirements); |
| } |
| |
| return nullptr; |
| } |
| |
| void CodecManager::UpdateBroadcastConnHandle( |
| const std::vector<uint16_t>& conn_handle, |
| std::function< |
| void(const ::bluetooth::le_audio::broadcast_offload_config& config)> |
| update_receiver) { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->UpdateBroadcastConnHandle( |
| conn_handle, update_receiver); |
| } |
| } |
| |
| void CodecManager::UpdateCisConfiguration( |
| const std::vector<struct types::cis>& cises, |
| const stream_parameters& stream_params, uint8_t direction) { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->UpdateCisConfiguration( |
| cises, stream_params, direction); |
| } |
| } |
| |
| void CodecManager::ClearCisConfiguration(uint8_t direction) { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->ClearCisConfiguration(direction); |
| } |
| } |
| |
| bool CodecManager::IsUsingCodecExtensibility() const { |
| if (pimpl_->IsRunning()) { |
| return pimpl_->codec_manager_impl_->IsUsingCodecExtensibility(); |
| } |
| return false; |
| } |
| |
| } // namespace bluetooth::le_audio |
