Merge "Parse broadcast offload capabilities" (47c304ee) · Commits · e / os / android_hardware_interfaces

bluetooth/audio/aidl/vts/VtsHalBluetoothAudioTargetTest.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -1566,6 +1566,7 @@ TEST_P(BluetoothAudioProviderLeAudioBroadcastHardwareAidl,
		};

		for (auto& lc3_config : lc3_codec_configs) {
		le_audio_broadcast_config.streamMap.resize(1);
		le_audio_broadcast_config.streamMap[0]
		.leAudioCodecConfig.set<LeAudioCodecConfiguration::lc3Config>(
		lc3_config);

bluetooth/audio/utils/aidl_session/BluetoothLeAudioCodecsProvider.cpp

+64 −4

Original line number	Diff line number	Diff line
		@@ -200,13 +200,21 @@ BluetoothLeAudioCodecsProvider::ComposeLeAudioCodecCapabilities(
		GetUnicastCapability(scenario.getEncode());
		UnicastCapability unicast_decode_capability =
		GetUnicastCapability(scenario.getDecode());
		// encode and decode cannot be unknown at the same time
		BroadcastCapability broadcast_capability = {.codecType =
		CodecType::UNKNOWN};

		if (scenario.hasBroadcast()) {
		broadcast_capability = GetBroadcastCapability(scenario.getBroadcast());
		}

		// At least one capability should be valid
		if (unicast_encode_capability.codecType == CodecType::UNKNOWN &&
		unicast_decode_capability.codecType == CodecType::UNKNOWN) {
		unicast_decode_capability.codecType == CodecType::UNKNOWN &&
		broadcast_capability.codecType == CodecType::UNKNOWN) {
		LOG(ERROR) << __func__ << ": None of the capability is valid.";
		continue;
		}
		BroadcastCapability broadcast_capability = {.codecType =
		CodecType::UNKNOWN};

		le_audio_codec_capabilities.push_back(
		{.unicastEncodeCapability = unicast_encode_capability,
		.unicastDecodeCapability = unicast_decode_capability,
		@@ -252,6 +260,54 @@ UnicastCapability BluetoothLeAudioCodecsProvider::GetUnicastCapability(
		return {.codecType = CodecType::UNKNOWN};
		}

		BroadcastCapability BluetoothLeAudioCodecsProvider::GetBroadcastCapability(
		const std::string& coding_direction) {
		if (coding_direction == "invalid") {
		return {.codecType = CodecType::UNKNOWN};
		}

		auto configuration_iter = configuration_map_.find(coding_direction);
		if (configuration_iter == configuration_map_.end()) {
		return {.codecType = CodecType::UNKNOWN};
		}

		auto codec_configuration_iter = codec_configuration_map_.find(
		configuration_iter->second.getCodecConfiguration());
		if (codec_configuration_iter == codec_configuration_map_.end()) {
		return {.codecType = CodecType::UNKNOWN};
		}

		auto strategy_configuration_iter = strategy_configuration_map_.find(
		configuration_iter->second.getStrategyConfiguration());
		if (strategy_configuration_iter == strategy_configuration_map_.end()) {
		return {.codecType = CodecType::UNKNOWN};
		}

		CodecType codec_type =
		GetCodecType(codec_configuration_iter->second.getCodec());
		std::vector<std::optional<Lc3Capabilities>> bcastLc3Cap(
		1, std::optional(ComposeLc3Capability(codec_configuration_iter->second)));

		if (codec_type == CodecType::LC3) {
		return ComposeBroadcastCapability(
		codec_type,
		GetAudioLocation(
		strategy_configuration_iter->second.getAudioLocation()),
		strategy_configuration_iter->second.getChannelCount(), bcastLc3Cap);
		}
		return {.codecType = CodecType::UNKNOWN};
		}

		template <class T>
		BroadcastCapability BluetoothLeAudioCodecsProvider::ComposeBroadcastCapability(
		const CodecType& codec_type, const AudioLocation& audio_location,
		const uint8_t& channel_count, const std::vector<T>& capability) {
		return {.codecType = codec_type,
		.supportedChannel = audio_location,
		.channelCountPerStream = channel_count,
		.leAudioCodecCapabilities = std::optional(capability)};
		}

		template <class T>
		UnicastCapability BluetoothLeAudioCodecsProvider::ComposeUnicastCapability(
		const CodecType& codec_type, const AudioLocation& audio_location,
		@@ -322,6 +378,10 @@ bool BluetoothLeAudioCodecsProvider::IsValidStrategyConfiguration(
		// 1. two connected device, one for L one for R
		// 2. one connected device for both L and R
		return true;
		} else if (strategy_configuration.getConnectedDevice() == 0 &&
		strategy_configuration.getChannelCount() == 2) {
		// Broadcast
		return true;
		}
		} else if (strategy_configuration.getAudioLocation() ==
		setting::AudioLocation::MONO) {

bluetooth/audio/utils/aidl_session/BluetoothLeAudioCodecsProvider.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@
		#include <android-base/logging.h>

		#include <unordered_map>
		#include <vector>

		#include "aidl_android_hardware_bluetooth_audio_setting.h"

		@@ -66,12 +67,20 @@ class BluetoothLeAudioCodecsProvider {

		static UnicastCapability GetUnicastCapability(
		const std::string& coding_direction);
		static BroadcastCapability GetBroadcastCapability(
		const std::string& coding_direction);

		template <class T>
		static inline UnicastCapability ComposeUnicastCapability(
		const CodecType& codec_type, const AudioLocation& audio_location,
		const uint8_t& device_cnt, const uint8_t& channel_count,
		const T& capability);

		template <class T>
		static inline BroadcastCapability ComposeBroadcastCapability(
		const CodecType& codec_type, const AudioLocation& audio_location,
		const uint8_t& channel_count, const std::vector<T>& capability);

		static inline Lc3Capabilities ComposeLc3Capability(
		const setting::CodecConfiguration& codec_configuration);

bluetooth/audio/utils/aidl_session/BluetoothLeAudioCodecsProviderTest.cpp

+19 −9

Original line number	Diff line number	Diff line
		@@ -46,7 +46,11 @@ typedef std::tuple<std::vector<ScenarioList>, std::vector<ConfigurationList>,
		// Define valid components for each list
		// Scenario
		static const Scenario kValidScenario(std::make_optional("OneChanStereo_16_1"),
		std::make_optional("OneChanStereo_16_1"));
		std::make_optional("OneChanStereo_16_1"),
		std::nullopt);
		static const Scenario kValidBroadcastScenario(
		std::nullopt, std::nullopt, std::make_optional("BcastStereo_16_2"));

		// Configuration
		static const Configuration kValidConfigOneChanStereo_16_1(
		std::make_optional("OneChanStereo_16_1"), std::make_optional("LC3_16k_1"),
		@@ -69,11 +73,15 @@ static const StrategyConfiguration kValidStrategyMonoOneCis(
		std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
		std::make_optional(AudioLocation::MONO), std::make_optional(1),
		std::make_optional(1));
		static const StrategyConfiguration kValidStrategyBroadcastStereo(
		std::make_optional("BROADCAST_STEREO"),
		std::make_optional(AudioLocation::STEREO), std::make_optional(0),
		std::make_optional(2));

		// Define valid test list built from above valid components
		// Scenario, Configuration, CodecConfiguration, StrategyConfiguration
		static const std::vector<ScenarioList> kValidScenarioList = {
		ScenarioList(std::vector<Scenario>{kValidScenario})};
		static const std::vector<ScenarioList> kValidScenarioList = {ScenarioList(
		std::vector<Scenario>{kValidScenario, kValidBroadcastScenario})};
		static const std::vector<ConfigurationList> kValidConfigurationList = {
		ConfigurationList(
		std::vector<Configuration>{kValidConfigOneChanStereo_16_1})};
		@@ -84,7 +92,7 @@ static const std::vector<StrategyConfigurationList>
		kValidStrategyConfigurationList = {
		StrategyConfigurationList(std::vector<StrategyConfiguration>{
		kValidStrategyStereoOneCis, kValidStrategyStereoTwoCis,
		kValidStrategyMonoOneCis})};
		kValidStrategyMonoOneCis, kValidStrategyBroadcastStereo})};

		class BluetoothLeAudioCodecsProviderTest
		: public ::testing::TestWithParam<OffloadSetting> {
		@@ -151,13 +159,15 @@ class GetScenariosTest : public BluetoothLeAudioCodecsProviderTest {
		static std::vector<ScenarioList> CreateInvalidScenarios() {
		std::vector<ScenarioList> invalid_scenario_test_cases;
		invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
		Scenario(std::nullopt, std::make_optional("OneChanStereo_16_1"))}));

		invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
		Scenario(std::make_optional("OneChanStereo_16_1"), std::nullopt)}));
		Scenario(std::nullopt, std::make_optional("OneChanStereo_16_1"),
		std::nullopt)}));

		invalid_scenario_test_cases.push_back(ScenarioList(
		std::vector<Scenario>{Scenario(std::nullopt, std::nullopt)}));
		std::vector<Scenario>{Scenario(std::make_optional("OneChanStereo_16_1"),
		std::nullopt, std::nullopt)}));

		invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
		Scenario(std::nullopt, std::nullopt, std::nullopt)}));

		invalid_scenario_test_cases.push_back(
		ScenarioList(std::vector<Scenario>{}));

bluetooth/audio/utils/le_audio_codec_capabilities/le_audio_codec_capabilities.xml

+4 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,8 @@
		<scenario encode="OneChanStereo_16_2" decode="OneChanMono_16_2"/>
		<scenario encode="TwoChanStereo_16_2" decode="OneChanMono_16_2"/>
		<scenario encode="OneChanMono_16_2" decode="OneChanMono_16_2"/>
		<!-- broadcast -->
		<scenario encode="invalid" decode="invalid" broadcast="BcastStereo_16_2"/>
		</scenarioList>
		<configurationList>
		<configuration name="OneChanMono_16_1" codecConfiguration="LC3_16k_1" strategyConfiguration="MONO_ONE_CIS_PER_DEVICE"/>
		@@ -48,6 +50,7 @@
		<configuration name="OneChanMono_16_2" codecConfiguration="LC3_16k_2" strategyConfiguration="MONO_ONE_CIS_PER_DEVICE"/>
		<configuration name="TwoChanStereo_16_2" codecConfiguration="LC3_16k_2" strategyConfiguration="STEREO_TWO_CISES_PER_DEVICE"/>
		<configuration name="OneChanStereo_16_2" codecConfiguration="LC3_16k_2" strategyConfiguration="STEREO_ONE_CIS_PER_DEVICE"/>
		<configuration name="BcastStereo_16_2" codecConfiguration="LC3_16k_2" strategyConfiguration="BROADCAST_STEREO"/>
		</configurationList>
		<codecConfigurationList>
		<codecConfiguration name="LC3_16k_1" codec="LC3" samplingFrequency="16000" frameDurationUs="7500" octetsPerCodecFrame="30"/>
		@@ -57,5 +60,6 @@
		<strategyConfiguration name="STEREO_ONE_CIS_PER_DEVICE" audioLocation="STEREO" connectedDevice="2" channelCount="1"/>
		<strategyConfiguration name="STEREO_TWO_CISES_PER_DEVICE" audioLocation="STEREO" connectedDevice="1" channelCount="2"/>
		<strategyConfiguration name="MONO_ONE_CIS_PER_DEVICE" audioLocation="MONO" connectedDevice="1" channelCount="1"/>
		<strategyConfiguration name="BROADCAST_STEREO" audioLocation="STEREO" connectedDevice="0" channelCount="2"/>
		</strategyConfigurationList>
		</leAudioOffloadSetting>