1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "BTAudioCodecsProviderAidl"
18
19 #include "BluetoothLeAudioCodecsProvider.h"
20
21 namespace aidl {
22 namespace android {
23 namespace hardware {
24 namespace bluetooth {
25 namespace audio {
26
27 static const char* kLeAudioCodecCapabilitiesFile =
28 "/vendor/etc/le_audio_codec_capabilities.xml";
29
30 static const AudioLocation kStereoAudio = static_cast<AudioLocation>(
31 static_cast<uint8_t>(AudioLocation::FRONT_LEFT) |
32 static_cast<uint8_t>(AudioLocation::FRONT_RIGHT));
33 static const AudioLocation kMonoAudio = AudioLocation::UNKNOWN;
34
35 static std::vector<LeAudioCodecCapabilitiesSetting> leAudioCodecCapabilities;
36
37 static bool isInvalidFileContent = false;
38
39 std::optional<setting::LeAudioOffloadSetting>
ParseFromLeAudioOffloadSettingFile()40 BluetoothLeAudioCodecsProvider::ParseFromLeAudioOffloadSettingFile() {
41 if (!leAudioCodecCapabilities.empty() || isInvalidFileContent) {
42 return std::nullopt;
43 }
44 auto le_audio_offload_setting =
45 setting::readLeAudioOffloadSetting(kLeAudioCodecCapabilitiesFile);
46 if (!le_audio_offload_setting.has_value()) {
47 LOG(ERROR) << __func__ << ": Failed to read "
48 << kLeAudioCodecCapabilitiesFile;
49 }
50 return le_audio_offload_setting;
51 }
52
53 std::vector<LeAudioCodecCapabilitiesSetting>
GetLeAudioCodecCapabilities(const std::optional<setting::LeAudioOffloadSetting> & le_audio_offload_setting)54 BluetoothLeAudioCodecsProvider::GetLeAudioCodecCapabilities(
55 const std::optional<setting::LeAudioOffloadSetting>&
56 le_audio_offload_setting) {
57 if (!leAudioCodecCapabilities.empty()) {
58 return leAudioCodecCapabilities;
59 }
60
61 if (!le_audio_offload_setting.has_value()) {
62 LOG(ERROR)
63 << __func__
64 << ": input le_audio_offload_setting content need to be non empty";
65 return {};
66 }
67
68 ClearLeAudioCodecCapabilities();
69 isInvalidFileContent = true;
70
71 std::vector<setting::Scenario> supported_scenarios =
72 GetScenarios(le_audio_offload_setting);
73 if (supported_scenarios.empty()) {
74 LOG(ERROR) << __func__ << ": No scenarios in "
75 << kLeAudioCodecCapabilitiesFile;
76 return {};
77 }
78
79 UpdateConfigurationsToMap(le_audio_offload_setting);
80 if (configuration_map_.empty()) {
81 LOG(ERROR) << __func__ << ": No configurations in "
82 << kLeAudioCodecCapabilitiesFile;
83 return {};
84 }
85
86 UpdateCodecConfigurationsToMap(le_audio_offload_setting);
87 if (codec_configuration_map_.empty()) {
88 LOG(ERROR) << __func__ << ": No codec configurations in "
89 << kLeAudioCodecCapabilitiesFile;
90 return {};
91 }
92
93 UpdateStrategyConfigurationsToMap(le_audio_offload_setting);
94 if (strategy_configuration_map_.empty()) {
95 LOG(ERROR) << __func__ << ": No strategy configurations in "
96 << kLeAudioCodecCapabilitiesFile;
97 return {};
98 }
99
100 leAudioCodecCapabilities =
101 ComposeLeAudioCodecCapabilities(supported_scenarios);
102 isInvalidFileContent = leAudioCodecCapabilities.empty();
103
104 return leAudioCodecCapabilities;
105 }
106
ClearLeAudioCodecCapabilities()107 void BluetoothLeAudioCodecsProvider::ClearLeAudioCodecCapabilities() {
108 leAudioCodecCapabilities.clear();
109 configuration_map_.clear();
110 codec_configuration_map_.clear();
111 strategy_configuration_map_.clear();
112 }
113
GetScenarios(const std::optional<setting::LeAudioOffloadSetting> & le_audio_offload_setting)114 std::vector<setting::Scenario> BluetoothLeAudioCodecsProvider::GetScenarios(
115 const std::optional<setting::LeAudioOffloadSetting>&
116 le_audio_offload_setting) {
117 std::vector<setting::Scenario> supported_scenarios;
118 if (le_audio_offload_setting->hasScenarioList()) {
119 for (const auto& scenario_list :
120 le_audio_offload_setting->getScenarioList()) {
121 if (!scenario_list.hasScenario()) {
122 continue;
123 }
124 for (const auto& scenario : scenario_list.getScenario()) {
125 if (scenario.hasEncode() && scenario.hasDecode()) {
126 supported_scenarios.push_back(scenario);
127 }
128 }
129 }
130 }
131 return supported_scenarios;
132 }
133
UpdateConfigurationsToMap(const std::optional<setting::LeAudioOffloadSetting> & le_audio_offload_setting)134 void BluetoothLeAudioCodecsProvider::UpdateConfigurationsToMap(
135 const std::optional<setting::LeAudioOffloadSetting>&
136 le_audio_offload_setting) {
137 if (le_audio_offload_setting->hasConfigurationList()) {
138 for (const auto& configuration_list :
139 le_audio_offload_setting->getConfigurationList()) {
140 if (!configuration_list.hasConfiguration()) {
141 continue;
142 }
143 for (const auto& configuration : configuration_list.getConfiguration()) {
144 if (configuration.hasName() && configuration.hasCodecConfiguration() &&
145 configuration.hasStrategyConfiguration()) {
146 configuration_map_.insert(
147 make_pair(configuration.getName(), configuration));
148 }
149 }
150 }
151 }
152 }
153
UpdateCodecConfigurationsToMap(const std::optional<setting::LeAudioOffloadSetting> & le_audio_offload_setting)154 void BluetoothLeAudioCodecsProvider::UpdateCodecConfigurationsToMap(
155 const std::optional<setting::LeAudioOffloadSetting>&
156 le_audio_offload_setting) {
157 if (le_audio_offload_setting->hasCodecConfigurationList()) {
158 for (const auto& codec_configuration_list :
159 le_audio_offload_setting->getCodecConfigurationList()) {
160 if (!codec_configuration_list.hasCodecConfiguration()) {
161 continue;
162 }
163 for (const auto& codec_configuration :
164 codec_configuration_list.getCodecConfiguration()) {
165 if (IsValidCodecConfiguration(codec_configuration)) {
166 codec_configuration_map_.insert(
167 make_pair(codec_configuration.getName(), codec_configuration));
168 }
169 }
170 }
171 }
172 }
173
UpdateStrategyConfigurationsToMap(const std::optional<setting::LeAudioOffloadSetting> & le_audio_offload_setting)174 void BluetoothLeAudioCodecsProvider::UpdateStrategyConfigurationsToMap(
175 const std::optional<setting::LeAudioOffloadSetting>&
176 le_audio_offload_setting) {
177 if (le_audio_offload_setting->hasStrategyConfigurationList()) {
178 for (const auto& strategy_configuration_list :
179 le_audio_offload_setting->getStrategyConfigurationList()) {
180 if (!strategy_configuration_list.hasStrategyConfiguration()) {
181 continue;
182 }
183 for (const auto& strategy_configuration :
184 strategy_configuration_list.getStrategyConfiguration()) {
185 if (IsValidStrategyConfiguration(strategy_configuration)) {
186 strategy_configuration_map_.insert(make_pair(
187 strategy_configuration.getName(), strategy_configuration));
188 }
189 }
190 }
191 }
192 }
193
194 std::vector<LeAudioCodecCapabilitiesSetting>
ComposeLeAudioCodecCapabilities(const std::vector<setting::Scenario> & supported_scenarios)195 BluetoothLeAudioCodecsProvider::ComposeLeAudioCodecCapabilities(
196 const std::vector<setting::Scenario>& supported_scenarios) {
197 std::vector<LeAudioCodecCapabilitiesSetting> le_audio_codec_capabilities;
198 for (const auto& scenario : supported_scenarios) {
199 UnicastCapability unicast_encode_capability =
200 GetUnicastCapability(scenario.getEncode());
201 UnicastCapability unicast_decode_capability =
202 GetUnicastCapability(scenario.getDecode());
203 // encode and decode cannot be unknown at the same time
204 if (unicast_encode_capability.codecType == CodecType::UNKNOWN &&
205 unicast_decode_capability.codecType == CodecType::UNKNOWN) {
206 continue;
207 }
208 BroadcastCapability broadcast_capability = {.codecType =
209 CodecType::UNKNOWN};
210 le_audio_codec_capabilities.push_back(
211 {.unicastEncodeCapability = unicast_encode_capability,
212 .unicastDecodeCapability = unicast_decode_capability,
213 .broadcastCapability = broadcast_capability});
214 }
215 return le_audio_codec_capabilities;
216 }
217
GetUnicastCapability(const std::string & coding_direction)218 UnicastCapability BluetoothLeAudioCodecsProvider::GetUnicastCapability(
219 const std::string& coding_direction) {
220 if (coding_direction == "invalid") {
221 return {.codecType = CodecType::UNKNOWN};
222 }
223
224 auto configuration_iter = configuration_map_.find(coding_direction);
225 if (configuration_iter == configuration_map_.end()) {
226 return {.codecType = CodecType::UNKNOWN};
227 }
228
229 auto codec_configuration_iter = codec_configuration_map_.find(
230 configuration_iter->second.getCodecConfiguration());
231 if (codec_configuration_iter == codec_configuration_map_.end()) {
232 return {.codecType = CodecType::UNKNOWN};
233 }
234
235 auto strategy_configuration_iter = strategy_configuration_map_.find(
236 configuration_iter->second.getStrategyConfiguration());
237 if (strategy_configuration_iter == strategy_configuration_map_.end()) {
238 return {.codecType = CodecType::UNKNOWN};
239 }
240
241 CodecType codec_type =
242 GetCodecType(codec_configuration_iter->second.getCodec());
243 if (codec_type == CodecType::LC3) {
244 return ComposeUnicastCapability(
245 codec_type,
246 GetAudioLocation(
247 strategy_configuration_iter->second.getAudioLocation()),
248 strategy_configuration_iter->second.getConnectedDevice(),
249 strategy_configuration_iter->second.getChannelCount(),
250 ComposeLc3Capability(codec_configuration_iter->second));
251 }
252 return {.codecType = CodecType::UNKNOWN};
253 }
254
255 template <class T>
ComposeUnicastCapability(const CodecType & codec_type,const AudioLocation & audio_location,const uint8_t & device_cnt,const uint8_t & channel_count,const T & capability)256 UnicastCapability BluetoothLeAudioCodecsProvider::ComposeUnicastCapability(
257 const CodecType& codec_type, const AudioLocation& audio_location,
258 const uint8_t& device_cnt, const uint8_t& channel_count,
259 const T& capability) {
260 return {
261 .codecType = codec_type,
262 .supportedChannel = audio_location,
263 .deviceCount = device_cnt,
264 .channelCountPerDevice = channel_count,
265 .leAudioCodecCapabilities =
266 UnicastCapability::LeAudioCodecCapabilities(capability),
267 };
268 }
269
ComposeLc3Capability(const setting::CodecConfiguration & codec_configuration)270 Lc3Capabilities BluetoothLeAudioCodecsProvider::ComposeLc3Capability(
271 const setting::CodecConfiguration& codec_configuration) {
272 return {.samplingFrequencyHz = {codec_configuration.getSamplingFrequency()},
273 .frameDurationUs = {codec_configuration.getFrameDurationUs()},
274 .octetsPerFrame = {codec_configuration.getOctetsPerCodecFrame()}};
275 }
276
GetAudioLocation(const setting::AudioLocation & audio_location)277 AudioLocation BluetoothLeAudioCodecsProvider::GetAudioLocation(
278 const setting::AudioLocation& audio_location) {
279 switch (audio_location) {
280 case setting::AudioLocation::MONO:
281 return kMonoAudio;
282 case setting::AudioLocation::STEREO:
283 return kStereoAudio;
284 default:
285 return AudioLocation::UNKNOWN;
286 }
287 }
288
GetCodecType(const setting::CodecType & codec_type)289 CodecType BluetoothLeAudioCodecsProvider::GetCodecType(
290 const setting::CodecType& codec_type) {
291 switch (codec_type) {
292 case setting::CodecType::LC3:
293 return CodecType::LC3;
294 default:
295 return CodecType::UNKNOWN;
296 }
297 }
298
IsValidCodecConfiguration(const setting::CodecConfiguration & codec_configuration)299 bool BluetoothLeAudioCodecsProvider::IsValidCodecConfiguration(
300 const setting::CodecConfiguration& codec_configuration) {
301 return codec_configuration.hasName() && codec_configuration.hasCodec() &&
302 codec_configuration.hasSamplingFrequency() &&
303 codec_configuration.hasFrameDurationUs() &&
304 codec_configuration.hasOctetsPerCodecFrame();
305 }
306
IsValidStrategyConfiguration(const setting::StrategyConfiguration & strategy_configuration)307 bool BluetoothLeAudioCodecsProvider::IsValidStrategyConfiguration(
308 const setting::StrategyConfiguration& strategy_configuration) {
309 if (!strategy_configuration.hasName() ||
310 !strategy_configuration.hasAudioLocation() ||
311 !strategy_configuration.hasConnectedDevice() ||
312 !strategy_configuration.hasChannelCount()) {
313 return false;
314 }
315 if (strategy_configuration.getAudioLocation() ==
316 setting::AudioLocation::STEREO) {
317 if ((strategy_configuration.getConnectedDevice() == 2 &&
318 strategy_configuration.getChannelCount() == 1) ||
319 (strategy_configuration.getConnectedDevice() == 1 &&
320 strategy_configuration.getChannelCount() == 2)) {
321 // Stereo
322 // 1. two connected device, one for L one for R
323 // 2. one connected device for both L and R
324 return true;
325 }
326 } else if (strategy_configuration.getAudioLocation() ==
327 setting::AudioLocation::MONO) {
328 if (strategy_configuration.getConnectedDevice() == 1 &&
329 strategy_configuration.getChannelCount() == 1) {
330 // Mono
331 return true;
332 }
333 }
334 return false;
335 }
336
337 } // namespace audio
338 } // namespace bluetooth
339 } // namespace hardware
340 } // namespace android
341 } // namespace aidl
342