1 /******************************************************************************
2 *
3 * Copyright 2002-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * Utility functions to help build and parse SBC Codec Information Element
22 * and Media Payload.
23 *
24 ******************************************************************************/
25
26 #define LOG_TAG "a2dp_sbc"
27
28 #include "bt_target.h"
29
30 #include "a2dp_sbc.h"
31
32 #include <string.h>
33
34 #include <base/logging.h>
35 #include "a2dp_sbc_decoder.h"
36 #include "a2dp_sbc_encoder.h"
37 #include "bt_utils.h"
38 #include "embdrv/sbc/encoder/include/sbc_encoder.h"
39 #include "osi/include/log.h"
40 #include "osi/include/osi.h"
41
42 #define A2DP_SBC_MAX_BITPOOL 53
43
44 /* data type for the SBC Codec Information Element */
45 typedef struct {
46 uint8_t samp_freq; /* Sampling frequency */
47 uint8_t ch_mode; /* Channel mode */
48 uint8_t block_len; /* Block length */
49 uint8_t num_subbands; /* Number of subbands */
50 uint8_t alloc_method; /* Allocation method */
51 uint8_t min_bitpool; /* Minimum bitpool */
52 uint8_t max_bitpool; /* Maximum bitpool */
53 btav_a2dp_codec_bits_per_sample_t bits_per_sample;
54 } tA2DP_SBC_CIE;
55
56 /* SBC Source codec capabilities */
57 static const tA2DP_SBC_CIE a2dp_sbc_source_caps = {
58 (A2DP_SBC_IE_SAMP_FREQ_44), /* samp_freq */
59 (A2DP_SBC_IE_CH_MD_MONO | A2DP_SBC_IE_CH_MD_JOINT), /* ch_mode */
60 (A2DP_SBC_IE_BLOCKS_16 | A2DP_SBC_IE_BLOCKS_12 | A2DP_SBC_IE_BLOCKS_8 |
61 A2DP_SBC_IE_BLOCKS_4), /* block_len */
62 A2DP_SBC_IE_SUBBAND_8, /* num_subbands */
63 A2DP_SBC_IE_ALLOC_MD_L, /* alloc_method */
64 A2DP_SBC_IE_MIN_BITPOOL, /* min_bitpool */
65 A2DP_SBC_MAX_BITPOOL, /* max_bitpool */
66 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 /* bits_per_sample */
67 };
68
69 /* SBC Sink codec capabilities */
70 static const tA2DP_SBC_CIE a2dp_sbc_sink_caps = {
71 (A2DP_SBC_IE_SAMP_FREQ_48 | A2DP_SBC_IE_SAMP_FREQ_44), /* samp_freq */
72 (A2DP_SBC_IE_CH_MD_MONO | A2DP_SBC_IE_CH_MD_STEREO |
73 A2DP_SBC_IE_CH_MD_JOINT | A2DP_SBC_IE_CH_MD_DUAL), /* ch_mode */
74 (A2DP_SBC_IE_BLOCKS_16 | A2DP_SBC_IE_BLOCKS_12 | A2DP_SBC_IE_BLOCKS_8 |
75 A2DP_SBC_IE_BLOCKS_4), /* block_len */
76 (A2DP_SBC_IE_SUBBAND_4 | A2DP_SBC_IE_SUBBAND_8), /* num_subbands */
77 (A2DP_SBC_IE_ALLOC_MD_L | A2DP_SBC_IE_ALLOC_MD_S), /* alloc_method */
78 A2DP_SBC_IE_MIN_BITPOOL, /* min_bitpool */
79 A2DP_SBC_MAX_BITPOOL, /* max_bitpool */
80 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 /* bits_per_sample */
81 };
82
83 /* Default SBC codec configuration */
84 const tA2DP_SBC_CIE a2dp_sbc_default_config = {
85 A2DP_SBC_IE_SAMP_FREQ_44, /* samp_freq */
86 A2DP_SBC_IE_CH_MD_JOINT, /* ch_mode */
87 A2DP_SBC_IE_BLOCKS_16, /* block_len */
88 A2DP_SBC_IE_SUBBAND_8, /* num_subbands */
89 A2DP_SBC_IE_ALLOC_MD_L, /* alloc_method */
90 A2DP_SBC_IE_MIN_BITPOOL, /* min_bitpool */
91 A2DP_SBC_MAX_BITPOOL, /* max_bitpool */
92 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 /* bits_per_sample */
93 };
94
95 static const tA2DP_ENCODER_INTERFACE a2dp_encoder_interface_sbc = {
96 a2dp_sbc_encoder_init,
97 a2dp_sbc_encoder_cleanup,
98 a2dp_sbc_feeding_reset,
99 a2dp_sbc_feeding_flush,
100 a2dp_sbc_get_encoder_interval_ms,
101 a2dp_sbc_send_frames,
102 nullptr // set_transmit_queue_length
103 };
104
105 static const tA2DP_DECODER_INTERFACE a2dp_decoder_interface_sbc = {
106 a2dp_sbc_decoder_init, a2dp_sbc_decoder_cleanup,
107 a2dp_sbc_decoder_decode_packet,
108 };
109
110 static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilitySbc(
111 const tA2DP_SBC_CIE* p_cap, const uint8_t* p_codec_info,
112 bool is_capability);
113 static void A2DP_ParseMplHeaderSbc(uint8_t* p_src, bool* p_frag, bool* p_start,
114 bool* p_last, uint8_t* p_num);
115
116 // Builds the SBC Media Codec Capabilities byte sequence beginning from the
117 // LOSC octet. |media_type| is the media type |AVDT_MEDIA_TYPE_*|.
118 // |p_ie| is a pointer to the SBC Codec Information Element information.
119 // The result is stored in |p_result|. Returns A2DP_SUCCESS on success,
120 // otherwise the corresponding A2DP error status code.
A2DP_BuildInfoSbc(uint8_t media_type,const tA2DP_SBC_CIE * p_ie,uint8_t * p_result)121 static tA2DP_STATUS A2DP_BuildInfoSbc(uint8_t media_type,
122 const tA2DP_SBC_CIE* p_ie,
123 uint8_t* p_result) {
124 if (p_ie == NULL || p_result == NULL ||
125 (p_ie->samp_freq & ~A2DP_SBC_IE_SAMP_FREQ_MSK) ||
126 (p_ie->ch_mode & ~A2DP_SBC_IE_CH_MD_MSK) ||
127 (p_ie->block_len & ~A2DP_SBC_IE_BLOCKS_MSK) ||
128 (p_ie->num_subbands & ~A2DP_SBC_IE_SUBBAND_MSK) ||
129 (p_ie->alloc_method & ~A2DP_SBC_IE_ALLOC_MD_MSK) ||
130 (p_ie->min_bitpool > p_ie->max_bitpool) ||
131 (p_ie->min_bitpool < A2DP_SBC_IE_MIN_BITPOOL) ||
132 (p_ie->min_bitpool > A2DP_SBC_IE_MAX_BITPOOL) ||
133 (p_ie->max_bitpool < A2DP_SBC_IE_MIN_BITPOOL) ||
134 (p_ie->max_bitpool > A2DP_SBC_IE_MAX_BITPOOL)) {
135 /* if any unused bit is set */
136 return A2DP_INVALID_PARAMS;
137 }
138
139 *p_result++ = A2DP_SBC_INFO_LEN;
140 *p_result++ = (media_type << 4);
141 *p_result++ = A2DP_MEDIA_CT_SBC;
142
143 /* Media Codec Specific Information Element */
144 *p_result++ = p_ie->samp_freq | p_ie->ch_mode;
145
146 *p_result++ = p_ie->block_len | p_ie->num_subbands | p_ie->alloc_method;
147
148 *p_result++ = p_ie->min_bitpool;
149 *p_result = p_ie->max_bitpool;
150
151 return A2DP_SUCCESS;
152 }
153
154 // Parses the SBC Media Codec Capabilities byte sequence beginning from the
155 // LOSC octet. The result is stored in |p_ie|. The byte sequence to parse is
156 // |p_codec_info|. If |is_capability| is true, the byte sequence contains
157 // codec capability.
158 // Returns A2DP_SUCCESS on success, otherwise the corresponding A2DP error
159 // status code.
A2DP_ParseInfoSbc(tA2DP_SBC_CIE * p_ie,const uint8_t * p_codec_info,bool is_capability)160 static tA2DP_STATUS A2DP_ParseInfoSbc(tA2DP_SBC_CIE* p_ie,
161 const uint8_t* p_codec_info,
162 bool is_capability) {
163 uint8_t losc;
164 uint8_t media_type;
165 tA2DP_CODEC_TYPE codec_type;
166
167 if (p_ie == NULL || p_codec_info == NULL) return A2DP_INVALID_PARAMS;
168
169 // Check the codec capability length
170 losc = *p_codec_info++;
171 if (losc != A2DP_SBC_INFO_LEN) return A2DP_WRONG_CODEC;
172
173 media_type = (*p_codec_info++) >> 4;
174 codec_type = *p_codec_info++;
175 /* Check the Media Type and Media Codec Type */
176 if (media_type != AVDT_MEDIA_TYPE_AUDIO || codec_type != A2DP_MEDIA_CT_SBC) {
177 return A2DP_WRONG_CODEC;
178 }
179
180 p_ie->samp_freq = *p_codec_info & A2DP_SBC_IE_SAMP_FREQ_MSK;
181 p_ie->ch_mode = *p_codec_info & A2DP_SBC_IE_CH_MD_MSK;
182 p_codec_info++;
183 p_ie->block_len = *p_codec_info & A2DP_SBC_IE_BLOCKS_MSK;
184 p_ie->num_subbands = *p_codec_info & A2DP_SBC_IE_SUBBAND_MSK;
185 p_ie->alloc_method = *p_codec_info & A2DP_SBC_IE_ALLOC_MD_MSK;
186 p_codec_info++;
187 p_ie->min_bitpool = *p_codec_info++;
188 p_ie->max_bitpool = *p_codec_info++;
189 if (p_ie->min_bitpool < A2DP_SBC_IE_MIN_BITPOOL ||
190 p_ie->min_bitpool > A2DP_SBC_IE_MAX_BITPOOL) {
191 return A2DP_BAD_MIN_BITPOOL;
192 }
193
194 if (p_ie->max_bitpool < A2DP_SBC_IE_MIN_BITPOOL ||
195 p_ie->max_bitpool > A2DP_SBC_IE_MAX_BITPOOL ||
196 p_ie->max_bitpool < p_ie->min_bitpool) {
197 return A2DP_BAD_MAX_BITPOOL;
198 }
199
200 if (is_capability) return A2DP_SUCCESS;
201
202 if (A2DP_BitsSet(p_ie->samp_freq) != A2DP_SET_ONE_BIT)
203 return A2DP_BAD_SAMP_FREQ;
204 if (A2DP_BitsSet(p_ie->ch_mode) != A2DP_SET_ONE_BIT) return A2DP_BAD_CH_MODE;
205 if (A2DP_BitsSet(p_ie->block_len) != A2DP_SET_ONE_BIT)
206 return A2DP_BAD_BLOCK_LEN;
207 if (A2DP_BitsSet(p_ie->num_subbands) != A2DP_SET_ONE_BIT)
208 return A2DP_BAD_SUBBANDS;
209 if (A2DP_BitsSet(p_ie->alloc_method) != A2DP_SET_ONE_BIT)
210 return A2DP_BAD_ALLOC_METHOD;
211
212 return A2DP_SUCCESS;
213 }
214
215 // Build the SBC Media Payload Header.
216 // |p_dst| points to the location where the header should be written to.
217 // If |frag| is true, the media payload frame is fragmented.
218 // |start| is true for the first packet of a fragmented frame.
219 // |last| is true for the last packet of a fragmented frame.
220 // If |frag| is false, |num| is the number of number of frames in the packet,
221 // otherwise is the number of remaining fragments (including this one).
A2DP_BuildMediaPayloadHeaderSbc(uint8_t * p_dst,bool frag,bool start,bool last,uint8_t num)222 static void A2DP_BuildMediaPayloadHeaderSbc(uint8_t* p_dst, bool frag,
223 bool start, bool last,
224 uint8_t num) {
225 if (p_dst == NULL) return;
226
227 *p_dst = 0;
228 if (frag) *p_dst |= A2DP_SBC_HDR_F_MSK;
229 if (start) *p_dst |= A2DP_SBC_HDR_S_MSK;
230 if (last) *p_dst |= A2DP_SBC_HDR_L_MSK;
231 *p_dst |= (A2DP_SBC_HDR_NUM_MSK & num);
232 }
233
234 /******************************************************************************
235 *
236 * Function A2DP_ParseMplHeaderSbc
237 *
238 * Description This function is called by an application to parse
239 * the SBC Media Payload header.
240 * Input Parameters:
241 * p_src: the byte sequence to parse..
242 *
243 * Output Parameters:
244 * frag: 1, if fragmented. 0, otherwise.
245 *
246 * start: 1, if the starting packet of a fragmented frame.
247 *
248 * last: 1, if the last packet of a fragmented frame.
249 *
250 * num: If frag is 1, this is the number of remaining
251 * fragments
252 * (including this fragment) of this frame.
253 * If frag is 0, this is the number of frames in
254 * this packet.
255 *
256 * Returns void.
257 *****************************************************************************/
A2DP_ParseMplHeaderSbc(uint8_t * p_src,bool * p_frag,bool * p_start,bool * p_last,uint8_t * p_num)258 UNUSED_ATTR static void A2DP_ParseMplHeaderSbc(uint8_t* p_src, bool* p_frag,
259 bool* p_start, bool* p_last,
260 uint8_t* p_num) {
261 if (p_src && p_frag && p_start && p_last && p_num) {
262 *p_frag = (*p_src & A2DP_SBC_HDR_F_MSK) ? true : false;
263 *p_start = (*p_src & A2DP_SBC_HDR_S_MSK) ? true : false;
264 *p_last = (*p_src & A2DP_SBC_HDR_L_MSK) ? true : false;
265 *p_num = (*p_src & A2DP_SBC_HDR_NUM_MSK);
266 }
267 }
268
A2DP_CodecNameSbc(UNUSED_ATTR const uint8_t * p_codec_info)269 const char* A2DP_CodecNameSbc(UNUSED_ATTR const uint8_t* p_codec_info) {
270 return "SBC";
271 }
272
A2DP_IsSourceCodecValidSbc(const uint8_t * p_codec_info)273 bool A2DP_IsSourceCodecValidSbc(const uint8_t* p_codec_info) {
274 tA2DP_SBC_CIE cfg_cie;
275
276 /* Use a liberal check when parsing the codec info */
277 return (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||
278 (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);
279 }
280
A2DP_IsSinkCodecValidSbc(const uint8_t * p_codec_info)281 bool A2DP_IsSinkCodecValidSbc(const uint8_t* p_codec_info) {
282 tA2DP_SBC_CIE cfg_cie;
283
284 /* Use a liberal check when parsing the codec info */
285 return (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||
286 (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);
287 }
288
A2DP_IsPeerSourceCodecValidSbc(const uint8_t * p_codec_info)289 bool A2DP_IsPeerSourceCodecValidSbc(const uint8_t* p_codec_info) {
290 tA2DP_SBC_CIE cfg_cie;
291
292 /* Use a liberal check when parsing the codec info */
293 return (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||
294 (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);
295 }
296
A2DP_IsPeerSinkCodecValidSbc(const uint8_t * p_codec_info)297 bool A2DP_IsPeerSinkCodecValidSbc(const uint8_t* p_codec_info) {
298 tA2DP_SBC_CIE cfg_cie;
299
300 /* Use a liberal check when parsing the codec info */
301 return (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||
302 (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);
303 }
304
A2DP_IsSinkCodecSupportedSbc(const uint8_t * p_codec_info)305 bool A2DP_IsSinkCodecSupportedSbc(const uint8_t* p_codec_info) {
306 return (A2DP_CodecInfoMatchesCapabilitySbc(&a2dp_sbc_sink_caps, p_codec_info,
307 false) == A2DP_SUCCESS);
308 }
309
A2DP_IsPeerSourceCodecSupportedSbc(const uint8_t * p_codec_info)310 bool A2DP_IsPeerSourceCodecSupportedSbc(const uint8_t* p_codec_info) {
311 return (A2DP_CodecInfoMatchesCapabilitySbc(&a2dp_sbc_sink_caps, p_codec_info,
312 true) == A2DP_SUCCESS);
313 }
314
A2DP_InitDefaultCodecSbc(uint8_t * p_codec_info)315 void A2DP_InitDefaultCodecSbc(uint8_t* p_codec_info) {
316 if (A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &a2dp_sbc_default_config,
317 p_codec_info) != A2DP_SUCCESS) {
318 LOG_ERROR(LOG_TAG, "%s: A2DP_BuildInfoSbc failed", __func__);
319 }
320 }
321
322 // Checks whether A2DP SBC codec configuration matches with a device's codec
323 // capabilities. |p_cap| is the SBC codec configuration. |p_codec_info| is
324 // the device's codec capabilities. |is_capability| is true if
325 // |p_codec_info| contains A2DP codec capability.
326 // Returns A2DP_SUCCESS if the codec configuration matches with capabilities,
327 // otherwise the corresponding A2DP error status code.
A2DP_CodecInfoMatchesCapabilitySbc(const tA2DP_SBC_CIE * p_cap,const uint8_t * p_codec_info,bool is_capability)328 static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilitySbc(
329 const tA2DP_SBC_CIE* p_cap, const uint8_t* p_codec_info,
330 bool is_capability) {
331 tA2DP_STATUS status;
332 tA2DP_SBC_CIE cfg_cie;
333
334 /* parse configuration */
335 status = A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, is_capability);
336 if (status != A2DP_SUCCESS) {
337 LOG_ERROR(LOG_TAG, "%s: parsing failed %d", __func__, status);
338 return status;
339 }
340
341 /* verify that each parameter is in range */
342
343 LOG_VERBOSE(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,
344 cfg_cie.samp_freq, p_cap->samp_freq);
345 LOG_VERBOSE(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,
346 cfg_cie.ch_mode, p_cap->ch_mode);
347 LOG_VERBOSE(LOG_TAG, "%s: BLOCK_LEN peer: 0x%x, capability 0x%x", __func__,
348 cfg_cie.block_len, p_cap->block_len);
349 LOG_VERBOSE(LOG_TAG, "%s: SUB_BAND peer: 0x%x, capability 0x%x", __func__,
350 cfg_cie.num_subbands, p_cap->num_subbands);
351 LOG_VERBOSE(LOG_TAG, "%s: ALLOC_METHOD peer: 0x%x, capability 0x%x", __func__,
352 cfg_cie.alloc_method, p_cap->alloc_method);
353 LOG_VERBOSE(LOG_TAG, "%s: MIN_BitPool peer: 0x%x, capability 0x%x", __func__,
354 cfg_cie.min_bitpool, p_cap->min_bitpool);
355 LOG_VERBOSE(LOG_TAG, "%s: MAX_BitPool peer: 0x%x, capability 0x%x", __func__,
356 cfg_cie.max_bitpool, p_cap->max_bitpool);
357
358 /* sampling frequency */
359 if ((cfg_cie.samp_freq & p_cap->samp_freq) == 0) return A2DP_NS_SAMP_FREQ;
360
361 /* channel mode */
362 if ((cfg_cie.ch_mode & p_cap->ch_mode) == 0) return A2DP_NS_CH_MODE;
363
364 /* block length */
365 if ((cfg_cie.block_len & p_cap->block_len) == 0) return A2DP_BAD_BLOCK_LEN;
366
367 /* subbands */
368 if ((cfg_cie.num_subbands & p_cap->num_subbands) == 0)
369 return A2DP_NS_SUBBANDS;
370
371 /* allocation method */
372 if ((cfg_cie.alloc_method & p_cap->alloc_method) == 0)
373 return A2DP_NS_ALLOC_METHOD;
374
375 /* min bitpool */
376 if (cfg_cie.min_bitpool > p_cap->max_bitpool) return A2DP_NS_MIN_BITPOOL;
377
378 /* max bitpool */
379 if (cfg_cie.max_bitpool < p_cap->min_bitpool) return A2DP_NS_MAX_BITPOOL;
380
381 return A2DP_SUCCESS;
382 }
383
A2DP_CodecTypeEqualsSbc(const uint8_t * p_codec_info_a,const uint8_t * p_codec_info_b)384 bool A2DP_CodecTypeEqualsSbc(const uint8_t* p_codec_info_a,
385 const uint8_t* p_codec_info_b) {
386 tA2DP_SBC_CIE sbc_cie_a;
387 tA2DP_SBC_CIE sbc_cie_b;
388
389 // Check whether the codec info contains valid data
390 tA2DP_STATUS a2dp_status =
391 A2DP_ParseInfoSbc(&sbc_cie_a, p_codec_info_a, true);
392 if (a2dp_status != A2DP_SUCCESS) {
393 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
394 a2dp_status);
395 return false;
396 }
397 a2dp_status = A2DP_ParseInfoSbc(&sbc_cie_b, p_codec_info_b, true);
398 if (a2dp_status != A2DP_SUCCESS) {
399 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
400 a2dp_status);
401 return false;
402 }
403
404 tA2DP_CODEC_TYPE codec_type_a = A2DP_GetCodecType(p_codec_info_a);
405 tA2DP_CODEC_TYPE codec_type_b = A2DP_GetCodecType(p_codec_info_b);
406
407 return (codec_type_a == codec_type_b) && (codec_type_a == A2DP_MEDIA_CT_SBC);
408 }
409
A2DP_CodecEqualsSbc(const uint8_t * p_codec_info_a,const uint8_t * p_codec_info_b)410 bool A2DP_CodecEqualsSbc(const uint8_t* p_codec_info_a,
411 const uint8_t* p_codec_info_b) {
412 tA2DP_SBC_CIE sbc_cie_a;
413 tA2DP_SBC_CIE sbc_cie_b;
414
415 // Check whether the codec info contains valid data
416 tA2DP_STATUS a2dp_status =
417 A2DP_ParseInfoSbc(&sbc_cie_a, p_codec_info_a, true);
418 if (a2dp_status != A2DP_SUCCESS) {
419 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
420 a2dp_status);
421 return false;
422 }
423 a2dp_status = A2DP_ParseInfoSbc(&sbc_cie_b, p_codec_info_b, true);
424 if (a2dp_status != A2DP_SUCCESS) {
425 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
426 a2dp_status);
427 return false;
428 }
429
430 tA2DP_CODEC_TYPE codec_type_a = A2DP_GetCodecType(p_codec_info_a);
431 tA2DP_CODEC_TYPE codec_type_b = A2DP_GetCodecType(p_codec_info_b);
432
433 if ((codec_type_a != codec_type_b) || (codec_type_a != A2DP_MEDIA_CT_SBC))
434 return false;
435
436 return (sbc_cie_a.samp_freq == sbc_cie_b.samp_freq) &&
437 (sbc_cie_a.ch_mode == sbc_cie_b.ch_mode) &&
438 (sbc_cie_a.block_len == sbc_cie_b.block_len) &&
439 (sbc_cie_a.num_subbands == sbc_cie_b.num_subbands) &&
440 (sbc_cie_a.alloc_method == sbc_cie_b.alloc_method) &&
441 (sbc_cie_a.min_bitpool == sbc_cie_b.min_bitpool) &&
442 (sbc_cie_a.max_bitpool == sbc_cie_b.max_bitpool);
443 }
444
A2DP_GetTrackSampleRateSbc(const uint8_t * p_codec_info)445 int A2DP_GetTrackSampleRateSbc(const uint8_t* p_codec_info) {
446 tA2DP_SBC_CIE sbc_cie;
447
448 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
449 if (a2dp_status != A2DP_SUCCESS) {
450 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
451 a2dp_status);
452 return -1;
453 }
454
455 switch (sbc_cie.samp_freq) {
456 case A2DP_SBC_IE_SAMP_FREQ_16:
457 return 16000;
458 case A2DP_SBC_IE_SAMP_FREQ_32:
459 return 32000;
460 case A2DP_SBC_IE_SAMP_FREQ_44:
461 return 44100;
462 case A2DP_SBC_IE_SAMP_FREQ_48:
463 return 48000;
464 default:
465 break;
466 }
467
468 return -1;
469 }
470
A2DP_GetTrackChannelCountSbc(const uint8_t * p_codec_info)471 int A2DP_GetTrackChannelCountSbc(const uint8_t* p_codec_info) {
472 tA2DP_SBC_CIE sbc_cie;
473
474 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
475 if (a2dp_status != A2DP_SUCCESS) {
476 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
477 a2dp_status);
478 return -1;
479 }
480
481 switch (sbc_cie.ch_mode) {
482 case A2DP_SBC_IE_CH_MD_MONO:
483 return 1;
484 case A2DP_SBC_IE_CH_MD_DUAL:
485 case A2DP_SBC_IE_CH_MD_STEREO:
486 case A2DP_SBC_IE_CH_MD_JOINT:
487 return 2;
488 default:
489 break;
490 }
491
492 return -1;
493 }
494
A2DP_GetNumberOfSubbandsSbc(const uint8_t * p_codec_info)495 int A2DP_GetNumberOfSubbandsSbc(const uint8_t* p_codec_info) {
496 tA2DP_SBC_CIE sbc_cie;
497
498 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
499 if (a2dp_status != A2DP_SUCCESS) {
500 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
501 a2dp_status);
502 return -1;
503 }
504
505 switch (sbc_cie.num_subbands) {
506 case A2DP_SBC_IE_SUBBAND_4:
507 return 4;
508 case A2DP_SBC_IE_SUBBAND_8:
509 return 8;
510 default:
511 break;
512 }
513
514 return -1;
515 }
516
A2DP_GetNumberOfBlocksSbc(const uint8_t * p_codec_info)517 int A2DP_GetNumberOfBlocksSbc(const uint8_t* p_codec_info) {
518 tA2DP_SBC_CIE sbc_cie;
519
520 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
521 if (a2dp_status != A2DP_SUCCESS) {
522 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
523 a2dp_status);
524 return -1;
525 }
526
527 switch (sbc_cie.block_len) {
528 case A2DP_SBC_IE_BLOCKS_4:
529 return 4;
530 case A2DP_SBC_IE_BLOCKS_8:
531 return 8;
532 case A2DP_SBC_IE_BLOCKS_12:
533 return 12;
534 case A2DP_SBC_IE_BLOCKS_16:
535 return 16;
536 default:
537 break;
538 }
539
540 return -1;
541 }
542
A2DP_GetAllocationMethodCodeSbc(const uint8_t * p_codec_info)543 int A2DP_GetAllocationMethodCodeSbc(const uint8_t* p_codec_info) {
544 tA2DP_SBC_CIE sbc_cie;
545
546 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
547 if (a2dp_status != A2DP_SUCCESS) {
548 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
549 a2dp_status);
550 return -1;
551 }
552
553 switch (sbc_cie.alloc_method) {
554 case A2DP_SBC_IE_ALLOC_MD_S:
555 return SBC_SNR;
556 case A2DP_SBC_IE_ALLOC_MD_L:
557 return SBC_LOUDNESS;
558 default:
559 break;
560 }
561
562 return -1;
563 }
564
A2DP_GetChannelModeCodeSbc(const uint8_t * p_codec_info)565 int A2DP_GetChannelModeCodeSbc(const uint8_t* p_codec_info) {
566 tA2DP_SBC_CIE sbc_cie;
567
568 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
569 if (a2dp_status != A2DP_SUCCESS) {
570 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
571 a2dp_status);
572 return -1;
573 }
574
575 switch (sbc_cie.ch_mode) {
576 case A2DP_SBC_IE_CH_MD_MONO:
577 return SBC_MONO;
578 case A2DP_SBC_IE_CH_MD_DUAL:
579 return SBC_DUAL;
580 case A2DP_SBC_IE_CH_MD_STEREO:
581 return SBC_STEREO;
582 case A2DP_SBC_IE_CH_MD_JOINT:
583 return SBC_JOINT_STEREO;
584 default:
585 break;
586 }
587
588 return -1;
589 }
590
A2DP_GetSamplingFrequencyCodeSbc(const uint8_t * p_codec_info)591 int A2DP_GetSamplingFrequencyCodeSbc(const uint8_t* p_codec_info) {
592 tA2DP_SBC_CIE sbc_cie;
593
594 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
595 if (a2dp_status != A2DP_SUCCESS) {
596 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
597 a2dp_status);
598 return -1;
599 }
600
601 switch (sbc_cie.samp_freq) {
602 case A2DP_SBC_IE_SAMP_FREQ_16:
603 return SBC_sf16000;
604 case A2DP_SBC_IE_SAMP_FREQ_32:
605 return SBC_sf32000;
606 case A2DP_SBC_IE_SAMP_FREQ_44:
607 return SBC_sf44100;
608 case A2DP_SBC_IE_SAMP_FREQ_48:
609 return SBC_sf48000;
610 default:
611 break;
612 }
613
614 return -1;
615 }
616
A2DP_GetMinBitpoolSbc(const uint8_t * p_codec_info)617 int A2DP_GetMinBitpoolSbc(const uint8_t* p_codec_info) {
618 tA2DP_SBC_CIE sbc_cie;
619
620 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, true);
621 if (a2dp_status != A2DP_SUCCESS) {
622 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
623 a2dp_status);
624 return -1;
625 }
626
627 return sbc_cie.min_bitpool;
628 }
629
A2DP_GetMaxBitpoolSbc(const uint8_t * p_codec_info)630 int A2DP_GetMaxBitpoolSbc(const uint8_t* p_codec_info) {
631 tA2DP_SBC_CIE sbc_cie;
632
633 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, true);
634 if (a2dp_status != A2DP_SUCCESS) {
635 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
636 a2dp_status);
637 return -1;
638 }
639
640 return sbc_cie.max_bitpool;
641 }
642
A2DP_GetBitrateSbc()643 uint32_t A2DP_GetBitrateSbc() { return a2dp_sbc_get_bitrate(); }
A2DP_GetSinkTrackChannelTypeSbc(const uint8_t * p_codec_info)644 int A2DP_GetSinkTrackChannelTypeSbc(const uint8_t* p_codec_info) {
645 tA2DP_SBC_CIE sbc_cie;
646
647 tA2DP_STATUS a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, false);
648 if (a2dp_status != A2DP_SUCCESS) {
649 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__,
650 a2dp_status);
651 return -1;
652 }
653
654 switch (sbc_cie.ch_mode) {
655 case A2DP_SBC_IE_CH_MD_MONO:
656 return 1;
657 case A2DP_SBC_IE_CH_MD_DUAL:
658 case A2DP_SBC_IE_CH_MD_STEREO:
659 case A2DP_SBC_IE_CH_MD_JOINT:
660 return 3;
661 default:
662 break;
663 }
664
665 return -1;
666 }
667
A2DP_GetPacketTimestampSbc(UNUSED_ATTR const uint8_t * p_codec_info,const uint8_t * p_data,uint32_t * p_timestamp)668 bool A2DP_GetPacketTimestampSbc(UNUSED_ATTR const uint8_t* p_codec_info,
669 const uint8_t* p_data, uint32_t* p_timestamp) {
670 *p_timestamp = *(const uint32_t*)p_data;
671 return true;
672 }
673
A2DP_BuildCodecHeaderSbc(UNUSED_ATTR const uint8_t * p_codec_info,BT_HDR * p_buf,uint16_t frames_per_packet)674 bool A2DP_BuildCodecHeaderSbc(UNUSED_ATTR const uint8_t* p_codec_info,
675 BT_HDR* p_buf, uint16_t frames_per_packet) {
676 uint8_t* p;
677
678 p_buf->offset -= A2DP_SBC_MPL_HDR_LEN;
679 p = (uint8_t*)(p_buf + 1) + p_buf->offset;
680 p_buf->len += A2DP_SBC_MPL_HDR_LEN;
681 A2DP_BuildMediaPayloadHeaderSbc(p, false, false, false,
682 (uint8_t)frames_per_packet);
683
684 return true;
685 }
686
A2DP_CodecInfoStringSbc(const uint8_t * p_codec_info)687 std::string A2DP_CodecInfoStringSbc(const uint8_t* p_codec_info) {
688 std::stringstream res;
689 std::string field;
690 tA2DP_STATUS a2dp_status;
691 tA2DP_SBC_CIE sbc_cie;
692
693 a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, true);
694 if (a2dp_status != A2DP_SUCCESS) {
695 res << "A2DP_ParseInfoSbc fail: " << loghex(a2dp_status);
696 return res.str();
697 }
698
699 res << "\tname: SBC\n";
700
701 // Sample frequency
702 field.clear();
703 AppendField(&field, (sbc_cie.samp_freq == 0), "NONE");
704 AppendField(&field, (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_16), "16000");
705 AppendField(&field, (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_32), "32000");
706 AppendField(&field, (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_44), "44100");
707 AppendField(&field, (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_48), "48000");
708 res << "\tsamp_freq: " << field << " (" << loghex(sbc_cie.samp_freq) << ")\n";
709
710 // Channel mode
711 field.clear();
712 AppendField(&field, (sbc_cie.ch_mode == 0), "NONE");
713 AppendField(&field, (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_MONO), "Mono");
714 AppendField(&field, (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_DUAL), "Dual");
715 AppendField(&field, (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_STEREO), "Stereo");
716 AppendField(&field, (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_JOINT), "Joint");
717 res << "\tch_mode: " << field << " (" << loghex(sbc_cie.ch_mode) << ")\n";
718
719 // Block length
720 field.clear();
721 AppendField(&field, (sbc_cie.block_len == 0), "NONE");
722 AppendField(&field, (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_4), "4");
723 AppendField(&field, (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_8), "8");
724 AppendField(&field, (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_12), "12");
725 AppendField(&field, (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_16), "16");
726 res << "\tblock_len: " << field << " (" << loghex(sbc_cie.block_len) << ")\n";
727
728 // Number of subbands
729 field.clear();
730 AppendField(&field, (sbc_cie.num_subbands == 0), "NONE");
731 AppendField(&field, (sbc_cie.num_subbands & A2DP_SBC_IE_SUBBAND_4), "4");
732 AppendField(&field, (sbc_cie.num_subbands & A2DP_SBC_IE_SUBBAND_8), "8");
733 res << "\tnum_subbands: " << field << " (" << loghex(sbc_cie.num_subbands)
734 << ")\n";
735
736 // Allocation method
737 field.clear();
738 AppendField(&field, (sbc_cie.alloc_method == 0), "NONE");
739 AppendField(&field, (sbc_cie.alloc_method & A2DP_SBC_IE_ALLOC_MD_S), "SNR");
740 AppendField(&field, (sbc_cie.alloc_method & A2DP_SBC_IE_ALLOC_MD_L),
741 "Loundess");
742 res << "\talloc_method: " << field << " (" << loghex(sbc_cie.alloc_method)
743 << ")\n";
744
745 // Min/max bitloop
746 res << "\tBit pool Min: " << std::to_string(sbc_cie.min_bitpool)
747 << " Max: " << std::to_string(sbc_cie.max_bitpool);
748
749 return res.str();
750 }
751
A2DP_GetEncoderInterfaceSbc(const uint8_t * p_codec_info)752 const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterfaceSbc(
753 const uint8_t* p_codec_info) {
754 if (!A2DP_IsSourceCodecValidSbc(p_codec_info)) return NULL;
755
756 return &a2dp_encoder_interface_sbc;
757 }
758
A2DP_GetDecoderInterfaceSbc(const uint8_t * p_codec_info)759 const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterfaceSbc(
760 const uint8_t* p_codec_info) {
761 if (!A2DP_IsSinkCodecValidSbc(p_codec_info)) return NULL;
762
763 return &a2dp_decoder_interface_sbc;
764 }
765
A2DP_AdjustCodecSbc(uint8_t * p_codec_info)766 bool A2DP_AdjustCodecSbc(uint8_t* p_codec_info) {
767 tA2DP_SBC_CIE cfg_cie;
768
769 if (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) != A2DP_SUCCESS)
770 return false;
771
772 // Updated the max bitpool
773 if (cfg_cie.max_bitpool > A2DP_SBC_MAX_BITPOOL) {
774 LOG_WARN(LOG_TAG, "%s: Updated the SBC codec max bitpool from %d to %d",
775 __func__, cfg_cie.max_bitpool, A2DP_SBC_MAX_BITPOOL);
776 cfg_cie.max_bitpool = A2DP_SBC_MAX_BITPOOL;
777 }
778
779 return (A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &cfg_cie, p_codec_info) ==
780 A2DP_SUCCESS);
781 }
782
A2DP_SourceCodecIndexSbc(UNUSED_ATTR const uint8_t * p_codec_info)783 btav_a2dp_codec_index_t A2DP_SourceCodecIndexSbc(
784 UNUSED_ATTR const uint8_t* p_codec_info) {
785 return BTAV_A2DP_CODEC_INDEX_SOURCE_SBC;
786 }
787
A2DP_SinkCodecIndexSbc(UNUSED_ATTR const uint8_t * p_codec_info)788 btav_a2dp_codec_index_t A2DP_SinkCodecIndexSbc(
789 UNUSED_ATTR const uint8_t* p_codec_info) {
790 return BTAV_A2DP_CODEC_INDEX_SINK_SBC;
791 }
792
A2DP_CodecIndexStrSbc(void)793 const char* A2DP_CodecIndexStrSbc(void) { return "SBC"; }
794
A2DP_CodecIndexStrSbcSink(void)795 const char* A2DP_CodecIndexStrSbcSink(void) { return "SBC SINK"; }
796
A2DP_InitCodecConfigSbc(AvdtpSepConfig * p_cfg)797 bool A2DP_InitCodecConfigSbc(AvdtpSepConfig* p_cfg) {
798 if (A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &a2dp_sbc_source_caps,
799 p_cfg->codec_info) != A2DP_SUCCESS) {
800 return false;
801 }
802
803 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
804 /* Content protection info - support SCMS-T */
805 uint8_t* p = p_cfg->protect_info;
806 *p++ = AVDT_CP_LOSC;
807 UINT16_TO_STREAM(p, AVDT_CP_SCMS_T_ID);
808 p_cfg->num_protect = 1;
809 #endif
810
811 return true;
812 }
813
A2DP_InitCodecConfigSbcSink(AvdtpSepConfig * p_cfg)814 bool A2DP_InitCodecConfigSbcSink(AvdtpSepConfig* p_cfg) {
815 if (A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &a2dp_sbc_sink_caps,
816 p_cfg->codec_info) != A2DP_SUCCESS) {
817 return false;
818 }
819
820 return true;
821 }
822
build_codec_config(const tA2DP_SBC_CIE & config_cie,btav_a2dp_codec_config_t * result)823 UNUSED_ATTR static void build_codec_config(const tA2DP_SBC_CIE& config_cie,
824 btav_a2dp_codec_config_t* result) {
825 if (config_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_44)
826 result->sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
827 if (config_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_48)
828 result->sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
829
830 result->bits_per_sample = config_cie.bits_per_sample;
831
832 if (config_cie.ch_mode & A2DP_SBC_IE_CH_MD_MONO)
833 result->channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
834
835 if (config_cie.ch_mode & (A2DP_SBC_IE_CH_MD_STEREO | A2DP_SBC_IE_CH_MD_JOINT |
836 A2DP_SBC_IE_CH_MD_DUAL)) {
837 result->channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
838 }
839 }
840
A2dpCodecConfigSbcSource(btav_a2dp_codec_priority_t codec_priority)841 A2dpCodecConfigSbcSource::A2dpCodecConfigSbcSource(
842 btav_a2dp_codec_priority_t codec_priority)
843 : A2dpCodecConfigSbcBase(BTAV_A2DP_CODEC_INDEX_SOURCE_SBC, "SBC",
844 codec_priority, true) {
845 // Compute the local capability
846 if (a2dp_sbc_source_caps.samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {
847 codec_local_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
848 }
849 if (a2dp_sbc_source_caps.samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {
850 codec_local_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
851 }
852 codec_local_capability_.bits_per_sample =
853 a2dp_sbc_source_caps.bits_per_sample;
854 if (a2dp_sbc_source_caps.ch_mode & A2DP_SBC_IE_CH_MD_MONO) {
855 codec_local_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
856 }
857 if (a2dp_sbc_source_caps.ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {
858 codec_local_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
859 }
860 if (a2dp_sbc_source_caps.ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {
861 codec_local_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
862 }
863 if (a2dp_sbc_source_caps.ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {
864 codec_local_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
865 }
866 }
867
~A2dpCodecConfigSbcSource()868 A2dpCodecConfigSbcSource::~A2dpCodecConfigSbcSource() {}
869
init()870 bool A2dpCodecConfigSbcSource::init() {
871 if (!isValid()) return false;
872
873 // Load the encoder
874 if (!A2DP_LoadEncoderSbc()) {
875 LOG_ERROR(LOG_TAG, "%s: cannot load the encoder", __func__);
876 return false;
877 }
878
879 return true;
880 }
881
useRtpHeaderMarkerBit() const882 bool A2dpCodecConfigSbcSource::useRtpHeaderMarkerBit() const { return false; }
883
884 //
885 // Selects the best sample rate from |samp_freq|.
886 // The result is stored in |p_result| and |p_codec_config|.
887 // Returns true if a selection was made, otherwise false.
888 //
select_best_sample_rate(uint8_t samp_freq,tA2DP_SBC_CIE * p_result,btav_a2dp_codec_config_t * p_codec_config)889 static bool select_best_sample_rate(uint8_t samp_freq, tA2DP_SBC_CIE* p_result,
890 btav_a2dp_codec_config_t* p_codec_config) {
891 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {
892 p_result->samp_freq = A2DP_SBC_IE_SAMP_FREQ_48;
893 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
894 return true;
895 }
896 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {
897 p_result->samp_freq = A2DP_SBC_IE_SAMP_FREQ_44;
898 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
899 return true;
900 }
901 return false;
902 }
903
904 //
905 // Selects the audio sample rate from |p_codec_audio_config|.
906 // |samp_freq| contains the capability.
907 // The result is stored in |p_result| and |p_codec_config|.
908 // Returns true if a selection was made, otherwise false.
909 //
select_audio_sample_rate(const btav_a2dp_codec_config_t * p_codec_audio_config,uint8_t samp_freq,tA2DP_SBC_CIE * p_result,btav_a2dp_codec_config_t * p_codec_config)910 static bool select_audio_sample_rate(
911 const btav_a2dp_codec_config_t* p_codec_audio_config, uint8_t samp_freq,
912 tA2DP_SBC_CIE* p_result, btav_a2dp_codec_config_t* p_codec_config) {
913 switch (p_codec_audio_config->sample_rate) {
914 case BTAV_A2DP_CODEC_SAMPLE_RATE_44100:
915 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {
916 p_result->samp_freq = A2DP_SBC_IE_SAMP_FREQ_44;
917 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
918 return true;
919 }
920 break;
921 case BTAV_A2DP_CODEC_SAMPLE_RATE_48000:
922 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {
923 p_result->samp_freq = A2DP_SBC_IE_SAMP_FREQ_48;
924 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
925 return true;
926 }
927 break;
928 case BTAV_A2DP_CODEC_SAMPLE_RATE_88200:
929 case BTAV_A2DP_CODEC_SAMPLE_RATE_96000:
930 case BTAV_A2DP_CODEC_SAMPLE_RATE_176400:
931 case BTAV_A2DP_CODEC_SAMPLE_RATE_192000:
932 case BTAV_A2DP_CODEC_SAMPLE_RATE_16000:
933 case BTAV_A2DP_CODEC_SAMPLE_RATE_24000:
934 case BTAV_A2DP_CODEC_SAMPLE_RATE_NONE:
935 break;
936 }
937
938 return false;
939 }
940
941 //
942 // Selects the best bits per sample.
943 // The result is stored in |p_codec_config|.
944 // Returns true if a selection was made, otherwise false.
945 //
select_best_bits_per_sample(btav_a2dp_codec_config_t * p_codec_config)946 static bool select_best_bits_per_sample(
947 btav_a2dp_codec_config_t* p_codec_config) {
948 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16;
949 return true;
950 }
951
952 //
953 // Selects the audio bits per sample from |p_codec_audio_config|.
954 // The result is stored in |p_codec_config|.
955 // Returns true if a selection was made, otherwise false.
956 //
select_audio_bits_per_sample(const btav_a2dp_codec_config_t * p_codec_audio_config,btav_a2dp_codec_config_t * p_codec_config)957 static bool select_audio_bits_per_sample(
958 const btav_a2dp_codec_config_t* p_codec_audio_config,
959 btav_a2dp_codec_config_t* p_codec_config) {
960 switch (p_codec_audio_config->bits_per_sample) {
961 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16:
962 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16;
963 return true;
964 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24:
965 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32:
966 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE:
967 break;
968 }
969 return false;
970 }
971
972 //
973 // Selects the best channel mode from |ch_mode|.
974 // The result is stored in |p_result| and |p_codec_config|.
975 // Returns true if a selection was made, otherwise false.
976 //
select_best_channel_mode(uint8_t ch_mode,tA2DP_SBC_CIE * p_result,btav_a2dp_codec_config_t * p_codec_config)977 static bool select_best_channel_mode(uint8_t ch_mode, tA2DP_SBC_CIE* p_result,
978 btav_a2dp_codec_config_t* p_codec_config) {
979 if (ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {
980 p_result->ch_mode = A2DP_SBC_IE_CH_MD_JOINT;
981 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
982 return true;
983 }
984 if (ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {
985 p_result->ch_mode = A2DP_SBC_IE_CH_MD_STEREO;
986 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
987 return true;
988 }
989 if (ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {
990 p_result->ch_mode = A2DP_SBC_IE_CH_MD_DUAL;
991 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
992 return true;
993 }
994 if (ch_mode & A2DP_SBC_IE_CH_MD_MONO) {
995 p_result->ch_mode = A2DP_SBC_IE_CH_MD_MONO;
996 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
997 return true;
998 }
999 return false;
1000 }
1001
1002 //
1003 // Selects the audio channel mode from |p_codec_audio_config|.
1004 // |ch_mode| contains the capability.
1005 // The result is stored in |p_result| and |p_codec_config|.
1006 // Returns true if a selection was made, otherwise false.
1007 //
select_audio_channel_mode(const btav_a2dp_codec_config_t * p_codec_audio_config,uint8_t ch_mode,tA2DP_SBC_CIE * p_result,btav_a2dp_codec_config_t * p_codec_config)1008 static bool select_audio_channel_mode(
1009 const btav_a2dp_codec_config_t* p_codec_audio_config, uint8_t ch_mode,
1010 tA2DP_SBC_CIE* p_result, btav_a2dp_codec_config_t* p_codec_config) {
1011 switch (p_codec_audio_config->channel_mode) {
1012 case BTAV_A2DP_CODEC_CHANNEL_MODE_MONO:
1013 if (ch_mode & A2DP_SBC_IE_CH_MD_MONO) {
1014 p_result->ch_mode = A2DP_SBC_IE_CH_MD_MONO;
1015 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
1016 return true;
1017 }
1018 break;
1019 case BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO:
1020 if (ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {
1021 p_result->ch_mode = A2DP_SBC_IE_CH_MD_JOINT;
1022 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1023 return true;
1024 }
1025 if (ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {
1026 p_result->ch_mode = A2DP_SBC_IE_CH_MD_STEREO;
1027 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1028 return true;
1029 }
1030 if (ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {
1031 p_result->ch_mode = A2DP_SBC_IE_CH_MD_DUAL;
1032 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1033 return true;
1034 }
1035 break;
1036 case BTAV_A2DP_CODEC_CHANNEL_MODE_NONE:
1037 break;
1038 }
1039
1040 return false;
1041 }
1042
setCodecConfig(const uint8_t * p_peer_codec_info,bool is_capability,uint8_t * p_result_codec_config)1043 bool A2dpCodecConfigSbcBase::setCodecConfig(const uint8_t* p_peer_codec_info,
1044 bool is_capability,
1045 uint8_t* p_result_codec_config) {
1046 std::lock_guard<std::recursive_mutex> lock(codec_mutex_);
1047 tA2DP_SBC_CIE peer_info_cie;
1048 tA2DP_SBC_CIE result_config_cie;
1049 uint8_t samp_freq;
1050 uint8_t ch_mode;
1051 uint8_t block_len;
1052 uint8_t num_subbands;
1053 uint8_t alloc_method;
1054 const tA2DP_SBC_CIE* p_a2dp_sbc_caps =
1055 (is_source_) ? &a2dp_sbc_source_caps : &a2dp_sbc_sink_caps;
1056
1057 // Save the internal state
1058 btav_a2dp_codec_config_t saved_codec_config = codec_config_;
1059 btav_a2dp_codec_config_t saved_codec_capability = codec_capability_;
1060 btav_a2dp_codec_config_t saved_codec_selectable_capability =
1061 codec_selectable_capability_;
1062 btav_a2dp_codec_config_t saved_codec_user_config = codec_user_config_;
1063 btav_a2dp_codec_config_t saved_codec_audio_config = codec_audio_config_;
1064 uint8_t saved_ota_codec_config[AVDT_CODEC_SIZE];
1065 uint8_t saved_ota_codec_peer_capability[AVDT_CODEC_SIZE];
1066 uint8_t saved_ota_codec_peer_config[AVDT_CODEC_SIZE];
1067 memcpy(saved_ota_codec_config, ota_codec_config_, sizeof(ota_codec_config_));
1068 memcpy(saved_ota_codec_peer_capability, ota_codec_peer_capability_,
1069 sizeof(ota_codec_peer_capability_));
1070 memcpy(saved_ota_codec_peer_config, ota_codec_peer_config_,
1071 sizeof(ota_codec_peer_config_));
1072
1073 tA2DP_STATUS status =
1074 A2DP_ParseInfoSbc(&peer_info_cie, p_peer_codec_info, is_capability);
1075 if (status != A2DP_SUCCESS) {
1076 LOG_ERROR(LOG_TAG, "%s: can't parse peer's capabilities: error = %d",
1077 __func__, status);
1078 goto fail;
1079 }
1080 // Try using the prefered peer codec config (if valid), instead of the peer
1081 // capability.
1082 if (is_capability) {
1083 if (is_source_) {
1084 if (A2DP_IsPeerSinkCodecValidSbc(ota_codec_peer_config_)) {
1085 status =
1086 A2DP_ParseInfoSbc(&peer_info_cie, ota_codec_peer_config_, false);
1087 }
1088 } else {
1089 if (A2DP_IsPeerSourceCodecValidSbc(ota_codec_peer_config_)) {
1090 status =
1091 A2DP_ParseInfoSbc(&peer_info_cie, ota_codec_peer_config_, false);
1092 }
1093 }
1094 if (status != A2DP_SUCCESS) {
1095 // Use the peer codec capability
1096 status =
1097 A2DP_ParseInfoSbc(&peer_info_cie, p_peer_codec_info, is_capability);
1098 CHECK(status == A2DP_SUCCESS);
1099 }
1100 }
1101
1102 //
1103 // Build the preferred configuration
1104 //
1105 memset(&result_config_cie, 0, sizeof(result_config_cie));
1106
1107 //
1108 // Select the sample frequency
1109 //
1110 samp_freq = p_a2dp_sbc_caps->samp_freq & peer_info_cie.samp_freq;
1111 codec_config_.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE;
1112 switch (codec_user_config_.sample_rate) {
1113 case BTAV_A2DP_CODEC_SAMPLE_RATE_44100:
1114 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {
1115 result_config_cie.samp_freq = A2DP_SBC_IE_SAMP_FREQ_44;
1116 codec_capability_.sample_rate = codec_user_config_.sample_rate;
1117 codec_config_.sample_rate = codec_user_config_.sample_rate;
1118 }
1119 break;
1120 case BTAV_A2DP_CODEC_SAMPLE_RATE_48000:
1121 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {
1122 result_config_cie.samp_freq = A2DP_SBC_IE_SAMP_FREQ_48;
1123 codec_capability_.sample_rate = codec_user_config_.sample_rate;
1124 codec_config_.sample_rate = codec_user_config_.sample_rate;
1125 }
1126 break;
1127 case BTAV_A2DP_CODEC_SAMPLE_RATE_88200:
1128 case BTAV_A2DP_CODEC_SAMPLE_RATE_96000:
1129 case BTAV_A2DP_CODEC_SAMPLE_RATE_176400:
1130 case BTAV_A2DP_CODEC_SAMPLE_RATE_192000:
1131 case BTAV_A2DP_CODEC_SAMPLE_RATE_16000:
1132 case BTAV_A2DP_CODEC_SAMPLE_RATE_24000:
1133 case BTAV_A2DP_CODEC_SAMPLE_RATE_NONE:
1134 codec_capability_.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE;
1135 codec_config_.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE;
1136 break;
1137 }
1138
1139 // Select the sample frequency if there is no user preference
1140 do {
1141 // Compute the selectable capability
1142 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {
1143 codec_selectable_capability_.sample_rate |=
1144 BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
1145 }
1146 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {
1147 codec_selectable_capability_.sample_rate |=
1148 BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
1149 }
1150
1151 if (codec_config_.sample_rate != BTAV_A2DP_CODEC_SAMPLE_RATE_NONE) break;
1152
1153 // Compute the common capability
1154 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_44)
1155 codec_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
1156 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_48)
1157 codec_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
1158
1159 // No user preference - try the codec audio config
1160 if (select_audio_sample_rate(&codec_audio_config_, samp_freq,
1161 &result_config_cie, &codec_config_)) {
1162 break;
1163 }
1164
1165 // No user preference - try the default config
1166 if (select_best_sample_rate(
1167 a2dp_sbc_default_config.samp_freq & peer_info_cie.samp_freq,
1168 &result_config_cie, &codec_config_)) {
1169 break;
1170 }
1171
1172 // No user preference - use the best match
1173 if (select_best_sample_rate(samp_freq, &result_config_cie,
1174 &codec_config_)) {
1175 break;
1176 }
1177 } while (false);
1178 if (codec_config_.sample_rate == BTAV_A2DP_CODEC_SAMPLE_RATE_NONE) {
1179 LOG_ERROR(LOG_TAG,
1180 "%s: cannot match sample frequency: local caps = 0x%x "
1181 "peer info = 0x%x",
1182 __func__, p_a2dp_sbc_caps->samp_freq, peer_info_cie.samp_freq);
1183 goto fail;
1184 }
1185
1186 //
1187 // Select the bits per sample
1188 //
1189 // NOTE: this information is NOT included in the SBC A2DP codec description
1190 // that is sent OTA.
1191 codec_config_.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE;
1192 switch (codec_user_config_.bits_per_sample) {
1193 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16:
1194 codec_capability_.bits_per_sample = codec_user_config_.bits_per_sample;
1195 codec_config_.bits_per_sample = codec_user_config_.bits_per_sample;
1196 break;
1197 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24:
1198 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32:
1199 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE:
1200 codec_capability_.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE;
1201 codec_config_.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE;
1202 break;
1203 }
1204
1205 // Select the bits per sample if there is no user preference
1206 do {
1207 // Compute the selectable capability
1208 codec_selectable_capability_.bits_per_sample =
1209 p_a2dp_sbc_caps->bits_per_sample;
1210
1211 if (codec_config_.bits_per_sample != BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE)
1212 break;
1213
1214 // Compute the common capability
1215 codec_capability_.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16;
1216
1217 // No user preference - try the codec audio config
1218 if (select_audio_bits_per_sample(&codec_audio_config_, &codec_config_)) {
1219 break;
1220 }
1221
1222 // No user preference - try the default config
1223 if (select_best_bits_per_sample(&codec_config_)) {
1224 break;
1225 }
1226
1227 // No user preference - use the best match
1228 // TODO: no-op - temporary kept here for consistency
1229 if (select_best_bits_per_sample(&codec_config_)) {
1230 break;
1231 }
1232 } while (false);
1233 if (codec_config_.bits_per_sample == BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE) {
1234 LOG_ERROR(LOG_TAG,
1235 "%s: cannot match bits per sample: user preference = 0x%x",
1236 __func__, codec_user_config_.bits_per_sample);
1237 goto fail;
1238 }
1239
1240 //
1241 // Select the channel mode
1242 //
1243 ch_mode = p_a2dp_sbc_caps->ch_mode & peer_info_cie.ch_mode;
1244 codec_config_.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE;
1245 switch (codec_user_config_.channel_mode) {
1246 case BTAV_A2DP_CODEC_CHANNEL_MODE_MONO:
1247 if (ch_mode & A2DP_SBC_IE_CH_MD_MONO) {
1248 result_config_cie.ch_mode = A2DP_SBC_IE_CH_MD_MONO;
1249 codec_capability_.channel_mode = codec_user_config_.channel_mode;
1250 codec_config_.channel_mode = codec_user_config_.channel_mode;
1251 }
1252 break;
1253 case BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO:
1254 if (ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {
1255 result_config_cie.ch_mode = A2DP_SBC_IE_CH_MD_JOINT;
1256 codec_capability_.channel_mode = codec_user_config_.channel_mode;
1257 codec_config_.channel_mode = codec_user_config_.channel_mode;
1258 break;
1259 }
1260 if (ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {
1261 result_config_cie.ch_mode = A2DP_SBC_IE_CH_MD_STEREO;
1262 codec_capability_.channel_mode = codec_user_config_.channel_mode;
1263 codec_config_.channel_mode = codec_user_config_.channel_mode;
1264 break;
1265 }
1266 if (ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {
1267 result_config_cie.ch_mode = A2DP_SBC_IE_CH_MD_DUAL;
1268 codec_capability_.channel_mode = codec_user_config_.channel_mode;
1269 codec_config_.channel_mode = codec_user_config_.channel_mode;
1270 break;
1271 }
1272 break;
1273 case BTAV_A2DP_CODEC_CHANNEL_MODE_NONE:
1274 codec_capability_.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE;
1275 codec_config_.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE;
1276 break;
1277 }
1278
1279 // Select the channel mode if there is no user preference
1280 do {
1281 // Compute the selectable capability
1282 if (ch_mode & A2DP_SBC_IE_CH_MD_MONO) {
1283 codec_selectable_capability_.channel_mode |=
1284 BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
1285 }
1286 if (ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {
1287 codec_selectable_capability_.channel_mode |=
1288 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1289 }
1290 if (ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {
1291 codec_selectable_capability_.channel_mode |=
1292 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1293 }
1294 if (ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {
1295 codec_selectable_capability_.channel_mode |=
1296 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1297 }
1298
1299 if (codec_config_.channel_mode != BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) break;
1300
1301 // Compute the common capability
1302 if (ch_mode & A2DP_SBC_IE_CH_MD_MONO)
1303 codec_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
1304 if (ch_mode & (A2DP_SBC_IE_CH_MD_JOINT | A2DP_SBC_IE_CH_MD_STEREO |
1305 A2DP_SBC_IE_CH_MD_DUAL)) {
1306 codec_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1307 }
1308
1309 // No user preference - use the codec audio config
1310 if (select_audio_channel_mode(&codec_audio_config_, ch_mode,
1311 &result_config_cie, &codec_config_)) {
1312 break;
1313 }
1314
1315 // No user preference - try the default config
1316 if (select_best_channel_mode(
1317 a2dp_sbc_default_config.ch_mode & peer_info_cie.ch_mode,
1318 &result_config_cie, &codec_config_)) {
1319 break;
1320 }
1321
1322 // No user preference - use the best match
1323 if (select_best_channel_mode(ch_mode, &result_config_cie, &codec_config_)) {
1324 break;
1325 }
1326 } while (false);
1327 if (codec_config_.channel_mode == BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) {
1328 LOG_ERROR(LOG_TAG,
1329 "%s: cannot match channel mode: local caps = 0x%x "
1330 "peer info = 0x%x",
1331 __func__, p_a2dp_sbc_caps->ch_mode, peer_info_cie.ch_mode);
1332 goto fail;
1333 }
1334
1335 //
1336 // Select the block length
1337 //
1338 block_len = p_a2dp_sbc_caps->block_len & peer_info_cie.block_len;
1339 if (block_len & A2DP_SBC_IE_BLOCKS_16) {
1340 result_config_cie.block_len = A2DP_SBC_IE_BLOCKS_16;
1341 } else if (block_len & A2DP_SBC_IE_BLOCKS_12) {
1342 result_config_cie.block_len = A2DP_SBC_IE_BLOCKS_12;
1343 } else if (block_len & A2DP_SBC_IE_BLOCKS_8) {
1344 result_config_cie.block_len = A2DP_SBC_IE_BLOCKS_8;
1345 } else if (block_len & A2DP_SBC_IE_BLOCKS_4) {
1346 result_config_cie.block_len = A2DP_SBC_IE_BLOCKS_4;
1347 } else {
1348 LOG_ERROR(LOG_TAG,
1349 "%s: cannot match block length: local caps = 0x%x "
1350 "peer info = 0x%x",
1351 __func__, p_a2dp_sbc_caps->block_len, peer_info_cie.block_len);
1352 goto fail;
1353 }
1354
1355 //
1356 // Select the number of sub-bands
1357 //
1358 num_subbands = p_a2dp_sbc_caps->num_subbands & peer_info_cie.num_subbands;
1359 if (num_subbands & A2DP_SBC_IE_SUBBAND_8) {
1360 result_config_cie.num_subbands = A2DP_SBC_IE_SUBBAND_8;
1361 } else if (num_subbands & A2DP_SBC_IE_SUBBAND_4) {
1362 result_config_cie.num_subbands = A2DP_SBC_IE_SUBBAND_4;
1363 } else {
1364 LOG_ERROR(LOG_TAG,
1365 "%s: cannot match number of sub-bands: local caps = 0x%x "
1366 "peer info = 0x%x",
1367 __func__, p_a2dp_sbc_caps->num_subbands,
1368 peer_info_cie.num_subbands);
1369 goto fail;
1370 }
1371
1372 //
1373 // Select the allocation method
1374 //
1375 alloc_method = p_a2dp_sbc_caps->alloc_method & peer_info_cie.alloc_method;
1376 if (alloc_method & A2DP_SBC_IE_ALLOC_MD_L) {
1377 result_config_cie.alloc_method = A2DP_SBC_IE_ALLOC_MD_L;
1378 } else if (alloc_method & A2DP_SBC_IE_ALLOC_MD_S) {
1379 result_config_cie.alloc_method = A2DP_SBC_IE_ALLOC_MD_S;
1380 } else {
1381 LOG_ERROR(LOG_TAG,
1382 "%s: cannot match allocation method: local caps = 0x%x "
1383 "peer info = 0x%x",
1384 __func__, p_a2dp_sbc_caps->alloc_method,
1385 peer_info_cie.alloc_method);
1386 goto fail;
1387 }
1388
1389 //
1390 // Select the min/max bitpool
1391 //
1392 result_config_cie.min_bitpool = p_a2dp_sbc_caps->min_bitpool;
1393 if (result_config_cie.min_bitpool < peer_info_cie.min_bitpool)
1394 result_config_cie.min_bitpool = peer_info_cie.min_bitpool;
1395 result_config_cie.max_bitpool = p_a2dp_sbc_caps->max_bitpool;
1396 if (result_config_cie.max_bitpool > peer_info_cie.max_bitpool)
1397 result_config_cie.max_bitpool = peer_info_cie.max_bitpool;
1398 if (result_config_cie.min_bitpool > result_config_cie.max_bitpool) {
1399 LOG_ERROR(LOG_TAG,
1400 "%s: cannot match min/max bitpool: "
1401 "local caps min/max = 0x%x/0x%x peer info min/max = 0x%x/0x%x",
1402 __func__, p_a2dp_sbc_caps->min_bitpool,
1403 p_a2dp_sbc_caps->max_bitpool, peer_info_cie.min_bitpool,
1404 peer_info_cie.max_bitpool);
1405 goto fail;
1406 }
1407
1408 if (A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie,
1409 p_result_codec_config) != A2DP_SUCCESS) {
1410 goto fail;
1411 }
1412
1413 //
1414 // Copy the codec-specific fields if they are not zero
1415 //
1416 if (codec_user_config_.codec_specific_1 != 0)
1417 codec_config_.codec_specific_1 = codec_user_config_.codec_specific_1;
1418 if (codec_user_config_.codec_specific_2 != 0)
1419 codec_config_.codec_specific_2 = codec_user_config_.codec_specific_2;
1420 if (codec_user_config_.codec_specific_3 != 0)
1421 codec_config_.codec_specific_3 = codec_user_config_.codec_specific_3;
1422 if (codec_user_config_.codec_specific_4 != 0)
1423 codec_config_.codec_specific_4 = codec_user_config_.codec_specific_4;
1424
1425 // Create a local copy of the peer codec capability/config, and the
1426 // result codec config.
1427 if (is_capability) {
1428 status = A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &peer_info_cie,
1429 ota_codec_peer_capability_);
1430 } else {
1431 status = A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &peer_info_cie,
1432 ota_codec_peer_config_);
1433 }
1434 CHECK(status == A2DP_SUCCESS);
1435 status = A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie,
1436 ota_codec_config_);
1437 CHECK(status == A2DP_SUCCESS);
1438 return true;
1439
1440 fail:
1441 // Restore the internal state
1442 codec_config_ = saved_codec_config;
1443 codec_capability_ = saved_codec_capability;
1444 codec_selectable_capability_ = saved_codec_selectable_capability;
1445 codec_user_config_ = saved_codec_user_config;
1446 codec_audio_config_ = saved_codec_audio_config;
1447 memcpy(ota_codec_config_, saved_ota_codec_config, sizeof(ota_codec_config_));
1448 memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,
1449 sizeof(ota_codec_peer_capability_));
1450 memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config,
1451 sizeof(ota_codec_peer_config_));
1452 return false;
1453 }
1454
setPeerCodecCapabilities(const uint8_t * p_peer_codec_capabilities)1455 bool A2dpCodecConfigSbcBase::setPeerCodecCapabilities(
1456 const uint8_t* p_peer_codec_capabilities) {
1457 std::lock_guard<std::recursive_mutex> lock(codec_mutex_);
1458 tA2DP_SBC_CIE peer_info_cie;
1459 uint8_t samp_freq;
1460 uint8_t ch_mode;
1461 const tA2DP_SBC_CIE* p_a2dp_sbc_caps =
1462 (is_source_) ? &a2dp_sbc_source_caps : &a2dp_sbc_sink_caps;
1463
1464 // Save the internal state
1465 btav_a2dp_codec_config_t saved_codec_selectable_capability =
1466 codec_selectable_capability_;
1467 uint8_t saved_ota_codec_peer_capability[AVDT_CODEC_SIZE];
1468 memcpy(saved_ota_codec_peer_capability, ota_codec_peer_capability_,
1469 sizeof(ota_codec_peer_capability_));
1470
1471 tA2DP_STATUS status =
1472 A2DP_ParseInfoSbc(&peer_info_cie, p_peer_codec_capabilities, true);
1473 if (status != A2DP_SUCCESS) {
1474 LOG_ERROR(LOG_TAG, "%s: can't parse peer's capabilities: error = %d",
1475 __func__, status);
1476 goto fail;
1477 }
1478
1479 // Compute the selectable capability - sample rate
1480 samp_freq = p_a2dp_sbc_caps->samp_freq & peer_info_cie.samp_freq;
1481 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {
1482 codec_selectable_capability_.sample_rate |=
1483 BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
1484 }
1485 if (samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {
1486 codec_selectable_capability_.sample_rate |=
1487 BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
1488 }
1489
1490 // Compute the selectable capability - bits per sample
1491 codec_selectable_capability_.bits_per_sample =
1492 p_a2dp_sbc_caps->bits_per_sample;
1493
1494 // Compute the selectable capability - channel mode
1495 ch_mode = p_a2dp_sbc_caps->ch_mode & peer_info_cie.ch_mode;
1496 if (ch_mode & A2DP_SBC_IE_CH_MD_MONO) {
1497 codec_selectable_capability_.channel_mode |=
1498 BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
1499 }
1500 if (ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {
1501 codec_selectable_capability_.channel_mode |=
1502 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1503 }
1504 if (ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {
1505 codec_selectable_capability_.channel_mode |=
1506 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1507 }
1508 if (ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {
1509 codec_selectable_capability_.channel_mode |=
1510 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
1511 }
1512
1513 status = A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &peer_info_cie,
1514 ota_codec_peer_capability_);
1515 CHECK(status == A2DP_SUCCESS);
1516 return true;
1517
1518 fail:
1519 // Restore the internal state
1520 codec_selectable_capability_ = saved_codec_selectable_capability;
1521 memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,
1522 sizeof(ota_codec_peer_capability_));
1523 return false;
1524 }
1525
A2dpCodecConfigSbcSink(btav_a2dp_codec_priority_t codec_priority)1526 A2dpCodecConfigSbcSink::A2dpCodecConfigSbcSink(
1527 btav_a2dp_codec_priority_t codec_priority)
1528 : A2dpCodecConfigSbcBase(BTAV_A2DP_CODEC_INDEX_SINK_SBC, "SBC(Sink)",
1529 codec_priority, false) {}
1530
~A2dpCodecConfigSbcSink()1531 A2dpCodecConfigSbcSink::~A2dpCodecConfigSbcSink() {}
1532
init()1533 bool A2dpCodecConfigSbcSink::init() {
1534 if (!isValid()) return false;
1535
1536 // Load the decoder
1537 if (!A2DP_LoadDecoderSbc()) {
1538 LOG_ERROR(LOG_TAG, "%s: cannot load the decoder", __func__);
1539 return false;
1540 }
1541
1542 return true;
1543 }
1544
useRtpHeaderMarkerBit() const1545 bool A2dpCodecConfigSbcSink::useRtpHeaderMarkerBit() const {
1546 // TODO: This method applies only to Source codecs
1547 return false;
1548 }
1549
updateEncoderUserConfig(UNUSED_ATTR const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,UNUSED_ATTR bool * p_restart_input,UNUSED_ATTR bool * p_restart_output,UNUSED_ATTR bool * p_config_updated)1550 bool A2dpCodecConfigSbcSink::updateEncoderUserConfig(
1551 UNUSED_ATTR const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params,
1552 UNUSED_ATTR bool* p_restart_input, UNUSED_ATTR bool* p_restart_output,
1553 UNUSED_ATTR bool* p_config_updated) {
1554 // TODO: This method applies only to Source codecs
1555 return false;
1556 }
1557
encoderIntervalMs() const1558 period_ms_t A2dpCodecConfigSbcSink::encoderIntervalMs() const {
1559 // TODO: This method applies only to Source codecs
1560 return 0;
1561 }
1562
getEffectiveMtu() const1563 int A2dpCodecConfigSbcSink::getEffectiveMtu() const {
1564 // TODO: This method applies only to Source codecs
1565 return 0;
1566 }
1567