1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "include/a2dp_aac_param_ctrl.h"
17
18 #include "include/a2dp_codec_constant.h"
19 #include "include/a2dp_codec_errors.h"
20 #include "log.h"
21 #include "memory.h"
22 #include "securec.h"
23
24 namespace OHOS {
25 namespace bluetooth {
26 const int PCM_CHANNEL_SAMPLES_PER_SAMPLE = 1024;
27 const int BIT_MOVE_RIGHT16 = 16;
28 const int BIT_MOVE_RIGHT8 = 8;
29 const int BIT_MOVE_RIGHT4 = 4;
30 const int BIT_MOVE_LEFT16 = 16;
31 const int BIT_MOVE_LEFT8 = 8;
32 const int BIT_MOVE_LEFT4 = 4;
33 const int CHANNEL_MODEL1 = 1;
34 const int CHANNEL_MODEL2 = 2;
35 const int SAMPLE_RATE8000 = 8000;
36 const int SAMPLE_RATE11025 = 11025;
37 const int SAMPLE_RATE12000 = 12000;
38 const int SAMPLE_RATE16000 = 16000;
39 const int SAMPLE_RATE22050 = 22050;
40 const int SAMPLE_RATE24000 = 24000;
41 const int SAMPLE_RATE32000 = 32000;
42 const int SAMPLE_RATE44100 = 44100;
43 const int SAMPLE_RATE48000 = 48000;
44 const int SAMPLE_RATE64000 = 64000;
45 const int SAMPLE_RATE88200 = 88200;
46 const int SAMPLE_RATE96000 = 96000;
47 const int VALUE_OF_EIGHT = 8;
A2dpCodecConfigAacSource(A2dpCodecPriority codecPriority)48 A2dpCodecConfigAacSource::A2dpCodecConfigAacSource(A2dpCodecPriority codecPriority)
49 : A2dpCodecConfigAacBase(A2DP_SOURCE_CODEC_INDEX_AAC, codecPriority, true)
50 {
51 LOG_INFO("[A2dpCodecConfigAacSource] %{public}s", __func__);
52
53 // Compute the local capability
54 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
55 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
56 }
57 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_32000) {
58 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_32000;
59 }
60 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_24000) {
61 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_24000;
62 }
63 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_22050) {
64 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_22050;
65 }
66 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_16000) {
67 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_16000;
68 }
69 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_12000) {
70 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_12000;
71 }
72 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_11025) {
73 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_11025;
74 }
75 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_8000) {
76 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_8000;
77 }
78 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_96000) {
79 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_96000;
80 }
81 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_88200) {
82 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_88200;
83 }
84 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_64000) {
85 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_64000;
86 }
87 if (A2DP_AAC_SOURCE_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
88 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
89 }
90
91 if (A2DP_AAC_SOURCE_CAPS.channelMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
92 codecLocalCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
93 }
94 if (A2DP_AAC_SOURCE_CAPS.channelMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
95 codecLocalCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
96 }
97 }
98
A2dpCodecConfigAacSink(A2dpCodecPriority codecPriority)99 A2dpCodecConfigAacSink::A2dpCodecConfigAacSink(A2dpCodecPriority codecPriority)
100 : A2dpCodecConfigAacBase(A2DP_SINK_CODEC_INDEX_AAC, codecPriority, false)
101 {
102 LOG_INFO("[A2dpCodecConfigAacSink] %{public}s", __func__);
103 // Compute the local capability
104 if (A2DP_AAC_SINK_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
105 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
106 }
107 if (A2DP_AAC_SINK_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_96000) {
108 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_96000;
109 }
110 if (A2DP_AAC_SINK_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_88200) {
111 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_88200;
112 }
113 if (A2DP_AAC_SINK_CAPS.sampleFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
114 codecLocalCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
115 }
116
117 codecLocalCap_.bitsPerSample = A2DP_AAC_SINK_CAPS.bitsPerSample;
118
119 if (A2DP_AAC_SINK_CAPS.channelMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
120 codecLocalCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
121 }
122 if (A2DP_AAC_SINK_CAPS.channelMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
123 codecLocalCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
124 }
125 }
126
SetSampleRateUser(uint32_t sampFreq,A2dpAACCapability & resultCap)127 void A2dpCodecConfigAacBase::SetSampleRateUser(uint32_t sampFreq, A2dpAACCapability &resultCap)
128 {
129 switch (userCodecConfig_.sampleRate_) {
130 case A2DP_AAC_SAMPLE_RATE_OCTET1_44100:
131 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
132 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
133 codecCap_.sampleRate_ = userCodecConfig_.sampleRate_;
134 codecConfig_.sampleRate_ = userCodecConfig_.sampleRate_;
135 }
136 break;
137 case A2DP_AAC_SAMPLE_RATE_OCTET2_48000:
138 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
139 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
140 codecCap_.sampleRate_ = userCodecConfig_.sampleRate_;
141 codecConfig_.sampleRate_ = userCodecConfig_.sampleRate_;
142 }
143 break;
144 case A2DP_AAC_SAMPLE_RATE_OCTET1_32000:
145 case A2DP_AAC_SAMPLE_RATE_OCTET1_16000:
146 case A2DP_SAMPLE_RATE_NONE:
147 resultCap.sampleFreq = A2DP_SAMPLE_RATE_NONE;
148 codecCap_.sampleRate_ = A2DP_SAMPLE_RATE_NONE;
149 codecConfig_.sampleRate_ = A2DP_SAMPLE_RATE_NONE;
150 break;
151 default:
152 break;
153 }
154 }
155
SetSampleRateSelectableCapa(uint32_t sampFreq)156 void A2dpCodecConfigAacBase::SetSampleRateSelectableCapa(uint32_t sampFreq)
157 {
158 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
159 codecSelectableCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
160 }
161 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
162 codecSelectableCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
163 }
164 }
165
SetSampleRateCommonCapa(uint32_t sampFreq)166 void A2dpCodecConfigAacBase::SetSampleRateCommonCapa(uint32_t sampFreq)
167 {
168 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
169 codecCap_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
170 }
171 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
172 codecCap_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
173 }
174 }
175
SetSampleRateAudioConfig(uint32_t sampFreq,A2dpAACCapability & resultCap)176 bool A2dpCodecConfigAacBase::SetSampleRateAudioConfig(uint32_t sampFreq, A2dpAACCapability &resultCap)
177 {
178 switch (audioCodecConfig_.sampleRate_) {
179 case A2DP_AAC_SAMPLE_RATE_OCTET1_44100:
180 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
181 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
182 codecConfig_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
183 return true;
184 }
185 break;
186 case A2DP_AAC_SAMPLE_RATE_OCTET2_48000:
187 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
188 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
189 codecConfig_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
190 return true;
191 }
192 break;
193 default:
194 LOG_ERROR("[ConfigAacBase] %{public}s [not 44100 or 48000]", __func__);
195 break;
196 }
197 return false;
198 }
199
SetSampleRateBestMatch(uint32_t sampFreq,A2dpAACCapability & resultCap)200 bool A2dpCodecConfigAacBase::SetSampleRateBestMatch(uint32_t sampFreq, A2dpAACCapability &resultCap)
201 {
202 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
203 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
204 codecConfig_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
205 return true;
206 }
207
208 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
209 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
210 codecConfig_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
211 return true;
212 }
213 return false;
214 }
215
SetSampleRateDefaultConfig(uint32_t sampFreq,A2dpAACCapability & resultCap)216 bool A2dpCodecConfigAacBase::SetSampleRateDefaultConfig(uint32_t sampFreq, A2dpAACCapability &resultCap)
217 {
218 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
219 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
220 codecConfig_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
221 return true;
222 }
223 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
224 resultCap.sampleFreq = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
225 codecConfig_.sampleRate_ = A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
226 return true;
227 }
228 return false;
229 }
230
SetSampleRate(const A2dpAACCapability & localCapability,A2dpAACCapability peerCapability,A2dpAACCapability & resultCap)231 bool A2dpCodecConfigAacBase::SetSampleRate(
232 const A2dpAACCapability &localCapability, A2dpAACCapability peerCapability, A2dpAACCapability &resultCap)
233 {
234 codecConfig_.sampleRate_ = A2DP_SAMPLE_RATE_NONE;
235 uint32_t sampFreq = localCapability.sampleFreq & peerCapability.sampleFreq;
236
237 LOG_INFO("[ConfigAacBase] %{public}s [sampFreq:0x%x] [uFreq:0x%x] [default:0x%x] [aFreq:0x%x] [peer:0x%x]",
238 __func__,
239 sampFreq,
240 userCodecConfig_.sampleRate_,
241 A2DP_AAC_DEFAULT_CONFIG.sampleFreq,
242 audioCodecConfig_.sampleRate_,
243 peerCapability.sampleFreq);
244
245 SetSampleRateUser(sampFreq, resultCap);
246
247 do {
248 SetSampleRateSelectableCapa(sampFreq);
249
250 if (codecConfig_.sampleRate_ != A2DP_SAMPLE_RATE_NONE) {
251 break;
252 }
253
254 SetSampleRateCommonCapa(sampFreq);
255
256 if (SetSampleRateAudioConfig(sampFreq, resultCap)) {
257 break;
258 }
259
260 if (SetSampleRateDefaultConfig(A2DP_AAC_DEFAULT_CONFIG.sampleFreq & peerCapability.sampleFreq, resultCap)) {
261 break;
262 }
263
264 if (SetSampleRateBestMatch(sampFreq, resultCap)) {
265 break;
266 }
267 } while (false);
268
269 LOG_INFO("[ConfigAacBase] %{public}s [sampFreq:0x%x]", __func__, codecConfig_.sampleRate_);
270 if (codecConfig_.sampleRate_ == A2DP_SAMPLE_RATE_NONE) {
271 LOG_ERROR("%{public}s: sampleRate_ had no value need reset config", __func__);
272 return ResetCodecConfig();
273 }
274 return true;
275 }
276
SetBitsPerSampleUser(const A2dpAACCapability & localCapability)277 void A2dpCodecConfigAacBase::SetBitsPerSampleUser(const A2dpAACCapability &localCapability)
278 {
279 switch (userCodecConfig_.bitsPerSample) {
280 case A2DP_SAMPLE_BITS_16:
281 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_16) {
282 codecCap_.bitsPerSample = userCodecConfig_.bitsPerSample;
283 codecConfig_.bitsPerSample = userCodecConfig_.bitsPerSample;
284 }
285 break;
286 case A2DP_SAMPLE_BITS_24:
287 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_24) {
288 codecCap_.bitsPerSample = userCodecConfig_.bitsPerSample;
289 codecConfig_.bitsPerSample = userCodecConfig_.bitsPerSample;
290 }
291 break;
292 case A2DP_SAMPLE_BITS_32:
293 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_32) {
294 codecCap_.bitsPerSample = userCodecConfig_.bitsPerSample;
295 codecConfig_.bitsPerSample = userCodecConfig_.bitsPerSample;
296 }
297 break;
298 case A2DP_SAMPLE_BITS_NONE:
299 codecCap_.bitsPerSample = A2DP_SAMPLE_BITS_NONE;
300 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_NONE;
301 break;
302 default:
303 break;
304 }
305 }
306
SetBitsPerSampleSelectableCapa(const A2dpAACCapability & localCapability)307 void A2dpCodecConfigAacBase::SetBitsPerSampleSelectableCapa(const A2dpAACCapability &localCapability)
308 {
309 codecSelectableCap_.bitsPerSample = localCapability.bitsPerSample;
310 }
311
SetBitsPerSampleCommonCapa(const A2dpAACCapability & localCapability)312 void A2dpCodecConfigAacBase::SetBitsPerSampleCommonCapa(const A2dpAACCapability &localCapability)
313 {
314 codecCap_.bitsPerSample = localCapability.bitsPerSample;
315 }
316
SetBitsPerSampleAudioConfig(const A2dpAACCapability & localCapability,A2dpAACCapability & resultCap)317 bool A2dpCodecConfigAacBase::SetBitsPerSampleAudioConfig(
318 const A2dpAACCapability &localCapability, A2dpAACCapability &resultCap)
319 {
320 switch (audioCodecConfig_.bitsPerSample) {
321 case A2DP_SAMPLE_BITS_16:
322 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_16) {
323 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_16;
324 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_16;
325 return true;
326 }
327 break;
328 case A2DP_SAMPLE_BITS_24:
329 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_24) {
330 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_24;
331 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_24;
332 return true;
333 }
334 break;
335 case A2DP_SAMPLE_BITS_32:
336 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_32) {
337 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_32;
338 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_32;
339 return true;
340 }
341 break;
342 default:
343 LOG_INFO("[ConfigAacBase] %{public}s [none]", __func__);
344 break;
345 }
346 LOG_INFO("[ConfigAacBase] %{public}s [no match audio config]", __func__);
347 return false;
348 }
349
SetBitsPerSampleBestMatch(const A2dpAACCapability & localCapability,A2dpAACCapability & resultCap)350 bool A2dpCodecConfigAacBase::SetBitsPerSampleBestMatch(
351 const A2dpAACCapability &localCapability, A2dpAACCapability &resultCap)
352 {
353 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_16) {
354 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_16;
355 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_16;
356 return true;
357 }
358
359 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_24) {
360 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_24;
361 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_24;
362 return true;
363 }
364
365 if (localCapability.bitsPerSample & A2DP_SAMPLE_BITS_32) {
366 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_32;
367 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_32;
368 return true;
369 }
370 LOG_INFO("[ConfigAacBase] %{public}s [no match audio config]", __func__);
371 return false;
372 }
373
SetBitsPerSampleDefaultConfig(uint8_t bitPerSample,A2dpAACCapability & resultCap)374 bool A2dpCodecConfigAacBase::SetBitsPerSampleDefaultConfig(uint8_t bitPerSample, A2dpAACCapability &resultCap)
375 {
376 if (bitPerSample & A2DP_SAMPLE_BITS_16) {
377 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_16;
378 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_16;
379 return true;
380 }
381
382 if (bitPerSample & A2DP_SAMPLE_BITS_24) {
383 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_24;
384 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_24;
385 return true;
386 }
387
388 if (bitPerSample & A2DP_SAMPLE_BITS_32) {
389 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_32;
390 resultCap.bitsPerSample = A2DP_SAMPLE_BITS_32;
391 return true;
392 }
393
394 LOG_INFO("[ConfigAacBase] %{public}s[bitsPerSample:0x%x]", __func__, codecConfig_.bitsPerSample);
395 return false;
396 }
397
SetBitsPerSample(const A2dpAACCapability & localCapability,A2dpAACCapability & resultCap)398 bool A2dpCodecConfigAacBase::SetBitsPerSample(const A2dpAACCapability &localCapability, A2dpAACCapability &resultCap)
399 {
400 LOG_INFO("[ConfigAacBase] %{public}s [uBitsPerSample:0x%x] [aBitsPerSample::0x%x][dBitsPerSample::0x%x]",
401 __func__,
402 userCodecConfig_.bitsPerSample,
403 audioCodecConfig_.bitsPerSample,
404 A2DP_AAC_DEFAULT_CONFIG.bitsPerSample);
405
406 codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_NONE;
407
408 SetBitsPerSampleUser(localCapability);
409
410 do {
411 SetBitsPerSampleSelectableCapa(localCapability);
412
413 if (codecConfig_.bitsPerSample != A2DP_SAMPLE_BITS_NONE) {
414 break;
415 }
416
417 SetBitsPerSampleCommonCapa(localCapability);
418
419 if (SetBitsPerSampleAudioConfig(localCapability, resultCap)) {
420 break;
421 }
422
423 if (SetBitsPerSampleDefaultConfig(A2DP_AAC_DEFAULT_CONFIG.bitsPerSample, resultCap)) {
424 break;
425 }
426
427 if (SetBitsPerSampleBestMatch(localCapability, resultCap)) {
428 break;
429 }
430 } while (false);
431
432 LOG_INFO("[ConfigAacBase] %{public}s [bitsPerSample:0x%x]", __func__, codecConfig_.bitsPerSample);
433
434 if (codecConfig_.bitsPerSample == A2DP_SAMPLE_BITS_NONE) {
435 LOG_ERROR("%{public}s: bitsPerSample had no value", __func__);
436 return ResetCodecConfig();
437 }
438 return true;
439 }
440
SetChannelModeUser(uint8_t chMode,A2dpAACCapability & resultCap)441 void A2dpCodecConfigAacBase::SetChannelModeUser(uint8_t chMode, A2dpAACCapability &resultCap)
442 {
443 switch (userCodecConfig_.channelMode_) {
444 case A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE:
445 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
446 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
447 codecCap_.channelMode_ = userCodecConfig_.channelMode_;
448 codecConfig_.channelMode_ = userCodecConfig_.channelMode_;
449 }
450 break;
451 case A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE:
452 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
453 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
454 codecCap_.channelMode_ = userCodecConfig_.channelMode_;
455 codecConfig_.channelMode_ = userCodecConfig_.channelMode_;
456 break;
457 }
458 break;
459 case A2DP_CHANNEL_MODE_NONE:
460 resultCap.channelMode = A2DP_CHANNEL_MODE_NONE;
461 codecCap_.channelMode_ = A2DP_CHANNEL_MODE_NONE;
462 codecConfig_.channelMode_ = A2DP_CHANNEL_MODE_NONE;
463 break;
464 default:
465 break;
466 }
467 }
468
SetChannelModeSelectableCapa(uint8_t chMode)469 void A2dpCodecConfigAacBase::SetChannelModeSelectableCapa(uint8_t chMode)
470 {
471 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
472 codecSelectableCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
473 }
474 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
475 codecSelectableCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
476 }
477 }
478
SetChannelModeCommonCapa(uint8_t chMode)479 void A2dpCodecConfigAacBase::SetChannelModeCommonCapa(uint8_t chMode)
480 {
481 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
482 codecCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
483 }
484
485 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
486 codecCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
487 }
488 }
489
SetChannelModeAudioConfig(uint8_t chMode,A2dpAACCapability & resultCap)490 bool A2dpCodecConfigAacBase::SetChannelModeAudioConfig(uint8_t chMode, A2dpAACCapability &resultCap)
491 {
492 switch (audioCodecConfig_.channelMode_) {
493 case A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE:
494 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
495 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
496 codecConfig_.channelMode_ = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
497 return true;
498 }
499 break;
500 case A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE:
501 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
502 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
503 codecConfig_.channelMode_ = A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
504 return true;
505 }
506 break;
507 case A2DP_CHANNEL_MODE_NONE:
508 break;
509 default:
510 break;
511 }
512 return false;
513 }
514
SetChannelModeBestMatch(uint8_t chMode,A2dpAACCapability & resultCap)515 bool A2dpCodecConfigAacBase::SetChannelModeBestMatch(uint8_t chMode, A2dpAACCapability &resultCap)
516 {
517 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
518 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
519 codecConfig_.channelMode_ = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
520 return true;
521 }
522
523 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
524 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
525 codecConfig_.channelMode_ = A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
526 return true;
527 }
528 return false;
529 }
530
SetChannelModeDefaultConfig(uint8_t chMode,A2dpAACCapability & resultCap)531 bool A2dpCodecConfigAacBase::SetChannelModeDefaultConfig(uint8_t chMode, A2dpAACCapability &resultCap)
532 {
533 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
534 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
535 codecConfig_.channelMode_ = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
536 return true;
537 }
538
539 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
540 resultCap.channelMode = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
541 codecConfig_.channelMode_ = A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
542 return true;
543 }
544 return false;
545 }
546
SetChannelMode(const A2dpAACCapability & localCapability,A2dpAACCapability peerCapability,A2dpAACCapability & resultCap)547 bool A2dpCodecConfigAacBase::SetChannelMode(
548 const A2dpAACCapability &localCapability, A2dpAACCapability peerCapability, A2dpAACCapability &resultCap)
549 {
550 uint8_t chMode = localCapability.channelMode & peerCapability.channelMode;
551 codecConfig_.channelMode_ = A2DP_CHANNEL_MODE_NONE;
552
553 LOG_INFO("[ConfigAacBase] %{public}s [chMode:0x%x] [uMode:0x%x] [default:0x%x] [aMode:0x%x] [peer:0x%x]",
554 __func__,
555 chMode,
556 userCodecConfig_.channelMode_,
557 A2DP_AAC_DEFAULT_CONFIG.channelMode,
558 audioCodecConfig_.channelMode_,
559 peerCapability.channelMode);
560
561 SetChannelModeUser(chMode, resultCap);
562
563 do {
564 SetChannelModeSelectableCapa(chMode);
565
566 if (codecConfig_.channelMode_ != A2DP_CHANNEL_MODE_NONE) {
567 break;
568 }
569
570 SetChannelModeCommonCapa(chMode);
571
572 if (SetChannelModeAudioConfig(chMode, resultCap)) {
573 break;
574 }
575
576 if (SetChannelModeDefaultConfig(A2DP_AAC_DEFAULT_CONFIG.channelMode & peerCapability.channelMode, resultCap)) {
577 break;
578 }
579
580 if (SetChannelModeBestMatch(chMode, resultCap)) {
581 break;
582 }
583 } while (false);
584
585 LOG_INFO("[ConfigAacBase] %{public}s [channelMode_:0x%x]", __func__, codecConfig_.channelMode_);
586
587 if (codecConfig_.channelMode_ == A2DP_CHANNEL_MODE_NONE) {
588 LOG_ERROR("%{public}s: channelMode had no value", __func__);
589 return ResetCodecConfig();
590 }
591 return true;
592 }
593
SetCodecSpecific(void)594 bool A2dpCodecConfigAacBase::SetCodecSpecific(void)
595 {
596 if (userCodecConfig_.codecSpecific1 != 0) {
597 codecConfig_.codecSpecific1 = userCodecConfig_.codecSpecific1;
598 }
599 if (userCodecConfig_.codecSpecific2 != 0) {
600 codecConfig_.codecSpecific2 = userCodecConfig_.codecSpecific2;
601 }
602 if (userCodecConfig_.codecSpecific3 != 0) {
603 codecConfig_.codecSpecific3 = userCodecConfig_.codecSpecific3;
604 }
605 if (userCodecConfig_.codecSpecific4 != 0) {
606 codecConfig_.codecSpecific4 = userCodecConfig_.codecSpecific4;
607 }
608 return true;
609 }
610
ResetCodecConfig(void)611 bool A2dpCodecConfigAacBase::ResetCodecConfig(void)
612 {
613 LOG_ERROR("[ConfigAacBase] %{public}s", __func__);
614 codecConfig_ = savedCodecConfig_;
615 codecCap_ = savedCodecCapability_;
616 userCodecConfig_ = savedCodecUserConfig_;
617 (void)memcpy_s(otaCodecConfig_, A2DP_CODEC_SIZE, savedOtaCodecConfig_, A2DP_CODEC_SIZE);
618 return false;
619 }
620
SetCodecConfig(const uint8_t * peerCodeInfo,uint8_t * resultCodecInfo)621 bool A2dpCodecConfigAacBase::SetCodecConfig(const uint8_t *peerCodeInfo, uint8_t *resultCodecInfo)
622 {
623 LOG_INFO("[ConfigAacBase] %{public}s\n", __func__);
624 const A2dpAACCapability *a2dpAacCaps = (isSource_) ? &A2DP_AAC_SOURCE_CAPS : &A2DP_AAC_SINK_CAPS;
625 A2dpAACCapability cfgCap = {};
626 A2dpAACCapability cfgCapResult = {};
627 savedCodecConfig_ = codecConfig_;
628 savedCodecCapability_ = codecCap_;
629 savedCodecUserConfig_ = userCodecConfig_;
630 (void)memcpy_s(savedOtaCodecConfig_, A2DP_CODEC_SIZE, otaCodecConfig_, A2DP_CODEC_SIZE);
631
632 if (ParseInfoAac(&cfgCap, peerCodeInfo) != A2DP_SUCCESS) {
633 LOG_ERROR("[ConfigAacBase] %{public}s: can't parse peer's capabilities\n", __func__);
634 return ResetCodecConfig();
635 }
636
637 cfgCapResult.objectType = a2dpAacCaps->objectType;
638 cfgCapResult.variableBitRateSupport = a2dpAacCaps->variableBitRateSupport & cfgCap.variableBitRateSupport;
639
640 if (cfgCap.bitRate < A2DP_AAC_MIN_BITRATE) {
641 // Bogus bit rate
642 cfgCapResult.bitRate = a2dpAacCaps->bitRate;
643 } else {
644 cfgCapResult.bitRate = std::min(a2dpAacCaps->bitRate, cfgCap.bitRate);
645 }
646
647 if (SetSampleRate(*a2dpAacCaps, cfgCap, cfgCapResult) != true) {
648 LOG_ERROR("%{public}s: SetSampleRate failed", __func__);
649 }
650 if (SetBitsPerSample(*a2dpAacCaps, cfgCapResult) != true) {
651 LOG_ERROR("%{public}s: SetBitsPerSample failed", __func__);
652 }
653 if (SetChannelMode(*a2dpAacCaps, cfgCap, cfgCapResult) != true) {
654 LOG_ERROR("%{public}s: SetChannelMode failed", __func__);
655 }
656
657 if (BuildAacInfo(&cfgCapResult, resultCodecInfo) != A2DP_SUCCESS) {
658 LOG_INFO("[ConfigAacBase] %{public}s: BuildAacInfo for return config failed\n", __func__);
659 return ResetCodecConfig();
660 }
661 SetCodecSpecific();
662 if (BuildAacInfo(&cfgCapResult, otaCodecConfig_) != A2DP_SUCCESS) {
663 LOG_INFO("[ConfigAacBase] %{public}s: Build Aac Info failed\n", __func__);
664 return ResetCodecConfig();
665 }
666 return true;
667 }
668
SetSampleFrameCapa(const A2dpAACCapability & localCapability,A2dpAACCapability peerCapability)669 void A2dpCodecConfigAacBase::SetSampleFrameCapa(
670 const A2dpAACCapability &localCapability, A2dpAACCapability peerCapability)
671 {
672 uint32_t sampFreq = localCapability.sampleFreq & peerCapability.sampleFreq;
673 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET1_44100) {
674 codecSelectableCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET1_44100;
675 }
676 if (sampFreq & A2DP_AAC_SAMPLE_RATE_OCTET2_48000) {
677 codecSelectableCap_.sampleRate_ |= A2DP_AAC_SAMPLE_RATE_OCTET2_48000;
678 }
679 }
680
SetBitsPerSampleCapa(const A2dpAACCapability & localCapability)681 void A2dpCodecConfigAacBase::SetBitsPerSampleCapa(const A2dpAACCapability &localCapability)
682 {
683 codecSelectableCap_.bitsPerSample = localCapability.bitsPerSample;
684 }
685
SetChannelModeCapa(const A2dpAACCapability & localCapability,A2dpAACCapability peerCapability)686 void A2dpCodecConfigAacBase::SetChannelModeCapa(
687 const A2dpAACCapability &localCapability, A2dpAACCapability peerCapability)
688 {
689 uint32_t chMode = localCapability.channelMode & peerCapability.channelMode;
690 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE) {
691 codecSelectableCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE;
692 }
693 if (chMode & A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE) {
694 codecSelectableCap_.channelMode_ |= A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE;
695 }
696 }
697
ResetCodecCapability(void)698 bool A2dpCodecConfigAacBase::ResetCodecCapability(void)
699 {
700 LOG_ERROR("[ConfigAacBase] %{public}s", __func__);
701 codecSelectableCap_ = savedCodecSelectableCapability;
702 (void)memcpy_s(otaCodecPeerCapability_, A2DP_CODEC_SIZE, savedOtaCodecPeerCapability, A2DP_CODEC_SIZE);
703 return false;
704 }
705
SetPeerCodecCapabilities(const uint8_t * peerCapabilities)706 bool A2dpCodecConfigAacBase::SetPeerCodecCapabilities(const uint8_t *peerCapabilities)
707 {
708 const A2dpAACCapability *a2dpAacCaps = (isSource_) ? &A2DP_AAC_SOURCE_CAPS : &A2DP_AAC_SINK_CAPS;
709
710 A2dpAACCapability cfgCap = {};
711
712 if (ParseInfoAac(&cfgCap, peerCapabilities) != A2DP_SUCCESS) {
713 LOG_ERROR("[ConfigAacBase]%{public}s: can't parse peer's capabilities", __func__);
714 return ResetCodecCapability();
715 }
716 // Compute the selectable capability - sample rate
717 SetSampleFrameCapa(*a2dpAacCaps, cfgCap);
718 // Compute the selectable capability - bits per sample
719 SetBitsPerSampleCapa(*a2dpAacCaps);
720 // Compute the selectable capability - channel mode
721 SetChannelModeCapa(*a2dpAacCaps, cfgCap);
722
723 if (BuildAacInfo(&cfgCap, otaCodecPeerCapability_) != A2DP_SUCCESS) {
724 LOG_ERROR("[ConfigAacBase]%{public}s: BuildAacInfo Error", __func__);
725 return ResetCodecCapability();
726 }
727 return true;
728 }
729
GetBitrateAac(const uint8_t * codecInfo)730 int GetBitrateAac(const uint8_t *codecInfo)
731 {
732 A2dpAACCapability cfgCap = {};
733 if (ParseInfoAac(&cfgCap, codecInfo) != A2DP_SUCCESS) {
734 LOG_ERROR("%{public}s: cannot get bitRate information", __func__);
735 return -1;
736 }
737 LOG_INFO("[ConfigAacBase] %{public}s [bitRate:0x%x]", __func__, cfgCap.bitRate);
738 return cfgCap.bitRate;
739 }
740
GetVariableBitRateSupportAac(const uint8_t * codecInfo)741 int GetVariableBitRateSupportAac(const uint8_t *codecInfo)
742 {
743 A2dpAACCapability cfgCap = {};
744
745 // Check whether the codec info contains valid data
746 if (ParseInfoAac(&cfgCap, codecInfo) != A2DP_SUCCESS) {
747 LOG_ERROR("%{public}s: cannot decode codec information", __func__);
748 return -1;
749 }
750 LOG_INFO("%{public}s [variableBitRateSupport:0x%x]", __func__, cfgCap.variableBitRateSupport);
751 switch (cfgCap.variableBitRateSupport) {
752 case A2DP_AAC_VARIABLE_BIT_RATE_DISABLED:
753 case A2DP_AAC_VARIABLE_BIT_RATE_ENABLED:
754 return cfgCap.variableBitRateSupport;
755 default:
756 break;
757 }
758 return -1;
759 }
760
GetSampleRateAac(const uint8_t * codecInfo)761 int GetSampleRateAac(const uint8_t *codecInfo)
762 {
763 A2dpAACCapability cfgCap = {};
764 if (ParseInfoAac(&cfgCap, codecInfo) != A2DP_SUCCESS) {
765 LOG_ERROR("%{public}s: cannot get SampleRate Aac information", __func__);
766 return -1;
767 }
768 LOG_INFO("[A2dpCodecConfigAacBase] %{public}s [sampleFreq:0x%x]", __func__, cfgCap.sampleFreq);
769 switch (cfgCap.sampleFreq) {
770 case A2DP_AAC_SAMPLE_RATE_OCTET1_8000:
771 return SAMPLE_RATE8000;
772 case A2DP_AAC_SAMPLE_RATE_OCTET1_11025:
773 return SAMPLE_RATE11025;
774 case A2DP_AAC_SAMPLE_RATE_OCTET1_12000:
775 return SAMPLE_RATE12000;
776 case A2DP_AAC_SAMPLE_RATE_OCTET1_16000:
777 return SAMPLE_RATE16000;
778 case A2DP_AAC_SAMPLE_RATE_OCTET1_22050:
779 return SAMPLE_RATE22050;
780 case A2DP_AAC_SAMPLE_RATE_OCTET1_24000:
781 return SAMPLE_RATE24000;
782 case A2DP_AAC_SAMPLE_RATE_OCTET1_32000:
783 return SAMPLE_RATE32000;
784 case A2DP_AAC_SAMPLE_RATE_OCTET1_44100:
785 return SAMPLE_RATE44100;
786 case A2DP_AAC_SAMPLE_RATE_OCTET2_48000:
787 return SAMPLE_RATE48000;
788 case A2DP_AAC_SAMPLE_RATE_OCTET2_64000:
789 return SAMPLE_RATE64000;
790 case A2DP_AAC_SAMPLE_RATE_OCTET2_88200:
791 return SAMPLE_RATE88200;
792 case A2DP_AAC_SAMPLE_RATE_OCTET2_96000:
793 return SAMPLE_RATE96000;
794 default:
795 break;
796 }
797
798 return -1;
799 }
ComputeMaxBitRateAac(const uint8_t * codecInfo,uint16_t mtu)800 int ComputeMaxBitRateAac(const uint8_t *codecInfo, uint16_t mtu)
801 {
802 A2dpAACCapability cfgCap = {};
803
804 // Check whether the codec info contains valid data
805 if (ParseInfoAac(&cfgCap, codecInfo) != A2DP_SUCCESS) {
806 LOG_ERROR("%{public}s: cannot get SampleRate Aac information", __func__);
807 return -1;
808 }
809
810 int samplingFreq = GetSampleRateAac(codecInfo);
811 if (samplingFreq == -1) {
812 return -1;
813 }
814
815 int samplesPerFrame = 0;
816 switch (cfgCap.objectType) {
817 case A2DP_AAC_MPEG2_OBJECT_TYPE:
818 case A2DP_AAC_MPEG4_LC_OBJECT_TYPE:
819 samplesPerFrame = PCM_CHANNEL_SAMPLES_PER_SAMPLE;
820 break;
821 case A2DP_AAC_MPEG4_LTP_OBJECT_TYPE:
822 case A2DP_AAC_MPEG4_SCALABLE_OBJECT_TYPE:
823 break;
824 default:
825 break;
826 }
827 if (samplesPerFrame == 0) {
828 return -1;
829 }
830
831 // See Section 3.2.1 Estimating Average Frame Size from
832 // the aacEncoder.pdf document included with the AAC source code.
833 return (VALUE_OF_EIGHT * mtu * samplingFreq) / samplesPerFrame;
834 }
835
GetTrackChannelModeAac(const uint8_t * codecInfo)836 int GetTrackChannelModeAac(const uint8_t *codecInfo)
837 {
838 A2dpAACCapability cfgCap = {};
839 if (ParseInfoAac(&cfgCap, codecInfo) != A2DP_SUCCESS) {
840 LOG_ERROR("%{public}s: cannot get Track ChannelMode information", __func__);
841 return -1;
842 }
843 LOG_INFO("[ConfigAacBase] %{public}s [channelMode:0x%x]", __func__, cfgCap.channelMode);
844 return cfgCap.channelMode;
845 }
846
GetTrackChannelCountAac(const uint8_t * codecInfo)847 int GetTrackChannelCountAac(const uint8_t *codecInfo)
848 {
849 A2dpAACCapability cfgCap = {};
850 if (ParseInfoAac(&cfgCap, codecInfo) != A2DP_SUCCESS) {
851 LOG_ERROR("%{public}s: cannot get TrackChannel information", __func__);
852 return -1;
853 }
854 LOG_INFO("[ConfigAacBase] %{public}s [channelMode:0x%x]", __func__, cfgCap.channelMode);
855 switch (cfgCap.channelMode) {
856 case A2DP_AAC_CHANNEL_MODE_OCTET2_SINGLE:
857 return CHANNEL_MODEL1;
858 case A2DP_AAC_CHANNEL_MODE_OCTET2_DOUBLE:
859 return CHANNEL_MODEL2;
860 default:
861 break;
862 }
863 return -1;
864 }
865
GetObjectTypeCodeAac(const uint8_t * codecInfo)866 int GetObjectTypeCodeAac(const uint8_t *codecInfo)
867 {
868 A2dpAACCapability cfgCap = {};
869
870 // Check whether the codec info contains valid data
871 if (A2DP_SUCCESS != ParseInfoAac(&cfgCap, codecInfo)) {
872 LOG_ERROR("%{public}s: cannot decode codec information", __func__);
873 return -1;
874 }
875 LOG_INFO("%{public}s [objectType:0x%x]", __func__, cfgCap.objectType);
876 return cfgCap.objectType;
877 }
878
BuildAacInfo(const A2dpAACCapability * aacCap,uint8_t * codecInfo)879 uint8_t BuildAacInfo(const A2dpAACCapability *aacCap, uint8_t *codecInfo)
880 {
881 LOG_INFO("[ConfigAacBase] %{public}s\n", __func__);
882 /// AAC codec Info
883 *codecInfo++ = A2DP_CODEC_AAC_INFO_LEN; /// aac information length
884 *codecInfo++ = (A2DP_MEDIA_TYPE_AUDIO << BIT_MOVE_LEFT4);
885 *codecInfo++ = A2DP_CODEC_TYPE_AAC; /// AAC media codec type
886 *codecInfo++ = aacCap->objectType;
887 *codecInfo++ = aacCap->sampleFreq;
888 *codecInfo++ = ((aacCap->sampleFreq >> BIT_MOVE_RIGHT8) & 0xF0) | (aacCap->channelMode & 0x0C);
889 *codecInfo++ = (aacCap->variableBitRateSupport & 0x80) | ((aacCap->bitRate >> BIT_MOVE_RIGHT16) & 0x7F);
890 *codecInfo++ = ((aacCap->bitRate >> BIT_MOVE_RIGHT8) & 0xFF);
891 *codecInfo++ = (aacCap->bitRate & 0xFF);
892 return A2DP_SUCCESS;
893 }
894
ParseInfoAac(A2dpAACCapability * aacCap,const uint8_t * codecInfo)895 uint8_t ParseInfoAac(A2dpAACCapability *aacCap, const uint8_t *codecInfo)
896 {
897 LOG_INFO("[ConfigAacBase] %{public}s\n", __func__);
898 uint8_t losc;
899 uint8_t mediaType;
900 uint8_t codecType;
901 if (codecInfo == nullptr) {
902 return A2DP_CODEC_ERROR_INVALID_PARAMS;
903 }
904 // Check the codec capability length931
905 losc = *codecInfo++;
906 if (losc != A2DP_CODEC_AAC_INFO_LEN) {
907 return A2DP_CODEC_ERROR_WRONG_CODEC;
908 }
909
910 mediaType = (*codecInfo++) >> BIT_MOVE_RIGHT4;
911 codecType = *codecInfo++;
912 /* Check the Media Type and Media Codec Type */
913 if (mediaType != A2DP_MEDIA_TYPE_AUDIO || codecType != A2DP_CODEC_TYPE_AAC) {
914 return A2DP_CODEC_ERROR_WRONG_CODEC;
915 }
916 aacCap->objectType = *codecInfo++ & 0xF0;
917 aacCap->sampleFreq = *codecInfo++ & 0xFF;
918 aacCap->sampleFreq |= (*codecInfo & 0xF0) << BIT_MOVE_LEFT8;
919 aacCap->channelMode = *codecInfo & 0x0C;
920 codecInfo++;
921 aacCap->variableBitRateSupport = *codecInfo & 0x80;
922 aacCap->bitRate = (*codecInfo++) << BIT_MOVE_LEFT16;
923 aacCap->bitRate |= (*codecInfo++) << BIT_MOVE_LEFT8;
924 aacCap->bitRate |= *codecInfo++;
925
926 return A2DP_SUCCESS;
927 }
928
IsAacConfigChanged(const uint8_t * lastCodecInfo,const uint8_t * newCodecInfo)929 bool IsAacConfigChanged(const uint8_t *lastCodecInfo, const uint8_t *newCodecInfo)
930 {
931 A2dpAACCapability lastInfo = {};
932 A2dpAACCapability newInfo = {};
933
934 if (ParseInfoAac(&lastInfo, lastCodecInfo) != A2DP_SUCCESS) {
935 LOG_ERROR("%{public}s: cannot parse lastCodecInfo", __func__);
936 return false;
937 }
938
939 if (ParseInfoAac(&newInfo, newCodecInfo) != A2DP_SUCCESS) {
940 LOG_ERROR("%{public}s: cannot parse newCodecInfo", __func__);
941 return false;
942 }
943
944 return (lastInfo.sampleFreq == newInfo.sampleFreq) && (lastInfo.channelMode == newInfo.channelMode) &&
945 (lastInfo.bitRate == newInfo.bitRate);
946 }
947 } // namespace bluetooth
948 } // namespace OHOS