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_codec_constant.h"
17 #include "include/a2dp_codec_errors.h"
18 #include "include/a2dp_sbc_param_ctrl.h"
19 #include "log.h"
20 #include "memory.h"
21 #include "securec.h"
22 
23 namespace OHOS {
24 namespace bluetooth {
25 const int BIT_MOVE_LEFT4 = 4;
26 const int BIT_MOVE_RIGHT4 = 4;
A2dpCodecConfigSbcSource(A2dpCodecPriority codecPriority)27 A2dpCodecConfigSbcSource::A2dpCodecConfigSbcSource(A2dpCodecPriority codecPriority)
28     : A2dpCodecConfigSbcBase(A2DP_SOURCE_CODEC_INDEX_SBC, codecPriority, true)
29 {
30     LOG_INFO("[CodecConfigSbcSource] %{public}s", __func__);
31 
32     // Compute the local capability
33     if (A2DP_SBC_SOURCE_CAPS.sampleFreq & A2DP_SBC_SAMPLE_RATE_44100) {
34         codecLocalCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_44100;
35     }
36     if (A2DP_SBC_SOURCE_CAPS.sampleFreq & A2DP_SBC_SAMPLE_RATE_48000) {
37         codecLocalCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_48000;
38     }
39 
40     if (A2DP_SBC_SOURCE_CAPS.bitsPerSample & A2DP_SAMPLE_BITS_16) {
41         codecLocalCap_.bitsPerSample |= A2DP_SAMPLE_BITS_16;
42     }
43 
44     if (A2DP_SBC_SOURCE_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_MONO) {
45         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_MONO;
46     }
47     if (A2DP_SBC_SOURCE_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
48         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
49     }
50     if (A2DP_SBC_SOURCE_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
51         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
52     }
53     if (A2DP_SBC_SOURCE_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
54         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
55     }
56 }
57 
A2dpCodecConfigSbcSink(A2dpCodecPriority codecPriority)58 A2dpCodecConfigSbcSink::A2dpCodecConfigSbcSink(A2dpCodecPriority codecPriority)
59     : A2dpCodecConfigSbcBase(A2DP_SINK_CODEC_INDEX_SBC, codecPriority, false)
60 {
61     LOG_INFO("[CodecConfigSbcSink] %{public}s", __func__);
62     // Compute the local capability
63     if (A2DP_SBC_SINK_CAPS.sampleFreq & A2DP_SBC_SAMPLE_RATE_44100) {
64         codecLocalCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_44100;
65     }
66     if (A2DP_SBC_SINK_CAPS.sampleFreq & A2DP_SBC_SAMPLE_RATE_48000) {
67         codecLocalCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_48000;
68     }
69 
70     if (A2DP_SBC_SINK_CAPS.bitsPerSample & A2DP_SAMPLE_BITS_16) {
71         codecLocalCap_.bitsPerSample |= A2DP_SAMPLE_BITS_16;
72     }
73 
74     if (A2DP_SBC_SINK_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_MONO) {
75         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_MONO;
76     }
77     if (A2DP_SBC_SINK_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
78         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
79     }
80     if (A2DP_SBC_SINK_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
81         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
82     }
83     if (A2DP_SBC_SINK_CAPS.channelMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
84         codecLocalCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
85     }
86 }
87 
SetSampleRateUser(uint32_t sampFreq,A2dpSBCCapability & resultCap)88 void A2dpCodecConfigSbcBase::SetSampleRateUser(uint32_t sampFreq, A2dpSBCCapability &resultCap)
89 {
90     switch (userCodecConfig_.sampleRate_) {
91         case A2DP_SBC_SAMPLE_RATE_44100:
92             if (sampFreq & A2DP_SBC_SAMPLE_RATE_44100) {
93                 resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_44100;
94                 codecCap_.sampleRate_ = userCodecConfig_.sampleRate_;
95                 codecConfig_.sampleRate_ = userCodecConfig_.sampleRate_;
96             }
97             break;
98         case A2DP_SBC_SAMPLE_RATE_48000:
99             if (sampFreq & A2DP_SBC_SAMPLE_RATE_48000) {
100                 resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_48000;
101                 codecCap_.sampleRate_ = userCodecConfig_.sampleRate_;
102                 codecConfig_.sampleRate_ = userCodecConfig_.sampleRate_;
103             }
104             break;
105         case A2DP_SBC_SAMPLE_RATE_32000:
106         case A2DP_SBC_SAMPLE_RATE_16000:
107         case A2DP_SAMPLE_RATE_NONE:
108             resultCap.sampleFreq = A2DP_SAMPLE_RATE_NONE;
109             codecCap_.sampleRate_ = A2DP_SAMPLE_RATE_NONE;
110             codecConfig_.sampleRate_ = A2DP_SAMPLE_RATE_NONE;
111             break;
112         default:
113             break;
114     }
115 }
116 
SetSampleRateSelectableCapa(uint32_t sampFreq)117 void A2dpCodecConfigSbcBase::SetSampleRateSelectableCapa(uint32_t sampFreq)
118 {
119     if (sampFreq & A2DP_SBC_SAMPLE_RATE_44100) {
120         codecSelectableCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_44100;
121     }
122     if (sampFreq & A2DP_SBC_SAMPLE_RATE_48000) {
123         codecSelectableCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_48000;
124     }
125 }
126 
SetSampleRateCommonCapa(uint32_t sampFreq)127 void A2dpCodecConfigSbcBase::SetSampleRateCommonCapa(uint32_t sampFreq)
128 {
129     if (sampFreq & A2DP_SBC_SAMPLE_RATE_44100) {
130         codecCap_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_44100;
131     }
132     if (sampFreq & A2DP_SBC_SAMPLE_RATE_48000) {
133         codecCap_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_48000;
134     }
135 }
136 
SetSampleRateAudioConfig(uint32_t sampFreq,A2dpSBCCapability & resultCap)137 bool A2dpCodecConfigSbcBase::SetSampleRateAudioConfig(uint32_t sampFreq, A2dpSBCCapability &resultCap)
138 {
139     switch (audioCodecConfig_.sampleRate_) {
140         case A2DP_SBC_SAMPLE_RATE_44100:
141             if (sampFreq & A2DP_SBC_SAMPLE_RATE_44100) {
142                 resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_44100;
143                 codecConfig_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_44100;
144                 return true;
145             }
146             break;
147         case A2DP_SBC_SAMPLE_RATE_48000:
148             if (sampFreq & A2DP_SBC_SAMPLE_RATE_48000) {
149                 resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_48000;
150                 codecConfig_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_48000;
151                 return true;
152             }
153             break;
154         default:
155             break;
156     }
157     LOG_INFO("[CodecConfigSbcBase] %{public}s [audio config not suitable]", __func__);
158     return false;
159 }
160 
SetSampleRateBestMatch(uint32_t sampFreq,A2dpSBCCapability & resultCap)161 bool A2dpCodecConfigSbcBase::SetSampleRateBestMatch(uint32_t sampFreq, A2dpSBCCapability &resultCap)
162 {
163     if (sampFreq & A2DP_SBC_SAMPLE_RATE_44100) {
164         resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_44100;
165         codecConfig_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_44100;
166         return true;
167     }
168 
169     if (sampFreq & A2DP_SBC_SAMPLE_RATE_48000) {
170         resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_48000;
171         codecConfig_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_48000;
172         return true;
173     }
174     LOG_INFO("[CodecConfigSbcBase] %{public}s [audio config not suitable]", __func__);
175     return false;
176 }
177 
SetSampleRateDefaultConfig(uint32_t sampFreq,A2dpSBCCapability & resultCap)178 bool A2dpCodecConfigSbcBase::SetSampleRateDefaultConfig(uint32_t sampFreq, A2dpSBCCapability &resultCap)
179 {
180     if (sampFreq & A2DP_SBC_SAMPLE_RATE_44100) {
181         resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_44100;
182         codecConfig_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_44100;
183         return true;
184     }
185     if (sampFreq & A2DP_SBC_SAMPLE_RATE_48000) {
186         resultCap.sampleFreq = A2DP_SBC_SAMPLE_RATE_48000;
187         codecConfig_.sampleRate_ = A2DP_SBC_SAMPLE_RATE_48000;
188         return true;
189     }
190     return false;
191 }
192 
SetSampleRate(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability,A2dpSBCCapability & resultCap)193 bool A2dpCodecConfigSbcBase::SetSampleRate(
194     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability, A2dpSBCCapability &resultCap)
195 {
196     codecConfig_.sampleRate_ = A2DP_SAMPLE_RATE_NONE;
197     uint32_t sampFreq = localCapability.sampleFreq & peerCapability.sampleFreq;
198 
199     LOG_INFO("[CodecConfigSbcBase] %{public}s [sampFreq:0x%x][uFreq:0x%x][dFreq:0x%x][aFreq:0x%x][peer:0x%x]",
200         __func__,
201         sampFreq,
202         userCodecConfig_.sampleRate_,
203         A2DP_SBC_DEFAULT_CONFIG.sampleFreq,
204         audioCodecConfig_.sampleRate_,
205         peerCapability.sampleFreq);
206 
207     SetSampleRateUser(sampFreq, resultCap);
208 
209     do {
210         SetSampleRateSelectableCapa(sampFreq);
211 
212         if (codecConfig_.sampleRate_ != A2DP_SAMPLE_RATE_NONE) {
213             break;
214         }
215 
216         SetSampleRateCommonCapa(sampFreq);
217 
218         if (SetSampleRateAudioConfig(sampFreq, resultCap)) {
219             break;
220         }
221 
222         if (SetSampleRateDefaultConfig(A2DP_SBC_DEFAULT_CONFIG.sampleFreq & peerCapability.sampleFreq, resultCap)) {
223             break;
224         }
225 
226         if (SetSampleRateBestMatch(sampFreq, resultCap)) {
227             break;
228         }
229     } while (false);
230 
231     LOG_INFO("[CodecConfigSbcBase] %{public}s [sampFreq:0x%x]", __func__, codecConfig_.sampleRate_);
232     if (codecConfig_.sampleRate_ == A2DP_SAMPLE_RATE_NONE) {
233         LOG_ERROR("%{public}s: sampleRate_ had no value need reset config", __func__);
234         return ResetCodecConfig();
235     }
236     return true;
237 }
238 
SetBitsPerSampleUser()239 void A2dpCodecConfigSbcBase::SetBitsPerSampleUser()
240 {
241     switch (userCodecConfig_.bitsPerSample) {
242         case A2DP_SAMPLE_BITS_16:
243             codecCap_.bitsPerSample = userCodecConfig_.bitsPerSample;
244             codecConfig_.bitsPerSample = userCodecConfig_.bitsPerSample;
245             break;
246         case A2DP_SAMPLE_BITS_24:
247         case A2DP_SAMPLE_BITS_32:
248         case A2DP_SAMPLE_BITS_NONE:
249             codecCap_.bitsPerSample = A2DP_SAMPLE_BITS_NONE;
250             codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_NONE;
251             break;
252         default:
253             break;
254     }
255 }
256 
SetBitsPerSampleSelectableCapa(const A2dpSBCCapability & localCapability)257 void A2dpCodecConfigSbcBase::SetBitsPerSampleSelectableCapa(const A2dpSBCCapability &localCapability)
258 {
259     codecSelectableCap_.bitsPerSample = localCapability.bitsPerSample;
260     LOG_INFO("[CodecConfigSbcBase] %{public}s [CapBitsPerSample:0x%x]", __func__, codecSelectableCap_.bitsPerSample);
261 }
262 
SetBitsPerSampleCommonCapa()263 void A2dpCodecConfigSbcBase::SetBitsPerSampleCommonCapa()
264 {
265     codecCap_.bitsPerSample = A2DP_SAMPLE_BITS_16;
266     LOG_INFO("[CodecConfigSbcBase] %{public}s [bitsPerSample:0x%x]", __func__, codecCap_.bitsPerSample);
267 }
268 
SetBitsPerSampleAudioConfig(A2dpSBCCapability & resultCap)269 bool A2dpCodecConfigSbcBase::SetBitsPerSampleAudioConfig(A2dpSBCCapability &resultCap)
270 {
271     switch (audioCodecConfig_.bitsPerSample) {
272         case A2DP_SAMPLE_BITS_16:
273             codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_16;
274             resultCap.bitsPerSample = A2DP_SAMPLE_BITS_16;
275             return true;
276         case A2DP_SAMPLE_BITS_24:
277         case A2DP_SAMPLE_BITS_32:
278         case A2DP_SAMPLE_BITS_NONE:
279             break;
280         default:
281             break;
282     }
283     LOG_INFO("[CodecConfigSbcBase] %{public}s [not bits16]", __func__);
284     return false;
285 }
286 
SetBitsPerSampleBestMatch(A2dpSBCCapability & resultCap)287 bool A2dpCodecConfigSbcBase::SetBitsPerSampleBestMatch(A2dpSBCCapability &resultCap)
288 {
289     codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_16;
290     resultCap.bitsPerSample = A2DP_SAMPLE_BITS_16;
291     return true;
292 }
293 
SetBitsPerSampleDefaultConfig(A2dpSBCCapability & resultCap)294 bool A2dpCodecConfigSbcBase::SetBitsPerSampleDefaultConfig(A2dpSBCCapability &resultCap)
295 {
296     codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_16;
297     resultCap.bitsPerSample = A2DP_SAMPLE_BITS_16;
298     return true;
299 }
300 
SetBitsPerSample(const A2dpSBCCapability & localCapability,A2dpSBCCapability & resultCap)301 bool A2dpCodecConfigSbcBase::SetBitsPerSample(const A2dpSBCCapability &localCapability, A2dpSBCCapability &resultCap)
302 {
303     LOG_INFO("[CodecConfigSbcBase] %{public}s [uBits:0x%x][aBits:0x%x]",
304         __func__,
305         userCodecConfig_.bitsPerSample,
306         audioCodecConfig_.bitsPerSample);
307 
308     codecConfig_.bitsPerSample = A2DP_SAMPLE_BITS_NONE;
309 
310     SetBitsPerSampleUser();
311 
312     do {
313         SetBitsPerSampleSelectableCapa(localCapability);
314 
315         if (codecConfig_.bitsPerSample != A2DP_SAMPLE_BITS_NONE) {
316             break;
317         }
318 
319         SetBitsPerSampleCommonCapa();
320 
321         if (SetBitsPerSampleAudioConfig(resultCap)) {
322             break;
323         }
324 
325         if (SetBitsPerSampleDefaultConfig(resultCap)) {
326             break;
327         }
328 
329         if (SetBitsPerSampleBestMatch(resultCap)) {
330             break;
331         }
332     } while (false);
333 
334     LOG_INFO("[CodecConfigSbcBase] %{public}s [bitsPerSample:0x%x]", __func__, codecConfig_.bitsPerSample);
335 
336     if (codecConfig_.bitsPerSample == A2DP_SAMPLE_BITS_NONE) {
337         LOG_ERROR("%{public}s: bitsPerSample had no value", __func__);
338         return ResetCodecConfig();
339     }
340     return true;
341 }
342 
SetChannelModeUser(uint8_t chMode,A2dpSBCCapability & resultCap)343 void A2dpCodecConfigSbcBase::SetChannelModeUser(uint8_t chMode, A2dpSBCCapability &resultCap)
344 {
345     switch (userCodecConfig_.channelMode_) {
346         case A2DP_SBC_CHANNEL_MODE_MONO:
347             if (chMode & A2DP_SBC_CHANNEL_MODE_MONO) {
348                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_MONO;
349                 codecCap_.channelMode_ = userCodecConfig_.channelMode_;
350                 codecConfig_.channelMode_ = userCodecConfig_.channelMode_;
351             }
352             break;
353         case A2DP_SBC_CHANNEL_MODE_JOINT_STEREO:
354         case A2DP_SBC_CHANNEL_MODE_STEREO:
355         case A2DP_SBC_CHANNEL_MODE_DUAL:
356             if (chMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
357                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
358                 codecCap_.channelMode_ = userCodecConfig_.channelMode_;
359                 codecConfig_.channelMode_ = userCodecConfig_.channelMode_;
360                 break;
361             }
362             if (chMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
363                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_STEREO;
364                 codecCap_.channelMode_ = userCodecConfig_.channelMode_;
365                 codecConfig_.channelMode_ = userCodecConfig_.channelMode_;
366                 break;
367             }
368             if (chMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
369                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_DUAL;
370                 codecCap_.channelMode_ = userCodecConfig_.channelMode_;
371                 codecConfig_.channelMode_ = userCodecConfig_.channelMode_;
372                 break;
373             }
374             break;
375         case A2DP_CHANNEL_MODE_NONE:
376             resultCap.channelMode = A2DP_CHANNEL_MODE_NONE;
377             codecCap_.channelMode_ = A2DP_CHANNEL_MODE_NONE;
378             codecConfig_.channelMode_ = A2DP_CHANNEL_MODE_NONE;
379             break;
380         default:
381             break;
382     }
383 }
384 
SetChannelModeSelectableCapa(uint8_t chMode)385 void A2dpCodecConfigSbcBase::SetChannelModeSelectableCapa(uint8_t chMode)
386 {
387     if (chMode & A2DP_SBC_CHANNEL_MODE_MONO) {
388         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_MONO;
389     }
390     if (chMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
391         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
392     }
393     if (chMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
394         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
395     }
396     if (chMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
397         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
398     }
399 }
400 
SetChannelModeCommonCapa(uint8_t chMode)401 void A2dpCodecConfigSbcBase::SetChannelModeCommonCapa(uint8_t chMode)
402 {
403     if (chMode & A2DP_SBC_CHANNEL_MODE_MONO) {
404         codecCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_MONO;
405     }
406     if (chMode & (A2DP_SBC_CHANNEL_MODE_JOINT_STEREO | A2DP_SBC_CHANNEL_MODE_STEREO | A2DP_SBC_CHANNEL_MODE_DUAL)) {
407         codecCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
408     }
409 }
410 
SetChannelModeAudioConfig(uint8_t chMode,A2dpSBCCapability & resultCap)411 bool A2dpCodecConfigSbcBase::SetChannelModeAudioConfig(uint8_t chMode, A2dpSBCCapability &resultCap)
412 {
413     switch (audioCodecConfig_.channelMode_) {
414         case A2DP_SBC_CHANNEL_MODE_MONO:
415             if (chMode & A2DP_SBC_CHANNEL_MODE_MONO) {
416                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_MONO;
417                 codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_MONO;
418                 return true;
419             }
420             break;
421         case A2DP_SBC_CHANNEL_MODE_DUAL:
422             if (chMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
423                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_STEREO;
424                 codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_STEREO;
425                 return true;
426             }
427             break;
428         case A2DP_SBC_CHANNEL_MODE_STEREO:
429             if (chMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
430                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_STEREO;
431                 codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_STEREO;
432                 return true;
433             }
434             break;
435         case A2DP_SBC_CHANNEL_MODE_JOINT_STEREO:
436             if (chMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
437                 resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
438                 codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
439                 return true;
440             }
441             break;
442         default:
443             LOG_ERROR("[CodecConfigSbcBase] %{public}s [Mode None]", __func__);
444             break;
445     }
446     return false;
447 }
448 
SetChannelModeBestMatch(uint8_t chMode,A2dpSBCCapability & resultCap)449 bool A2dpCodecConfigSbcBase::SetChannelModeBestMatch(uint8_t chMode, A2dpSBCCapability &resultCap)
450 {
451     if (chMode & A2DP_SBC_CHANNEL_MODE_MONO) {
452         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_MONO;
453         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_MONO;
454         return true;
455     }
456 
457     if (chMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
458         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_STEREO;
459         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_STEREO;
460         return true;
461     }
462 
463     if (chMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
464         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_STEREO;
465         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_STEREO;
466         return true;
467     }
468 
469     if (chMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
470         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
471         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
472         return true;
473     }
474     return false;
475 }
476 
SetChannelModeDefaultConfig(uint8_t chMode,A2dpSBCCapability & resultCap)477 bool A2dpCodecConfigSbcBase::SetChannelModeDefaultConfig(uint8_t chMode, A2dpSBCCapability &resultCap)
478 {
479     if (chMode & A2DP_SBC_CHANNEL_MODE_MONO) {
480         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_MONO;
481         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_MONO;
482         return true;
483     }
484     if (chMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
485         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
486         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
487         return true;
488     }
489     if (chMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
490         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_STEREO;
491         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_STEREO;
492         return true;
493     }
494     if (chMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
495         resultCap.channelMode = A2DP_SBC_CHANNEL_MODE_DUAL;
496         codecConfig_.channelMode_ = A2DP_SBC_CHANNEL_MODE_DUAL;
497         return true;
498     }
499     return false;
500 }
501 
SetChannelMode(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability,A2dpSBCCapability & resultCap)502 bool A2dpCodecConfigSbcBase::SetChannelMode(
503     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability, A2dpSBCCapability &resultCap)
504 {
505     uint8_t chMode = localCapability.channelMode & peerCapability.channelMode;
506     codecConfig_.channelMode_ = A2DP_CHANNEL_MODE_NONE;
507 
508     LOG_INFO("[CodecConfigSbcBase] %{public}s [chMode:0x%x][uMode:0x%x][dMode:0x%x][aMode:0x%x][peer:0x%x]",
509         __func__,
510         chMode,
511         userCodecConfig_.channelMode_,
512         A2DP_SBC_DEFAULT_CONFIG.channelMode,
513         audioCodecConfig_.channelMode_,
514         peerCapability.channelMode);
515 
516     SetChannelModeUser(chMode, resultCap);
517 
518     do {
519         SetChannelModeSelectableCapa(chMode);
520 
521         if (codecConfig_.channelMode_ != A2DP_CHANNEL_MODE_NONE) {
522             break;
523         }
524 
525         SetChannelModeCommonCapa(chMode);
526 
527         if (SetChannelModeAudioConfig(chMode, resultCap)) {
528             break;
529         }
530 
531         if (SetChannelModeDefaultConfig(A2DP_SBC_DEFAULT_CONFIG.channelMode & peerCapability.channelMode, resultCap)) {
532             break;
533         }
534 
535         if (SetChannelModeBestMatch(chMode, resultCap)) {
536             break;
537         }
538     } while (false);
539 
540     LOG_INFO("[CodecConfigSbcBase] %{public}s [channelMode_:0x%x]", __func__, codecConfig_.channelMode_);
541 
542     if (codecConfig_.channelMode_ == A2DP_CHANNEL_MODE_NONE) {
543         LOG_ERROR("%{public}s: channelMode had no value", __func__);
544         return ResetCodecConfig();
545     }
546     return true;
547 }
548 
SetBlockLength(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability,A2dpSBCCapability & resultCap)549 bool A2dpCodecConfigSbcBase::SetBlockLength(
550     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability, A2dpSBCCapability &resultCap)
551 {
552     uint8_t blockLen = localCapability.blockLen & peerCapability.blockLen;
553 
554     LOG_INFO("[CodecConfigSbcBase] %{public}s [blockLen:0x%x]", __func__, blockLen);
555 
556     if (blockLen & A2DP_SBC_BLOCKS_16) {
557         resultCap.blockLen = A2DP_SBC_BLOCKS_16;
558     } else if (blockLen & A2DP_SBC_BLOCKS_12) {
559         resultCap.blockLen = A2DP_SBC_BLOCKS_12;
560     } else if (blockLen & A2DP_SBC_BLOCKS_8) {
561         resultCap.blockLen = A2DP_SBC_BLOCKS_8;
562     } else if (blockLen & A2DP_SBC_BLOCKS_4) {
563         resultCap.blockLen = A2DP_SBC_BLOCKS_4;
564     } else {
565         LOG_ERROR("%{public}s: BlockLength had no value", __func__);
566         return ResetCodecConfig();
567     }
568     return true;
569 }
570 
SetSubBands(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability,A2dpSBCCapability & resultCap)571 bool A2dpCodecConfigSbcBase::SetSubBands(
572     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability, A2dpSBCCapability &resultCap)
573 {
574     uint8_t numSubbands = localCapability.numSubbands & peerCapability.numSubbands;
575 
576     LOG_INFO("[CodecConfigSbcBase] %{public}s [numSubbands:0x%x]", __func__, numSubbands);
577 
578     if (numSubbands & A2DP_SBC_SUBBAND_8) {
579         resultCap.numSubbands = A2DP_SBC_SUBBAND_8;
580     } else if (numSubbands & A2DP_SBC_SUBBAND_4) {
581         resultCap.numSubbands = A2DP_SBC_SUBBAND_4;
582     } else {
583         LOG_ERROR("%{public}s: subBands had no value", __func__);
584         return ResetCodecConfig();
585     }
586     return true;
587 }
588 
SetAllocationMethod(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability,A2dpSBCCapability & resultCap)589 bool A2dpCodecConfigSbcBase::SetAllocationMethod(
590     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability, A2dpSBCCapability &resultCap)
591 {
592     uint8_t allocMethod = localCapability.allocatedMethod & peerCapability.allocatedMethod;
593 
594     LOG_INFO("[CodecConfigSbcBase] %{public}s [allocMethod:0x%x]", __func__, allocMethod);
595 
596     if (allocMethod & A2DP_SBC_ALLOC_MODE_L) {
597         resultCap.allocatedMethod = A2DP_SBC_ALLOC_MODE_L;
598     } else if (allocMethod & A2DP_SBC_ALLOC_MODE_S) {
599         resultCap.allocatedMethod = A2DP_SBC_ALLOC_MODE_S;
600     } else {
601         LOG_ERROR("%{public}s: subBands had no value", __func__);
602         return ResetCodecConfig();
603     }
604     return true;
605 }
606 
SetBitPool(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability,A2dpSBCCapability & resultCap)607 bool A2dpCodecConfigSbcBase::SetBitPool(
608     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability, A2dpSBCCapability &resultCap)
609 {
610     resultCap.minBitpool = localCapability.minBitpool;
611     if (resultCap.minBitpool < peerCapability.minBitpool) {
612         resultCap.minBitpool = peerCapability.minBitpool;
613     }
614 
615     resultCap.maxBitpool = localCapability.maxBitpool;
616     if (resultCap.maxBitpool > peerCapability.maxBitpool) {
617         resultCap.maxBitpool = peerCapability.maxBitpool;
618     }
619 
620     if (resultCap.minBitpool > localCapability.maxBitpool) {
621         LOG_ERROR("%{public}s: bitpool set err", __func__);
622         return ResetCodecConfig();
623     }
624     return true;
625 }
626 
SetCodecSpecific(void)627 bool A2dpCodecConfigSbcBase::SetCodecSpecific(void)
628 {
629     if (userCodecConfig_.codecSpecific1 != 0) {
630         codecConfig_.codecSpecific1 = userCodecConfig_.codecSpecific1;
631     }
632     if (userCodecConfig_.codecSpecific2 != 0) {
633         codecConfig_.codecSpecific2 = userCodecConfig_.codecSpecific2;
634     }
635     if (userCodecConfig_.codecSpecific3 != 0) {
636         codecConfig_.codecSpecific3 = userCodecConfig_.codecSpecific3;
637     }
638     if (userCodecConfig_.codecSpecific4 != 0) {
639         codecConfig_.codecSpecific4 = userCodecConfig_.codecSpecific4;
640     }
641     return true;
642 }
643 
ResetCodecConfig(void)644 bool A2dpCodecConfigSbcBase::ResetCodecConfig(void)
645 {
646     LOG_ERROR("[CodecConfigSbcBase] %{public}s", __func__);
647     codecConfig_ = savedCodecConfig_;
648     codecCap_ = savedCodecCapability_;
649     userCodecConfig_ = savedCodecUserConfig_;
650     (void)memcpy_s(otaCodecConfig_, A2DP_CODEC_SIZE, savedOtaCodecConfig_, A2DP_CODEC_SIZE);
651     return false;
652 }
653 
SetCodecConfig(const uint8_t * peerCodeInfo,uint8_t * resultCodecInfo)654 bool A2dpCodecConfigSbcBase::SetCodecConfig(const uint8_t *peerCodeInfo, uint8_t *resultCodecInfo)
655 {
656     LOG_INFO("[CodecConfigSbcBase] %{public}s", __func__);
657     const A2dpSBCCapability *a2dpSbcCaps = (isSource_) ? &A2DP_SBC_SOURCE_CAPS : &A2DP_SBC_SINK_CAPS;
658     A2dpSBCCapability cfgCap = {};
659     A2dpSBCCapability cfgCapResult = {};
660     savedCodecConfig_ = codecConfig_;
661     savedCodecCapability_ = codecCap_;
662     savedCodecUserConfig_ = userCodecConfig_;
663     (void)memcpy_s(savedOtaCodecConfig_, A2DP_CODEC_SIZE, otaCodecConfig_, A2DP_CODEC_SIZE);
664 
665     if (ParseInfoSbc(&cfgCap, peerCodeInfo) != A2DP_SUCCESS) {
666         LOG_INFO("[CodecConfigSbcBase] %{public}s: can't parse peer's capabilities", __func__);
667         return ResetCodecConfig();
668     }
669 
670     if (SetSampleRate(*a2dpSbcCaps, cfgCap, cfgCapResult) != true) {
671         LOG_ERROR("%{public}s: SetSampleRate failed", __func__);
672     }
673     if (SetBitsPerSample(*a2dpSbcCaps, cfgCapResult) != true) {
674         LOG_ERROR("%{public}s: SetBitsPerSample failed", __func__);
675     }
676     if (SetChannelMode(*a2dpSbcCaps, cfgCap, cfgCapResult) != true) {
677         LOG_ERROR("%{public}s: SetChannelMode failed", __func__);
678     }
679     if (SetBlockLength(*a2dpSbcCaps, cfgCap, cfgCapResult) != true) {
680         LOG_ERROR("%{public}s: SetBlockLength failed", __func__);
681     }
682     if (SetSubBands(*a2dpSbcCaps, cfgCap, cfgCapResult) != true) {
683         LOG_ERROR("%{public}s: SetSubBands failed", __func__);
684     }
685     if (SetAllocationMethod(*a2dpSbcCaps, cfgCap, cfgCapResult) != true) {
686         LOG_ERROR("%{public}s: SetAllocationMethod failed", __func__);
687     }
688     if (SetBitPool(*a2dpSbcCaps, cfgCap, cfgCapResult) != true) {
689         LOG_ERROR("%{public}s: SetBitPool failed", __func__);
690     }
691 
692     if (BuildSbcInfo(&cfgCapResult, resultCodecInfo) != A2DP_SUCCESS) {
693         LOG_INFO("[CodecConfigSbcBase] %{public}s: BuildSbcInfo for return config failed", __func__);
694         return ResetCodecConfig();
695     }
696 
697     SetCodecSpecific();
698 
699     if (BuildSbcInfo(&cfgCapResult, otaCodecConfig_) != A2DP_SUCCESS) {
700         LOG_INFO("[CodecConfigSbcBase] %{public}s: Build Sbc Info failed", __func__);
701         return ResetCodecConfig();
702     }
703     return true;
704 }
705 
SetSampleFrameCapa(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability)706 void A2dpCodecConfigSbcBase::SetSampleFrameCapa(
707     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability)
708 {
709     uint32_t sampFreq = localCapability.sampleFreq & peerCapability.sampleFreq;
710     if (sampFreq & A2DP_SBC_SAMPLE_RATE_44100) {
711         codecSelectableCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_44100;
712     }
713     if (sampFreq & A2DP_SBC_SAMPLE_RATE_48000) {
714         codecSelectableCap_.sampleRate_ |= A2DP_SBC_SAMPLE_RATE_48000;
715     }
716 }
717 
SetBitsPerSampleCapa(const A2dpSBCCapability & localCapability)718 void A2dpCodecConfigSbcBase::SetBitsPerSampleCapa(const A2dpSBCCapability &localCapability)
719 {
720     codecSelectableCap_.bitsPerSample = localCapability.bitsPerSample;
721 }
722 
SetChannelModeCapa(const A2dpSBCCapability & localCapability,A2dpSBCCapability peerCapability)723 void A2dpCodecConfigSbcBase::SetChannelModeCapa(
724     const A2dpSBCCapability &localCapability, A2dpSBCCapability peerCapability)
725 {
726     uint32_t chMode = localCapability.channelMode & peerCapability.channelMode;
727     if (chMode & A2DP_SBC_CHANNEL_MODE_MONO) {
728         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_MONO;
729     }
730     if (chMode & A2DP_SBC_CHANNEL_MODE_JOINT_STEREO) {
731         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_JOINT_STEREO;
732     }
733     if (chMode & A2DP_SBC_CHANNEL_MODE_STEREO) {
734         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_STEREO;
735     }
736     if (chMode & A2DP_SBC_CHANNEL_MODE_DUAL) {
737         codecSelectableCap_.channelMode_ |= A2DP_SBC_CHANNEL_MODE_DUAL;
738     }
739 }
740 
ResetCodecCapability(void)741 bool A2dpCodecConfigSbcBase::ResetCodecCapability(void)
742 {
743     LOG_ERROR("[CodecConfigSbcBase] %{public}s", __func__);
744     codecSelectableCap_ = savedCodecSelectableCapability;
745     (void)memcpy_s(otaCodecPeerCapability_, A2DP_CODEC_SIZE, savedOtaCodecPeerCapability, A2DP_CODEC_SIZE);
746     return false;
747 }
748 
SetPeerCodecCapabilities(const uint8_t * peerCapabilities)749 bool A2dpCodecConfigSbcBase::SetPeerCodecCapabilities(const uint8_t *peerCapabilities)
750 {
751     const A2dpSBCCapability *a2dpSbcCaps = (isSource_) ? &A2DP_SBC_SOURCE_CAPS : &A2DP_SBC_SINK_CAPS;
752 
753     A2dpSBCCapability cfgCap = {};
754 
755     if (ParseInfoSbc(&cfgCap, peerCapabilities) != A2DP_SUCCESS) {
756         LOG_ERROR("[CodecConfigSbcBase]%{public}s: can't parse peer's capabilities", __func__);
757         return ResetCodecCapability();
758     }
759     SetSampleFrameCapa(*a2dpSbcCaps, cfgCap);
760     SetBitsPerSampleCapa(*a2dpSbcCaps);
761     SetChannelModeCapa(*a2dpSbcCaps, cfgCap);
762 
763     if (BuildSbcInfo(&cfgCap, otaCodecPeerCapability_) != A2DP_SUCCESS) {
764         LOG_ERROR("[CodecConfigSbcBase]%{public}s: BuildSbcInfo Error", __func__);
765         return ResetCodecCapability();
766     }
767     return true;
768 }
769 
GetMinBitpoolSbc(const uint8_t * codecInfo)770 int GetMinBitpoolSbc(const uint8_t *codecInfo)
771 {
772     A2dpSBCCapability cfgCap = {};
773     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
774         LOG_ERROR("%{public}s: cannot get Minpool information", __func__);
775         return -1;
776     }
777     LOG_INFO("[CodecConfigSbcBase] %{public}s [minBitpool:0x%x]", __func__, cfgCap.minBitpool);
778     return cfgCap.minBitpool;
779 }
780 
GetMaxBitpoolSbc(const uint8_t * codecInfo)781 int GetMaxBitpoolSbc(const uint8_t *codecInfo)
782 {
783     A2dpSBCCapability cfgCap = {};
784     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
785         LOG_ERROR("%{public}s: cannot Maxpool information", __func__);
786         return -1;
787     }
788     LOG_INFO("[CodecConfigSbcBase] %{public}s [maxBitpool:0x%x]", __func__, cfgCap.maxBitpool);
789     return cfgCap.maxBitpool;
790 }
791 
GetSampleRateSbc(const uint8_t * codecInfo)792 int GetSampleRateSbc(const uint8_t *codecInfo)
793 {
794     A2dpSBCCapability cfgCap = {};
795     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
796         LOG_ERROR("%{public}s: cannot get SampleRate Sbc information", __func__);
797         return -1;
798     }
799     LOG_INFO("[CodecConfigSbcBase] %{public}s [sampleFreq:0x%x]", __func__, cfgCap.sampleFreq);
800     return cfgCap.sampleFreq;
801 }
802 
GetTrackChannelModeSbc(const uint8_t * codecInfo)803 int GetTrackChannelModeSbc(const uint8_t *codecInfo)
804 {
805     A2dpSBCCapability cfgCap = {};
806     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
807         LOG_ERROR("%{public}s: cannot get Track ChannelMode information", __func__);
808         return -1;
809     }
810     LOG_INFO("[CodecConfigSbcBase] %{public}s [channelMode:0x%x]", __func__, cfgCap.channelMode);
811     return cfgCap.channelMode;
812 }
813 
GetTrackChannelCountSbc(const uint8_t * codecInfo)814 int GetTrackChannelCountSbc(const uint8_t *codecInfo)
815 {
816     A2dpSBCCapability cfgCap = {};
817     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
818         LOG_ERROR("%{public}s: cannot get TrackChannel information", __func__);
819         return -1;
820     }
821     LOG_INFO("[CodecConfigSbcBase] %{public}s [channelMode:0x%x]", __func__, cfgCap.channelMode);
822     return cfgCap.channelMode;
823 }
824 
GetNumberOfSubbandsSbc(const uint8_t * codecInfo)825 int GetNumberOfSubbandsSbc(const uint8_t *codecInfo)
826 {
827     A2dpSBCCapability cfgCap = {};
828     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
829         LOG_ERROR("%{public}s: cannot get NumberOfSubbands information", __func__);
830         return -1;
831     }
832     LOG_INFO("[CodecConfigSbcBase] %{public}s [numSubbands:0x%x]", __func__, cfgCap.numSubbands);
833     return cfgCap.numSubbands;
834 }
835 
GetNumberOfBlocksSbc(const uint8_t * codecInfo)836 int GetNumberOfBlocksSbc(const uint8_t *codecInfo)
837 {
838     A2dpSBCCapability cfgCap = {};
839     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
840         LOG_ERROR("%{public}s: cannot get NumberOfBlocks information", __func__);
841         return -1;
842     }
843     LOG_INFO("[CodecConfigSbcBase] %{public}s [blockLen:0x%x]", __func__, cfgCap.blockLen);
844     return cfgCap.blockLen;
845 }
846 
GetAllocationMethodCodeSbc(const uint8_t * codecInfo)847 int GetAllocationMethodCodeSbc(const uint8_t *codecInfo)
848 {
849     A2dpSBCCapability cfgCap = {};
850     if (ParseInfoSbc(&cfgCap, codecInfo) != A2DP_SUCCESS) {
851         LOG_ERROR("%{public}s: cannot get AllocationMethodCode information", __func__);
852         return -1;
853     }
854     LOG_INFO("[CodecConfigSbcBase] %{public}s [allocatedMethod:0x%x]", __func__, cfgCap.allocatedMethod);
855     return cfgCap.allocatedMethod;
856 }
857 
BuildSbcInfo(A2dpSBCCapability * sbcCap,uint8_t * codecInfo)858 uint8_t BuildSbcInfo(A2dpSBCCapability *sbcCap, uint8_t *codecInfo)
859 {
860     LOG_INFO("[CodecConfig] %{public}s", __func__);
861     /// SBC codec Info
862     *codecInfo++ = A2DP_CODEC_SBC_INFO_LEN;  /// sbc information length
863     *codecInfo++ = (A2DP_MEDIA_TYPE_AUDIO << BIT_MOVE_LEFT4);
864     *codecInfo++ = 0;  /// SBC media codec type
865     *codecInfo++ = sbcCap->sampleFreq | sbcCap->channelMode;
866     *codecInfo++ = sbcCap->blockLen | sbcCap->numSubbands | sbcCap->allocatedMethod;
867     *codecInfo++ = sbcCap->minBitpool;
868     *codecInfo++ = sbcCap->maxBitpool;
869     LOG_INFO("[CodecConfig] %{public}s End", __func__);
870     return A2DP_SUCCESS;
871 }
872 
ParseInfoSbc(A2dpSBCCapability * sbcCap,const uint8_t * codecInfo)873 uint8_t ParseInfoSbc(A2dpSBCCapability *sbcCap, const uint8_t *codecInfo)
874 {
875     LOG_INFO("[CodecConfigSbcBase] %{public}s", __func__);
876     uint8_t losc;
877     uint8_t mediaType;
878     uint8_t codecType;
879     if (codecInfo == nullptr) {
880         LOG_ERROR("[CodecConfigSbcBase]%{public}s codecInfo is NULL", __func__);
881         return A2DP_CODEC_ERROR_INVALID_PARAMS;
882     }
883 
884     losc = *codecInfo++;
885     if (losc != A2DP_CODEC_SBC_INFO_LEN) {
886         LOG_ERROR("[CodecConfigSbcBase]%{public}s wrong codec", __func__);
887         return A2DP_CODEC_ERROR_WRONG_CODEC;
888     }
889 
890     mediaType = (*codecInfo++) >> BIT_MOVE_RIGHT4;
891     codecType = *codecInfo++;
892     if ((mediaType != A2DP_MEDIA_TYPE_AUDIO) || (codecType != A2DP_CODEC_TYPE_SBC)) {
893         LOG_ERROR("[CodecConfigSbcBase]%{public}s wrong media type", __func__);
894         return A2DP_CODEC_ERROR_WRONG_CODEC;
895     }
896     sbcCap->sampleFreq = *codecInfo & A2DP_SBC_SAMPLE_RATE_MSK;
897     sbcCap->channelMode = *codecInfo & A2DP_SBC_CHANNEL_MODE_MSK;
898     codecInfo++;
899     sbcCap->blockLen = *codecInfo & A2DP_SBC_BLOCKS_MSK;
900     sbcCap->numSubbands = *codecInfo & A2DP_SBC_SUBBAND_MSK;
901     sbcCap->allocatedMethod = *codecInfo & A2DP_SBC_ALLOC_MODE_MSK;
902     codecInfo++;
903     sbcCap->minBitpool = *codecInfo++;
904     sbcCap->maxBitpool = *codecInfo++;
905     if ((sbcCap->minBitpool < A2DP_SBC_MIN_BITPOOL) || (sbcCap->minBitpool > A2DP_SBC_MAX_BITPOOL)) {
906         LOG_ERROR("[CodecConfigSbcBase]%{public}s wrong min pool", __func__);
907         return A2DP_CODEC_ERROR_BAD_MIN_BITPOOL;
908     }
909 
910     if ((sbcCap->maxBitpool < A2DP_SBC_MIN_BITPOOL) || (sbcCap->maxBitpool > A2DP_SBC_MAX_BITPOOL) ||
911         (sbcCap->maxBitpool < sbcCap->minBitpool)) {
912         LOG_ERROR("[CodecConfigSbcBase]%{public}s wrong max pool", __func__);
913         return A2DP_CODEC_ERROR_BAD_MAX_BITPOOL;
914     }
915 
916     return A2DP_SUCCESS;
917 }
918 
919 
IsSbcConfigChanged(const uint8_t * lastCodecInfo,const uint8_t * newCodecInfo)920 bool IsSbcConfigChanged(const uint8_t *lastCodecInfo, const uint8_t *newCodecInfo)
921 {
922     A2dpSBCCapability lastInfo = {};
923     A2dpSBCCapability newInfo = {};
924 
925     if (ParseInfoSbc(&lastInfo, lastCodecInfo) != A2DP_SUCCESS) {
926         LOG_ERROR("%{public}s: cannot parse lastCodecInfo", __func__);
927         return false;
928     }
929 
930     if (ParseInfoSbc(&newInfo, newCodecInfo) != A2DP_SUCCESS) {
931         LOG_ERROR("%{public}s: cannot parse newCodecInfo", __func__);
932         return false;
933     }
934 
935     return (lastInfo.sampleFreq == newInfo.sampleFreq) && (lastInfo.channelMode == newInfo.channelMode) &&
936            (lastInfo.blockLen == newInfo.blockLen) && (lastInfo.numSubbands == newInfo.numSubbands) &&
937            (lastInfo.allocatedMethod == newInfo.allocatedMethod) && (lastInfo.minBitpool == newInfo.minBitpool) &&
938            (lastInfo.maxBitpool == newInfo.maxBitpool);
939 }
940 }  // namespace bluetooth
941 }  // namespace OHOS