1/* 2 * Copyright 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17/****************************************************************************** 18 * 19 * Utility functions to help build and parse the AAC Codec Information 20 * Element and Media Payload. 21 * 22 ******************************************************************************/ 23 24#define LOG_TAG "a2dp_aac" 25 26#include "bt_target.h" 27 28#include "a2dp_aac.h" 29 30#include <string.h> 31 32#include <base/logging.h> 33#include "a2dp_aac_decoder.h" 34#include "a2dp_aac_encoder.h" 35#include "bt_utils.h" 36#include "osi/include/log.h" 37#include "osi/include/osi.h" 38 39#define A2DP_AAC_DEFAULT_BITRATE 320000 // 320 kbps 40#define A2DP_AAC_MIN_BITRATE 64000 // 64 kbps 41 42// data type for the AAC Codec Information Element */ 43// NOTE: bits_per_sample is needed only for AAC encoder initialization. 44typedef struct { 45 uint8_t objectType; /* Object Type */ 46 uint16_t sampleRate; /* Sampling Frequency */ 47 uint8_t channelMode; /* STEREO/MONO */ 48 uint8_t variableBitRateSupport; /* Variable Bit Rate Support*/ 49 uint32_t bitRate; /* Bit rate */ 50 btav_a2dp_codec_bits_per_sample_t bits_per_sample; 51} tA2DP_AAC_CIE; 52 53/* AAC Source codec capabilities */ 54static const tA2DP_AAC_CIE a2dp_aac_source_caps = { 55 // objectType 56 A2DP_AAC_OBJECT_TYPE_MPEG2_LC, 57 // sampleRate 58 // TODO: AAC 48.0kHz sampling rate should be added back - see b/62301376 59 A2DP_AAC_SAMPLING_FREQ_44100, 60 // channelMode 61 A2DP_AAC_CHANNEL_MODE_STEREO, 62 // variableBitRateSupport 63 A2DP_AAC_VARIABLE_BIT_RATE_DISABLED, 64 // bitRate 65 A2DP_AAC_DEFAULT_BITRATE, 66 // bits_per_sample 67 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16}; 68 69/* AAC Sink codec capabilities */ 70static const tA2DP_AAC_CIE a2dp_aac_sink_caps = { 71 // objectType 72 A2DP_AAC_OBJECT_TYPE_MPEG2_LC, 73 // sampleRate 74 A2DP_AAC_SAMPLING_FREQ_44100 | A2DP_AAC_SAMPLING_FREQ_48000, 75 // channelMode 76 A2DP_AAC_CHANNEL_MODE_MONO | A2DP_AAC_CHANNEL_MODE_STEREO, 77 // variableBitRateSupport 78 A2DP_AAC_VARIABLE_BIT_RATE_ENABLED, 79 // bitRate 80 A2DP_AAC_DEFAULT_BITRATE, 81 // bits_per_sample 82 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16}; 83 84/* Default AAC codec configuration */ 85static const tA2DP_AAC_CIE a2dp_aac_default_config = { 86 A2DP_AAC_OBJECT_TYPE_MPEG2_LC, // objectType 87 A2DP_AAC_SAMPLING_FREQ_44100, // sampleRate 88 A2DP_AAC_CHANNEL_MODE_STEREO, // channelMode 89 A2DP_AAC_VARIABLE_BIT_RATE_DISABLED, // variableBitRateSupport 90 A2DP_AAC_DEFAULT_BITRATE, // bitRate 91 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 // bits_per_sample 92}; 93 94static const tA2DP_ENCODER_INTERFACE a2dp_encoder_interface_aac = { 95 a2dp_aac_encoder_init, 96 a2dp_aac_encoder_cleanup, 97 a2dp_aac_feeding_reset, 98 a2dp_aac_feeding_flush, 99 a2dp_aac_get_encoder_interval_ms, 100 a2dp_aac_send_frames, 101 nullptr // set_transmit_queue_length 102}; 103 104static const tA2DP_DECODER_INTERFACE a2dp_decoder_interface_aac = { 105 a2dp_aac_decoder_init, a2dp_aac_decoder_cleanup, 106 a2dp_aac_decoder_decode_packet, 107}; 108 109UNUSED_ATTR static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilityAac( 110 const tA2DP_AAC_CIE* p_cap, const uint8_t* p_codec_info, 111 bool is_capability); 112 113// Builds the AAC Media Codec Capabilities byte sequence beginning from the 114// LOSC octet. |media_type| is the media type |AVDT_MEDIA_TYPE_*|. 115// |p_ie| is a pointer to the AAC Codec Information Element information. 116// The result is stored in |p_result|. Returns A2DP_SUCCESS on success, 117// otherwise the corresponding A2DP error status code. 118static tA2DP_STATUS A2DP_BuildInfoAac(uint8_t media_type, 119 const tA2DP_AAC_CIE* p_ie, 120 uint8_t* p_result) { 121 if (p_ie == NULL || p_result == NULL) { 122 return A2DP_INVALID_PARAMS; 123 } 124 125 *p_result++ = A2DP_AAC_CODEC_LEN; 126 *p_result++ = (media_type << 4); 127 *p_result++ = A2DP_MEDIA_CT_AAC; 128 129 // Object Type 130 if (p_ie->objectType == 0) return A2DP_INVALID_PARAMS; 131 *p_result++ = p_ie->objectType; 132 133 // Sampling Frequency 134 if (p_ie->sampleRate == 0) return A2DP_INVALID_PARAMS; 135 *p_result++ = (uint8_t)(p_ie->sampleRate & A2DP_AAC_SAMPLING_FREQ_MASK0); 136 *p_result = (uint8_t)((p_ie->sampleRate & A2DP_AAC_SAMPLING_FREQ_MASK1) >> 8); 137 138 // Channel Mode 139 if (p_ie->channelMode == 0) return A2DP_INVALID_PARAMS; 140 *p_result++ |= (p_ie->channelMode & A2DP_AAC_CHANNEL_MODE_MASK); 141 142 // Variable Bit Rate Support 143 *p_result = (p_ie->variableBitRateSupport & A2DP_AAC_VARIABLE_BIT_RATE_MASK); 144 145 // Bit Rate 146 *p_result++ |= (uint8_t)((p_ie->bitRate & A2DP_AAC_BIT_RATE_MASK0) >> 16); 147 *p_result++ = (uint8_t)((p_ie->bitRate & A2DP_AAC_BIT_RATE_MASK1) >> 8); 148 *p_result++ = (uint8_t)(p_ie->bitRate & A2DP_AAC_BIT_RATE_MASK2); 149 150 return A2DP_SUCCESS; 151} 152 153// Parses the AAC Media Codec Capabilities byte sequence beginning from the 154// LOSC octet. The result is stored in |p_ie|. The byte sequence to parse is 155// |p_codec_info|. If |is_capability| is true, the byte sequence is 156// codec capabilities, otherwise is codec configuration. 157// Returns A2DP_SUCCESS on success, otherwise the corresponding A2DP error 158// status code. 159static tA2DP_STATUS A2DP_ParseInfoAac(tA2DP_AAC_CIE* p_ie, 160 const uint8_t* p_codec_info, 161 bool is_capability) { 162 uint8_t losc; 163 uint8_t media_type; 164 tA2DP_CODEC_TYPE codec_type; 165 166 if (p_ie == NULL || p_codec_info == NULL) return A2DP_INVALID_PARAMS; 167 168 // Check the codec capability length 169 losc = *p_codec_info++; 170 if (losc != A2DP_AAC_CODEC_LEN) return A2DP_WRONG_CODEC; 171 172 media_type = (*p_codec_info++) >> 4; 173 codec_type = *p_codec_info++; 174 /* Check the Media Type and Media Codec Type */ 175 if (media_type != AVDT_MEDIA_TYPE_AUDIO || codec_type != A2DP_MEDIA_CT_AAC) { 176 return A2DP_WRONG_CODEC; 177 } 178 179 p_ie->objectType = *p_codec_info++; 180 p_ie->sampleRate = (*p_codec_info & A2DP_AAC_SAMPLING_FREQ_MASK0) | 181 (*(p_codec_info + 1) << 8 & A2DP_AAC_SAMPLING_FREQ_MASK1); 182 p_codec_info++; 183 p_ie->channelMode = *p_codec_info & A2DP_AAC_CHANNEL_MODE_MASK; 184 p_codec_info++; 185 186 p_ie->variableBitRateSupport = 187 *p_codec_info & A2DP_AAC_VARIABLE_BIT_RATE_MASK; 188 189 p_ie->bitRate = ((*p_codec_info) << 16 & A2DP_AAC_BIT_RATE_MASK0) | 190 (*(p_codec_info + 1) << 8 & A2DP_AAC_BIT_RATE_MASK1) | 191 (*(p_codec_info + 2) & A2DP_AAC_BIT_RATE_MASK2); 192 p_codec_info += 3; 193 194 if (is_capability) return A2DP_SUCCESS; 195 196 if (A2DP_BitsSet(p_ie->objectType) != A2DP_SET_ONE_BIT) 197 return A2DP_BAD_OBJ_TYPE; 198 if (A2DP_BitsSet(p_ie->sampleRate) != A2DP_SET_ONE_BIT) 199 return A2DP_BAD_SAMP_FREQ; 200 if (A2DP_BitsSet(p_ie->channelMode) != A2DP_SET_ONE_BIT) 201 return A2DP_BAD_CH_MODE; 202 203 return A2DP_SUCCESS; 204} 205 206bool A2DP_IsSourceCodecValidAac(const uint8_t* p_codec_info) { 207 tA2DP_AAC_CIE cfg_cie; 208 209 /* Use a liberal check when parsing the codec info */ 210 return (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) || 211 (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS); 212} 213 214bool A2DP_IsSinkCodecValidAac(UNUSED_ATTR const uint8_t* p_codec_info) { 215 tA2DP_AAC_CIE cfg_cie; 216 217 /* Use a liberal check when parsing the codec info */ 218 return (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) || 219 (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS); 220} 221 222bool A2DP_IsPeerSourceCodecValidAac(UNUSED_ATTR const uint8_t* p_codec_info) { 223 tA2DP_AAC_CIE cfg_cie; 224 225 /* Use a liberal check when parsing the codec info */ 226 return (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) || 227 (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS); 228} 229 230bool A2DP_IsPeerSinkCodecValidAac(const uint8_t* p_codec_info) { 231 tA2DP_AAC_CIE cfg_cie; 232 233 /* Use a liberal check when parsing the codec info */ 234 return (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) || 235 (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS); 236} 237 238bool A2DP_IsSinkCodecSupportedAac(const uint8_t* p_codec_info) { 239 return A2DP_CodecInfoMatchesCapabilityAac(&a2dp_aac_sink_caps, p_codec_info, 240 false) == A2DP_SUCCESS; 241} 242 243bool A2DP_IsPeerSourceCodecSupportedAac(const uint8_t* p_codec_info) { 244 return A2DP_CodecInfoMatchesCapabilityAac(&a2dp_aac_sink_caps, p_codec_info, 245 true) == A2DP_SUCCESS; 246} 247 248// Checks whether A2DP AAC codec configuration matches with a device's codec 249// capabilities. |p_cap| is the AAC codec configuration. |p_codec_info| is 250// the device's codec capabilities. |is_capability| is true if 251// |p_codec_info| contains A2DP codec capability. 252// Returns A2DP_SUCCESS if the codec configuration matches with capabilities, 253// otherwise the corresponding A2DP error status code. 254static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilityAac( 255 const tA2DP_AAC_CIE* p_cap, const uint8_t* p_codec_info, 256 bool is_capability) { 257 tA2DP_STATUS status; 258 tA2DP_AAC_CIE cfg_cie; 259 260 /* parse configuration */ 261 status = A2DP_ParseInfoAac(&cfg_cie, p_codec_info, is_capability); 262 if (status != A2DP_SUCCESS) { 263 LOG_ERROR(LOG_TAG, "%s: parsing failed %d", __func__, status); 264 return status; 265 } 266 267 /* verify that each parameter is in range */ 268 269 LOG_VERBOSE(LOG_TAG, "%s: Object Type peer: 0x%x, capability 0x%x", __func__, 270 cfg_cie.objectType, p_cap->objectType); 271 LOG_VERBOSE(LOG_TAG, "%s: Sample Rate peer: %u, capability %u", __func__, 272 cfg_cie.sampleRate, p_cap->sampleRate); 273 LOG_VERBOSE(LOG_TAG, "%s: Channel Mode peer: 0x%x, capability 0x%x", __func__, 274 cfg_cie.channelMode, p_cap->channelMode); 275 LOG_VERBOSE( 276 LOG_TAG, "%s: Variable Bit Rate Support peer: 0x%x, capability 0x%x", 277 __func__, cfg_cie.variableBitRateSupport, p_cap->variableBitRateSupport); 278 LOG_VERBOSE(LOG_TAG, "%s: Bit Rate peer: %u, capability %u", __func__, 279 cfg_cie.bitRate, p_cap->bitRate); 280 281 /* Object Type */ 282 if ((cfg_cie.objectType & p_cap->objectType) == 0) return A2DP_BAD_OBJ_TYPE; 283 284 /* Sample Rate */ 285 if ((cfg_cie.sampleRate & p_cap->sampleRate) == 0) return A2DP_BAD_SAMP_FREQ; 286 287 /* Channel Mode */ 288 if ((cfg_cie.channelMode & p_cap->channelMode) == 0) return A2DP_NS_CH_MODE; 289 290 return A2DP_SUCCESS; 291} 292 293bool A2DP_UsesRtpHeaderAac(UNUSED_ATTR bool content_protection_enabled, 294 UNUSED_ATTR const uint8_t* p_codec_info) { 295 return true; 296} 297 298const char* A2DP_CodecNameAac(UNUSED_ATTR const uint8_t* p_codec_info) { 299 return "AAC"; 300} 301 302bool A2DP_CodecTypeEqualsAac(const uint8_t* p_codec_info_a, 303 const uint8_t* p_codec_info_b) { 304 tA2DP_AAC_CIE aac_cie_a; 305 tA2DP_AAC_CIE aac_cie_b; 306 307 // Check whether the codec info contains valid data 308 tA2DP_STATUS a2dp_status = 309 A2DP_ParseInfoAac(&aac_cie_a, p_codec_info_a, true); 310 if (a2dp_status != A2DP_SUCCESS) { 311 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 312 a2dp_status); 313 return false; 314 } 315 a2dp_status = A2DP_ParseInfoAac(&aac_cie_b, p_codec_info_b, true); 316 if (a2dp_status != A2DP_SUCCESS) { 317 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 318 a2dp_status); 319 return false; 320 } 321 322 return true; 323} 324 325bool A2DP_CodecEqualsAac(const uint8_t* p_codec_info_a, 326 const uint8_t* p_codec_info_b) { 327 tA2DP_AAC_CIE aac_cie_a; 328 tA2DP_AAC_CIE aac_cie_b; 329 330 // Check whether the codec info contains valid data 331 tA2DP_STATUS a2dp_status = 332 A2DP_ParseInfoAac(&aac_cie_a, p_codec_info_a, true); 333 if (a2dp_status != A2DP_SUCCESS) { 334 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 335 a2dp_status); 336 return false; 337 } 338 a2dp_status = A2DP_ParseInfoAac(&aac_cie_b, p_codec_info_b, true); 339 if (a2dp_status != A2DP_SUCCESS) { 340 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 341 a2dp_status); 342 return false; 343 } 344 345 return (aac_cie_a.objectType == aac_cie_b.objectType) && 346 (aac_cie_a.sampleRate == aac_cie_b.sampleRate) && 347 (aac_cie_a.channelMode == aac_cie_b.channelMode) && 348 (aac_cie_a.variableBitRateSupport == 349 aac_cie_b.variableBitRateSupport) && 350 (aac_cie_a.bitRate == aac_cie_b.bitRate); 351} 352 353int A2DP_GetTrackSampleRateAac(const uint8_t* p_codec_info) { 354 tA2DP_AAC_CIE aac_cie; 355 356 // Check whether the codec info contains valid data 357 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 358 if (a2dp_status != A2DP_SUCCESS) { 359 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 360 a2dp_status); 361 return -1; 362 } 363 364 switch (aac_cie.sampleRate) { 365 case A2DP_AAC_SAMPLING_FREQ_8000: 366 return 8000; 367 case A2DP_AAC_SAMPLING_FREQ_11025: 368 return 11025; 369 case A2DP_AAC_SAMPLING_FREQ_12000: 370 return 12000; 371 case A2DP_AAC_SAMPLING_FREQ_16000: 372 return 16000; 373 case A2DP_AAC_SAMPLING_FREQ_22050: 374 return 22050; 375 case A2DP_AAC_SAMPLING_FREQ_24000: 376 return 24000; 377 case A2DP_AAC_SAMPLING_FREQ_32000: 378 return 32000; 379 case A2DP_AAC_SAMPLING_FREQ_44100: 380 return 44100; 381 case A2DP_AAC_SAMPLING_FREQ_48000: 382 return 48000; 383 case A2DP_AAC_SAMPLING_FREQ_64000: 384 return 64000; 385 case A2DP_AAC_SAMPLING_FREQ_88200: 386 return 88200; 387 case A2DP_AAC_SAMPLING_FREQ_96000: 388 return 96000; 389 } 390 391 return -1; 392} 393 394int A2DP_GetTrackChannelCountAac(const uint8_t* p_codec_info) { 395 tA2DP_AAC_CIE aac_cie; 396 397 // Check whether the codec info contains valid data 398 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 399 if (a2dp_status != A2DP_SUCCESS) { 400 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 401 a2dp_status); 402 return -1; 403 } 404 405 switch (aac_cie.channelMode) { 406 case A2DP_AAC_CHANNEL_MODE_MONO: 407 return 1; 408 case A2DP_AAC_CHANNEL_MODE_STEREO: 409 return 2; 410 } 411 412 return -1; 413} 414 415int A2DP_GetSinkTrackChannelTypeAac(const uint8_t* p_codec_info) { 416 tA2DP_AAC_CIE aac_cie; 417 418 // Check whether the codec info contains valid data 419 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 420 if (a2dp_status != A2DP_SUCCESS) { 421 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 422 a2dp_status); 423 return -1; 424 } 425 426 switch (aac_cie.channelMode) { 427 case A2DP_AAC_CHANNEL_MODE_MONO: 428 return 1; 429 case A2DP_AAC_CHANNEL_MODE_STEREO: 430 return 3; 431 } 432 433 return -1; 434} 435 436int A2DP_GetObjectTypeCodeAac(const uint8_t* p_codec_info) { 437 tA2DP_AAC_CIE aac_cie; 438 439 // Check whether the codec info contains valid data 440 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 441 if (a2dp_status != A2DP_SUCCESS) { 442 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 443 a2dp_status); 444 return -1; 445 } 446 447 switch (aac_cie.objectType) { 448 case A2DP_AAC_OBJECT_TYPE_MPEG2_LC: 449 case A2DP_AAC_OBJECT_TYPE_MPEG4_LC: 450 case A2DP_AAC_OBJECT_TYPE_MPEG4_LTP: 451 case A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE: 452 return aac_cie.objectType; 453 default: 454 break; 455 } 456 457 return -1; 458} 459 460int A2DP_GetChannelModeCodeAac(const uint8_t* p_codec_info) { 461 tA2DP_AAC_CIE aac_cie; 462 463 // Check whether the codec info contains valid data 464 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 465 if (a2dp_status != A2DP_SUCCESS) { 466 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 467 a2dp_status); 468 return -1; 469 } 470 471 switch (aac_cie.channelMode) { 472 case A2DP_AAC_CHANNEL_MODE_MONO: 473 case A2DP_AAC_CHANNEL_MODE_STEREO: 474 return aac_cie.channelMode; 475 default: 476 break; 477 } 478 479 return -1; 480} 481 482int A2DP_GetVariableBitRateSupportAac(const uint8_t* p_codec_info) { 483 tA2DP_AAC_CIE aac_cie; 484 485 // Check whether the codec info contains valid data 486 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 487 if (a2dp_status != A2DP_SUCCESS) { 488 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 489 a2dp_status); 490 return -1; 491 } 492 493 switch (aac_cie.variableBitRateSupport) { 494 case A2DP_AAC_VARIABLE_BIT_RATE_ENABLED: 495 case A2DP_AAC_VARIABLE_BIT_RATE_DISABLED: 496 return aac_cie.variableBitRateSupport; 497 default: 498 break; 499 } 500 501 return -1; 502} 503 504int A2DP_GetBitRateAac(const uint8_t* p_codec_info) { 505 tA2DP_AAC_CIE aac_cie; 506 507 // Check whether the codec info contains valid data 508 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 509 if (a2dp_status != A2DP_SUCCESS) { 510 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 511 a2dp_status); 512 return -1; 513 } 514 515 return aac_cie.bitRate; 516} 517 518int A2DP_ComputeMaxBitRateAac(const uint8_t* p_codec_info, uint16_t mtu) { 519 tA2DP_AAC_CIE aac_cie; 520 521 // Check whether the codec info contains valid data 522 tA2DP_STATUS a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, false); 523 if (a2dp_status != A2DP_SUCCESS) { 524 LOG_ERROR(LOG_TAG, "%s: cannot decode codec information: %d", __func__, 525 a2dp_status); 526 return -1; 527 } 528 529 int sampling_freq = A2DP_GetTrackSampleRateAac(p_codec_info); 530 if (sampling_freq == -1) return -1; 531 532 int pcm_channel_samples_per_frame = 0; 533 switch (aac_cie.objectType) { 534 case A2DP_AAC_OBJECT_TYPE_MPEG2_LC: 535 case A2DP_AAC_OBJECT_TYPE_MPEG4_LC: 536 pcm_channel_samples_per_frame = 1024; 537 break; 538 case A2DP_AAC_OBJECT_TYPE_MPEG4_LTP: 539 case A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE: 540 // TODO: The MPEG documentation doesn't specify the value. 541 break; 542 default: 543 break; 544 } 545 if (pcm_channel_samples_per_frame == 0) return -1; 546 547 // See Section 3.2.1 Estimating Average Frame Size from 548 // the aacEncoder.pdf document included with the AAC source code. 549 return (8 * mtu * sampling_freq) / pcm_channel_samples_per_frame; 550} 551 552bool A2DP_GetPacketTimestampAac(const uint8_t* p_codec_info, 553 const uint8_t* p_data, uint32_t* p_timestamp) { 554 // TODO: Is this function really codec-specific? 555 *p_timestamp = *(const uint32_t*)p_data; 556 return true; 557} 558 559bool A2DP_BuildCodecHeaderAac(UNUSED_ATTR const uint8_t* p_codec_info, 560 UNUSED_ATTR BT_HDR* p_buf, 561 UNUSED_ATTR uint16_t frames_per_packet) { 562 return true; 563} 564 565std::string A2DP_CodecInfoStringAac(const uint8_t* p_codec_info) { 566 std::stringstream res; 567 std::string field; 568 tA2DP_STATUS a2dp_status; 569 tA2DP_AAC_CIE aac_cie; 570 571 a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, true); 572 if (a2dp_status != A2DP_SUCCESS) { 573 res << "A2DP_ParseInfoAac fail: " << loghex(a2dp_status); 574 return res.str(); 575 } 576 577 res << "\tname: AAC\n"; 578 579 // Object type 580 field.clear(); 581 AppendField(&field, (aac_cie.objectType == 0), "NONE"); 582 AppendField(&field, (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG2_LC), 583 "(MPEG-2 AAC LC)"); 584 AppendField(&field, (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_LC), 585 "(MPEG-4 AAC LC)"); 586 AppendField(&field, (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_LTP), 587 "(MPEG-4 AAC LTP)"); 588 AppendField(&field, 589 (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE), 590 "(MPEG-4 AAC Scalable)"); 591 res << "\tobjectType: " << field << " (" << loghex(aac_cie.objectType) 592 << ")\n"; 593 594 // Sample frequency 595 field.clear(); 596 AppendField(&field, (aac_cie.sampleRate == 0), "NONE"); 597 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_8000), 598 "8000"); 599 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_11025), 600 "11025"); 601 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_12000), 602 "12000"); 603 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_16000), 604 "16000"); 605 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_22050), 606 "22050"); 607 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_24000), 608 "24000"); 609 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_32000), 610 "32000"); 611 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_44100), 612 "44100"); 613 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_48000), 614 "48000"); 615 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_64000), 616 "64000"); 617 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_88200), 618 "88200"); 619 AppendField(&field, (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_96000), 620 "96000"); 621 res << "\tsamp_freq: " << field << " (" << loghex(aac_cie.sampleRate) 622 << ")\n"; 623 624 // Channel mode 625 field.clear(); 626 AppendField(&field, (aac_cie.channelMode == 0), "NONE"); 627 AppendField(&field, (aac_cie.channelMode == A2DP_AAC_CHANNEL_MODE_MONO), 628 "Mono"); 629 AppendField(&field, (aac_cie.channelMode == A2DP_AAC_CHANNEL_MODE_STEREO), 630 "Stereo"); 631 res << "\tch_mode: " << field << " (" << loghex(aac_cie.channelMode) << ")\n"; 632 633 // Variable bit rate support 634 res << "\tvariableBitRateSupport: " << std::boolalpha 635 << (aac_cie.variableBitRateSupport != 0) << "\n"; 636 637 // Bit rate 638 res << "\tbitRate: " << std::to_string(aac_cie.bitRate) << "\n"; 639 640 return res.str(); 641} 642 643const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterfaceAac( 644 const uint8_t* p_codec_info) { 645 if (!A2DP_IsSourceCodecValidAac(p_codec_info)) return NULL; 646 647 return &a2dp_encoder_interface_aac; 648} 649 650const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterfaceAac( 651 const uint8_t* p_codec_info) { 652 if (!A2DP_IsSinkCodecValidAac(p_codec_info)) return NULL; 653 654 return &a2dp_decoder_interface_aac; 655} 656 657bool A2DP_AdjustCodecAac(uint8_t* p_codec_info) { 658 tA2DP_AAC_CIE cfg_cie; 659 660 // Nothing to do: just verify the codec info is valid 661 if (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) != A2DP_SUCCESS) 662 return false; 663 664 return true; 665} 666 667btav_a2dp_codec_index_t A2DP_SourceCodecIndexAac( 668 UNUSED_ATTR const uint8_t* p_codec_info) { 669 return BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; 670} 671 672btav_a2dp_codec_index_t A2DP_SinkCodecIndexAac( 673 UNUSED_ATTR const uint8_t* p_codec_info) { 674 return BTAV_A2DP_CODEC_INDEX_SINK_AAC; 675} 676 677const char* A2DP_CodecIndexStrAac(void) { return "AAC"; } 678 679const char* A2DP_CodecIndexStrAacSink(void) { return "AAC SINK"; } 680 681bool A2DP_InitCodecConfigAac(AvdtpSepConfig* p_cfg) { 682 if (A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &a2dp_aac_source_caps, 683 p_cfg->codec_info) != A2DP_SUCCESS) { 684 return false; 685 } 686 687#if (BTA_AV_CO_CP_SCMS_T == TRUE) 688 /* Content protection info - support SCMS-T */ 689 uint8_t* p = p_cfg->protect_info; 690 *p++ = AVDT_CP_LOSC; 691 UINT16_TO_STREAM(p, AVDT_CP_SCMS_T_ID); 692 p_cfg->num_protect = 1; 693#endif 694 695 return true; 696} 697 698bool A2DP_InitCodecConfigAacSink(AvdtpSepConfig* p_cfg) { 699 return A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &a2dp_aac_sink_caps, 700 p_cfg->codec_info) == A2DP_SUCCESS; 701} 702 703UNUSED_ATTR static void build_codec_config(const tA2DP_AAC_CIE& config_cie, 704 btav_a2dp_codec_config_t* result) { 705 if (config_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) 706 result->sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_44100; 707 if (config_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) 708 result->sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_48000; 709 if (config_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) 710 result->sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_88200; 711 if (config_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) 712 result->sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_96000; 713 714 result->bits_per_sample = config_cie.bits_per_sample; 715 716 if (config_cie.channelMode & A2DP_AAC_CHANNEL_MODE_MONO) 717 result->channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_MONO; 718 if (config_cie.channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 719 result->channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO; 720 } 721} 722 723A2dpCodecConfigAacSource::A2dpCodecConfigAacSource( 724 btav_a2dp_codec_priority_t codec_priority) 725 : A2dpCodecConfigAacBase(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC, 726 A2DP_CodecIndexStrAac(), codec_priority, true) { 727 // Compute the local capability 728 if (a2dp_aac_source_caps.sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) { 729 codec_local_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_44100; 730 } 731 if (a2dp_aac_source_caps.sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) { 732 codec_local_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_48000; 733 } 734 if (a2dp_aac_source_caps.sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) { 735 codec_local_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_88200; 736 } 737 if (a2dp_aac_source_caps.sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) { 738 codec_local_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_96000; 739 } 740 codec_local_capability_.bits_per_sample = 741 a2dp_aac_source_caps.bits_per_sample; 742 if (a2dp_aac_source_caps.channelMode & A2DP_AAC_CHANNEL_MODE_MONO) { 743 codec_local_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_MONO; 744 } 745 if (a2dp_aac_source_caps.channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 746 codec_local_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO; 747 } 748} 749 750A2dpCodecConfigAacSource::~A2dpCodecConfigAacSource() {} 751 752bool A2dpCodecConfigAacSource::init() { 753 if (!isValid()) return false; 754 755 // Load the encoder 756 if (!A2DP_LoadEncoderAac()) { 757 LOG_ERROR(LOG_TAG, "%s: cannot load the encoder", __func__); 758 return false; 759 } 760 761 return true; 762} 763 764bool A2dpCodecConfigAacSource::useRtpHeaderMarkerBit() const { return true; } 765 766// 767// Selects the best sample rate from |sampleRate|. 768// The result is stored in |p_result| and |p_codec_config|. 769// Returns true if a selection was made, otherwise false. 770// 771static bool select_best_sample_rate(uint16_t sampleRate, 772 tA2DP_AAC_CIE* p_result, 773 btav_a2dp_codec_config_t* p_codec_config) { 774 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) { 775 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_96000; 776 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_96000; 777 return true; 778 } 779 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) { 780 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_88200; 781 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_88200; 782 return true; 783 } 784 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) { 785 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_48000; 786 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_48000; 787 return true; 788 } 789 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) { 790 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_44100; 791 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_44100; 792 return true; 793 } 794 return false; 795} 796 797// 798// Selects the audio sample rate from |p_codec_audio_config|. 799// |sampleRate| contains the capability. 800// The result is stored in |p_result| and |p_codec_config|. 801// Returns true if a selection was made, otherwise false. 802// 803static bool select_audio_sample_rate( 804 const btav_a2dp_codec_config_t* p_codec_audio_config, uint16_t sampleRate, 805 tA2DP_AAC_CIE* p_result, btav_a2dp_codec_config_t* p_codec_config) { 806 switch (p_codec_audio_config->sample_rate) { 807 case BTAV_A2DP_CODEC_SAMPLE_RATE_44100: 808 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) { 809 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_44100; 810 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_44100; 811 return true; 812 } 813 break; 814 case BTAV_A2DP_CODEC_SAMPLE_RATE_48000: 815 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) { 816 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_48000; 817 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_48000; 818 return true; 819 } 820 break; 821 case BTAV_A2DP_CODEC_SAMPLE_RATE_88200: 822 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) { 823 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_88200; 824 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_88200; 825 return true; 826 } 827 break; 828 case BTAV_A2DP_CODEC_SAMPLE_RATE_96000: 829 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) { 830 p_result->sampleRate = A2DP_AAC_SAMPLING_FREQ_96000; 831 p_codec_config->sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_96000; 832 return true; 833 } 834 break; 835 case BTAV_A2DP_CODEC_SAMPLE_RATE_176400: 836 case BTAV_A2DP_CODEC_SAMPLE_RATE_192000: 837 case BTAV_A2DP_CODEC_SAMPLE_RATE_16000: 838 case BTAV_A2DP_CODEC_SAMPLE_RATE_24000: 839 case BTAV_A2DP_CODEC_SAMPLE_RATE_NONE: 840 break; 841 } 842 return false; 843} 844 845// 846// Selects the best bits per sample from |bits_per_sample|. 847// |bits_per_sample| contains the capability. 848// The result is stored in |p_result| and |p_codec_config|. 849// Returns true if a selection was made, otherwise false. 850// 851static bool select_best_bits_per_sample( 852 btav_a2dp_codec_bits_per_sample_t bits_per_sample, tA2DP_AAC_CIE* p_result, 853 btav_a2dp_codec_config_t* p_codec_config) { 854 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32) { 855 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32; 856 p_result->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32; 857 return true; 858 } 859 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24) { 860 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24; 861 p_result->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24; 862 return true; 863 } 864 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16) { 865 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16; 866 p_result->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16; 867 return true; 868 } 869 return false; 870} 871 872// 873// Selects the audio bits per sample from |p_codec_audio_config|. 874// |bits_per_sample| contains the capability. 875// The result is stored in |p_result| and |p_codec_config|. 876// Returns true if a selection was made, otherwise false. 877// 878static bool select_audio_bits_per_sample( 879 const btav_a2dp_codec_config_t* p_codec_audio_config, 880 btav_a2dp_codec_bits_per_sample_t bits_per_sample, tA2DP_AAC_CIE* p_result, 881 btav_a2dp_codec_config_t* p_codec_config) { 882 switch (p_codec_audio_config->bits_per_sample) { 883 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16: 884 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16) { 885 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16; 886 p_result->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16; 887 return true; 888 } 889 break; 890 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24: 891 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24) { 892 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24; 893 p_result->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24; 894 return true; 895 } 896 break; 897 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32: 898 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32) { 899 p_codec_config->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32; 900 p_result->bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32; 901 return true; 902 } 903 break; 904 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE: 905 break; 906 } 907 return false; 908} 909 910// 911// Selects the best channel mode from |channelMode|. 912// The result is stored in |p_result| and |p_codec_config|. 913// Returns true if a selection was made, otherwise false. 914// 915static bool select_best_channel_mode(uint8_t channelMode, 916 tA2DP_AAC_CIE* p_result, 917 btav_a2dp_codec_config_t* p_codec_config) { 918 if (channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 919 p_result->channelMode = A2DP_AAC_CHANNEL_MODE_STEREO; 920 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO; 921 return true; 922 } 923 if (channelMode & A2DP_AAC_CHANNEL_MODE_MONO) { 924 p_result->channelMode = A2DP_AAC_CHANNEL_MODE_MONO; 925 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_MONO; 926 return true; 927 } 928 return false; 929} 930 931// 932// Selects the audio channel mode from |p_codec_audio_config|. 933// |channelMode| contains the capability. 934// The result is stored in |p_result| and |p_codec_config|. 935// Returns true if a selection was made, otherwise false. 936// 937static bool select_audio_channel_mode( 938 const btav_a2dp_codec_config_t* p_codec_audio_config, uint8_t channelMode, 939 tA2DP_AAC_CIE* p_result, btav_a2dp_codec_config_t* p_codec_config) { 940 switch (p_codec_audio_config->channel_mode) { 941 case BTAV_A2DP_CODEC_CHANNEL_MODE_MONO: 942 if (channelMode & A2DP_AAC_CHANNEL_MODE_MONO) { 943 p_result->channelMode = A2DP_AAC_CHANNEL_MODE_MONO; 944 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_MONO; 945 return true; 946 } 947 break; 948 case BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO: 949 if (channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 950 p_result->channelMode = A2DP_AAC_CHANNEL_MODE_STEREO; 951 p_codec_config->channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO; 952 return true; 953 } 954 break; 955 case BTAV_A2DP_CODEC_CHANNEL_MODE_NONE: 956 break; 957 } 958 959 return false; 960} 961 962bool A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info, 963 bool is_capability, 964 uint8_t* p_result_codec_config) { 965 std::lock_guard<std::recursive_mutex> lock(codec_mutex_); 966 tA2DP_AAC_CIE peer_info_cie; 967 tA2DP_AAC_CIE result_config_cie; 968 uint8_t channelMode; 969 uint16_t sampleRate; 970 btav_a2dp_codec_bits_per_sample_t bits_per_sample; 971 const tA2DP_AAC_CIE* p_a2dp_aac_caps = 972 (is_source_) ? &a2dp_aac_source_caps : &a2dp_aac_sink_caps; 973 974 // Save the internal state 975 btav_a2dp_codec_config_t saved_codec_config = codec_config_; 976 btav_a2dp_codec_config_t saved_codec_capability = codec_capability_; 977 btav_a2dp_codec_config_t saved_codec_selectable_capability = 978 codec_selectable_capability_; 979 btav_a2dp_codec_config_t saved_codec_user_config = codec_user_config_; 980 btav_a2dp_codec_config_t saved_codec_audio_config = codec_audio_config_; 981 uint8_t saved_ota_codec_config[AVDT_CODEC_SIZE]; 982 uint8_t saved_ota_codec_peer_capability[AVDT_CODEC_SIZE]; 983 uint8_t saved_ota_codec_peer_config[AVDT_CODEC_SIZE]; 984 memcpy(saved_ota_codec_config, ota_codec_config_, sizeof(ota_codec_config_)); 985 memcpy(saved_ota_codec_peer_capability, ota_codec_peer_capability_, 986 sizeof(ota_codec_peer_capability_)); 987 memcpy(saved_ota_codec_peer_config, ota_codec_peer_config_, 988 sizeof(ota_codec_peer_config_)); 989 990 tA2DP_STATUS status = 991 A2DP_ParseInfoAac(&peer_info_cie, p_peer_codec_info, is_capability); 992 if (status != A2DP_SUCCESS) { 993 LOG_ERROR(LOG_TAG, "%s: can't parse peer's capabilities: error = %d", 994 __func__, status); 995 goto fail; 996 } 997 998 // 999 // Build the preferred configuration 1000 // 1001 memset(&result_config_cie, 0, sizeof(result_config_cie)); 1002 1003 // NOTE: Always assign the Object Type and Variable Bit Rate Support. 1004 result_config_cie.objectType = p_a2dp_aac_caps->objectType; 1005 // The Variable Bit Rate Support is disabled if either side disables it 1006 result_config_cie.variableBitRateSupport = 1007 p_a2dp_aac_caps->variableBitRateSupport & 1008 peer_info_cie.variableBitRateSupport; 1009 1010 // Set the bit rate as follows: 1011 // 1. If the remote device reports a bogus bit rate 1012 // (bitRate < A2DP_AAC_MIN_BITRATE), then use the bit rate from our 1013 // configuration. Examples of observed bogus bit rates are zero 1014 // and 24576. 1015 // 2. If the remote device reports valid bit rate 1016 // (bitRate >= A2DP_AAC_MIN_BITRATE), then use the smaller 1017 // of the remote device's bit rate and the bit rate from our configuration. 1018 // In either case, the actual streaming bit rate will also consider the MTU. 1019 if (peer_info_cie.bitRate < A2DP_AAC_MIN_BITRATE) { 1020 // Bogus bit rate 1021 result_config_cie.bitRate = p_a2dp_aac_caps->bitRate; 1022 } else { 1023 result_config_cie.bitRate = 1024 std::min(p_a2dp_aac_caps->bitRate, peer_info_cie.bitRate); 1025 } 1026 1027 // 1028 // Select the sample frequency 1029 // 1030 sampleRate = p_a2dp_aac_caps->sampleRate & peer_info_cie.sampleRate; 1031 codec_config_.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE; 1032 switch (codec_user_config_.sample_rate) { 1033 case BTAV_A2DP_CODEC_SAMPLE_RATE_44100: 1034 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) { 1035 result_config_cie.sampleRate = A2DP_AAC_SAMPLING_FREQ_44100; 1036 codec_capability_.sample_rate = codec_user_config_.sample_rate; 1037 codec_config_.sample_rate = codec_user_config_.sample_rate; 1038 } 1039 break; 1040 case BTAV_A2DP_CODEC_SAMPLE_RATE_48000: 1041 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) { 1042 result_config_cie.sampleRate = A2DP_AAC_SAMPLING_FREQ_48000; 1043 codec_capability_.sample_rate = codec_user_config_.sample_rate; 1044 codec_config_.sample_rate = codec_user_config_.sample_rate; 1045 } 1046 break; 1047 case BTAV_A2DP_CODEC_SAMPLE_RATE_88200: 1048 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) { 1049 result_config_cie.sampleRate = A2DP_AAC_SAMPLING_FREQ_88200; 1050 codec_capability_.sample_rate = codec_user_config_.sample_rate; 1051 codec_config_.sample_rate = codec_user_config_.sample_rate; 1052 } 1053 break; 1054 case BTAV_A2DP_CODEC_SAMPLE_RATE_96000: 1055 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) { 1056 result_config_cie.sampleRate = A2DP_AAC_SAMPLING_FREQ_96000; 1057 codec_capability_.sample_rate = codec_user_config_.sample_rate; 1058 codec_config_.sample_rate = codec_user_config_.sample_rate; 1059 } 1060 break; 1061 case BTAV_A2DP_CODEC_SAMPLE_RATE_176400: 1062 case BTAV_A2DP_CODEC_SAMPLE_RATE_192000: 1063 case BTAV_A2DP_CODEC_SAMPLE_RATE_16000: 1064 case BTAV_A2DP_CODEC_SAMPLE_RATE_24000: 1065 case BTAV_A2DP_CODEC_SAMPLE_RATE_NONE: 1066 codec_capability_.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE; 1067 codec_config_.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE; 1068 break; 1069 } 1070 1071 // Select the sample frequency if there is no user preference 1072 do { 1073 // Compute the selectable capability 1074 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) { 1075 codec_selectable_capability_.sample_rate |= 1076 BTAV_A2DP_CODEC_SAMPLE_RATE_44100; 1077 } 1078 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) { 1079 codec_selectable_capability_.sample_rate |= 1080 BTAV_A2DP_CODEC_SAMPLE_RATE_48000; 1081 } 1082 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) { 1083 codec_selectable_capability_.sample_rate |= 1084 BTAV_A2DP_CODEC_SAMPLE_RATE_88200; 1085 } 1086 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) { 1087 codec_selectable_capability_.sample_rate |= 1088 BTAV_A2DP_CODEC_SAMPLE_RATE_96000; 1089 } 1090 1091 if (codec_config_.sample_rate != BTAV_A2DP_CODEC_SAMPLE_RATE_NONE) break; 1092 1093 // Compute the common capability 1094 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) 1095 codec_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_44100; 1096 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) 1097 codec_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_48000; 1098 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) 1099 codec_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_88200; 1100 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) 1101 codec_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_96000; 1102 1103 // No user preference - try the codec audio config 1104 if (select_audio_sample_rate(&codec_audio_config_, sampleRate, 1105 &result_config_cie, &codec_config_)) { 1106 break; 1107 } 1108 1109 // No user preference - try the default config 1110 if (select_best_sample_rate( 1111 a2dp_aac_default_config.sampleRate & peer_info_cie.sampleRate, 1112 &result_config_cie, &codec_config_)) { 1113 break; 1114 } 1115 1116 // No user preference - use the best match 1117 if (select_best_sample_rate(sampleRate, &result_config_cie, 1118 &codec_config_)) { 1119 break; 1120 } 1121 } while (false); 1122 if (codec_config_.sample_rate == BTAV_A2DP_CODEC_SAMPLE_RATE_NONE) { 1123 LOG_ERROR(LOG_TAG, 1124 "%s: cannot match sample frequency: source caps = 0x%x " 1125 "peer info = 0x%x", 1126 __func__, p_a2dp_aac_caps->sampleRate, peer_info_cie.sampleRate); 1127 goto fail; 1128 } 1129 1130 // 1131 // Select the bits per sample 1132 // 1133 // NOTE: this information is NOT included in the AAC A2DP codec description 1134 // that is sent OTA. 1135 bits_per_sample = p_a2dp_aac_caps->bits_per_sample; 1136 codec_config_.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE; 1137 switch (codec_user_config_.bits_per_sample) { 1138 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16: 1139 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16) { 1140 result_config_cie.bits_per_sample = codec_user_config_.bits_per_sample; 1141 codec_capability_.bits_per_sample = codec_user_config_.bits_per_sample; 1142 codec_config_.bits_per_sample = codec_user_config_.bits_per_sample; 1143 } 1144 break; 1145 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24: 1146 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24) { 1147 result_config_cie.bits_per_sample = codec_user_config_.bits_per_sample; 1148 codec_capability_.bits_per_sample = codec_user_config_.bits_per_sample; 1149 codec_config_.bits_per_sample = codec_user_config_.bits_per_sample; 1150 } 1151 break; 1152 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32: 1153 if (bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32) { 1154 result_config_cie.bits_per_sample = codec_user_config_.bits_per_sample; 1155 codec_capability_.bits_per_sample = codec_user_config_.bits_per_sample; 1156 codec_config_.bits_per_sample = codec_user_config_.bits_per_sample; 1157 } 1158 break; 1159 case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE: 1160 result_config_cie.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE; 1161 codec_capability_.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE; 1162 codec_config_.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE; 1163 break; 1164 } 1165 1166 // Select the bits per sample if there is no user preference 1167 do { 1168 // Compute the selectable capability 1169 codec_selectable_capability_.bits_per_sample = 1170 p_a2dp_aac_caps->bits_per_sample; 1171 1172 if (codec_config_.bits_per_sample != BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE) 1173 break; 1174 1175 // Compute the common capability 1176 codec_capability_.bits_per_sample = bits_per_sample; 1177 1178 // No user preference - the the codec audio config 1179 if (select_audio_bits_per_sample(&codec_audio_config_, 1180 p_a2dp_aac_caps->bits_per_sample, 1181 &result_config_cie, &codec_config_)) { 1182 break; 1183 } 1184 1185 // No user preference - try the default config 1186 if (select_best_bits_per_sample(a2dp_aac_default_config.bits_per_sample, 1187 &result_config_cie, &codec_config_)) { 1188 break; 1189 } 1190 1191 // No user preference - use the best match 1192 if (select_best_bits_per_sample(p_a2dp_aac_caps->bits_per_sample, 1193 &result_config_cie, &codec_config_)) { 1194 break; 1195 } 1196 } while (false); 1197 if (codec_config_.bits_per_sample == BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE) { 1198 LOG_ERROR(LOG_TAG, 1199 "%s: cannot match bits per sample: default = 0x%x " 1200 "user preference = 0x%x", 1201 __func__, a2dp_aac_default_config.bits_per_sample, 1202 codec_user_config_.bits_per_sample); 1203 goto fail; 1204 } 1205 1206 // 1207 // Select the channel mode 1208 // 1209 channelMode = p_a2dp_aac_caps->channelMode & peer_info_cie.channelMode; 1210 codec_config_.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE; 1211 switch (codec_user_config_.channel_mode) { 1212 case BTAV_A2DP_CODEC_CHANNEL_MODE_MONO: 1213 if (channelMode & A2DP_AAC_CHANNEL_MODE_MONO) { 1214 result_config_cie.channelMode = A2DP_AAC_CHANNEL_MODE_MONO; 1215 codec_capability_.channel_mode = codec_user_config_.channel_mode; 1216 codec_config_.channel_mode = codec_user_config_.channel_mode; 1217 } 1218 break; 1219 case BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO: 1220 if (channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 1221 result_config_cie.channelMode = A2DP_AAC_CHANNEL_MODE_STEREO; 1222 codec_capability_.channel_mode = codec_user_config_.channel_mode; 1223 codec_config_.channel_mode = codec_user_config_.channel_mode; 1224 } 1225 break; 1226 case BTAV_A2DP_CODEC_CHANNEL_MODE_NONE: 1227 codec_capability_.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE; 1228 codec_config_.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE; 1229 break; 1230 } 1231 1232 // Select the channel mode if there is no user preference 1233 do { 1234 // Compute the selectable capability 1235 if (channelMode & A2DP_AAC_CHANNEL_MODE_MONO) { 1236 codec_selectable_capability_.channel_mode |= 1237 BTAV_A2DP_CODEC_CHANNEL_MODE_MONO; 1238 } 1239 if (channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 1240 codec_selectable_capability_.channel_mode |= 1241 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO; 1242 } 1243 1244 if (codec_config_.channel_mode != BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) break; 1245 1246 // Compute the common capability 1247 if (channelMode & A2DP_AAC_CHANNEL_MODE_MONO) 1248 codec_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_MONO; 1249 if (channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 1250 codec_capability_.channel_mode |= BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO; 1251 } 1252 1253 // No user preference - try the codec audio config 1254 if (select_audio_channel_mode(&codec_audio_config_, channelMode, 1255 &result_config_cie, &codec_config_)) { 1256 break; 1257 } 1258 1259 // No user preference - try the default config 1260 if (select_best_channel_mode( 1261 a2dp_aac_default_config.channelMode & peer_info_cie.channelMode, 1262 &result_config_cie, &codec_config_)) { 1263 break; 1264 } 1265 1266 // No user preference - use the best match 1267 if (select_best_channel_mode(channelMode, &result_config_cie, 1268 &codec_config_)) { 1269 break; 1270 } 1271 } while (false); 1272 if (codec_config_.channel_mode == BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) { 1273 LOG_ERROR(LOG_TAG, 1274 "%s: cannot match channel mode: source caps = 0x%x " 1275 "peer info = 0x%x", 1276 __func__, p_a2dp_aac_caps->channelMode, 1277 peer_info_cie.channelMode); 1278 goto fail; 1279 } 1280 1281 if (A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, 1282 p_result_codec_config) != A2DP_SUCCESS) { 1283 goto fail; 1284 } 1285 1286 // 1287 // Copy the codec-specific fields if they are not zero 1288 // 1289 if (codec_user_config_.codec_specific_1 != 0) 1290 codec_config_.codec_specific_1 = codec_user_config_.codec_specific_1; 1291 if (codec_user_config_.codec_specific_2 != 0) 1292 codec_config_.codec_specific_2 = codec_user_config_.codec_specific_2; 1293 if (codec_user_config_.codec_specific_3 != 0) 1294 codec_config_.codec_specific_3 = codec_user_config_.codec_specific_3; 1295 if (codec_user_config_.codec_specific_4 != 0) 1296 codec_config_.codec_specific_4 = codec_user_config_.codec_specific_4; 1297 1298 // Create a local copy of the peer codec capability/config, and the 1299 // result codec config. 1300 if (is_capability) { 1301 status = A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &peer_info_cie, 1302 ota_codec_peer_capability_); 1303 } else { 1304 status = A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &peer_info_cie, 1305 ota_codec_peer_config_); 1306 } 1307 CHECK(status == A2DP_SUCCESS); 1308 status = A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, 1309 ota_codec_config_); 1310 CHECK(status == A2DP_SUCCESS); 1311 return true; 1312 1313fail: 1314 // Restore the internal state 1315 codec_config_ = saved_codec_config; 1316 codec_capability_ = saved_codec_capability; 1317 codec_selectable_capability_ = saved_codec_selectable_capability; 1318 codec_user_config_ = saved_codec_user_config; 1319 codec_audio_config_ = saved_codec_audio_config; 1320 memcpy(ota_codec_config_, saved_ota_codec_config, sizeof(ota_codec_config_)); 1321 memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability, 1322 sizeof(ota_codec_peer_capability_)); 1323 memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config, 1324 sizeof(ota_codec_peer_config_)); 1325 return false; 1326} 1327bool A2dpCodecConfigAacBase::setPeerCodecCapabilities( 1328 const uint8_t* p_peer_codec_capabilities) { 1329 std::lock_guard<std::recursive_mutex> lock(codec_mutex_); 1330 tA2DP_AAC_CIE peer_info_cie; 1331 uint8_t channelMode; 1332 uint16_t sampleRate; 1333 const tA2DP_AAC_CIE* p_a2dp_aac_caps = 1334 (is_source_) ? &a2dp_aac_source_caps : &a2dp_aac_sink_caps; 1335 1336 // Save the internal state 1337 btav_a2dp_codec_config_t saved_codec_selectable_capability = 1338 codec_selectable_capability_; 1339 uint8_t saved_ota_codec_peer_capability[AVDT_CODEC_SIZE]; 1340 memcpy(saved_ota_codec_peer_capability, ota_codec_peer_capability_, 1341 sizeof(ota_codec_peer_capability_)); 1342 1343 tA2DP_STATUS status = 1344 A2DP_ParseInfoAac(&peer_info_cie, p_peer_codec_capabilities, true); 1345 if (status != A2DP_SUCCESS) { 1346 LOG_ERROR(LOG_TAG, "%s: can't parse peer's capabilities: error = %d", 1347 __func__, status); 1348 goto fail; 1349 } 1350 1351 // Compute the selectable capability - sample rate 1352 sampleRate = p_a2dp_aac_caps->sampleRate & peer_info_cie.sampleRate; 1353 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) { 1354 codec_selectable_capability_.sample_rate |= 1355 BTAV_A2DP_CODEC_SAMPLE_RATE_44100; 1356 } 1357 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) { 1358 codec_selectable_capability_.sample_rate |= 1359 BTAV_A2DP_CODEC_SAMPLE_RATE_48000; 1360 } 1361 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) { 1362 codec_selectable_capability_.sample_rate |= 1363 BTAV_A2DP_CODEC_SAMPLE_RATE_88200; 1364 } 1365 if (sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) { 1366 codec_selectable_capability_.sample_rate |= 1367 BTAV_A2DP_CODEC_SAMPLE_RATE_96000; 1368 } 1369 1370 // Compute the selectable capability - bits per sample 1371 codec_selectable_capability_.bits_per_sample = 1372 p_a2dp_aac_caps->bits_per_sample; 1373 1374 // Compute the selectable capability - channel mode 1375 channelMode = p_a2dp_aac_caps->channelMode & peer_info_cie.channelMode; 1376 if (channelMode & A2DP_AAC_CHANNEL_MODE_MONO) { 1377 codec_selectable_capability_.channel_mode |= 1378 BTAV_A2DP_CODEC_CHANNEL_MODE_MONO; 1379 } 1380 if (channelMode & A2DP_AAC_CHANNEL_MODE_STEREO) { 1381 codec_selectable_capability_.channel_mode |= 1382 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO; 1383 } 1384 1385 status = A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &peer_info_cie, 1386 ota_codec_peer_capability_); 1387 CHECK(status == A2DP_SUCCESS); 1388 return true; 1389 1390fail: 1391 // Restore the internal state 1392 codec_selectable_capability_ = saved_codec_selectable_capability; 1393 memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability, 1394 sizeof(ota_codec_peer_capability_)); 1395 return false; 1396} 1397 1398A2dpCodecConfigAacSink::A2dpCodecConfigAacSink( 1399 btav_a2dp_codec_priority_t codec_priority) 1400 : A2dpCodecConfigAacBase(BTAV_A2DP_CODEC_INDEX_SINK_AAC, 1401 A2DP_CodecIndexStrAacSink(), codec_priority, 1402 false) {} 1403 1404A2dpCodecConfigAacSink::~A2dpCodecConfigAacSink() {} 1405 1406bool A2dpCodecConfigAacSink::init() { 1407 if (!isValid()) return false; 1408 1409 // Load the decoder 1410 if (!A2DP_LoadDecoderAac()) { 1411 LOG_ERROR(LOG_TAG, "%s: cannot load the decoder", __func__); 1412 return false; 1413 } 1414 1415 return true; 1416} 1417 1418period_ms_t A2dpCodecConfigAacSink::encoderIntervalMs() const { 1419 // TODO: This method applies only to Source codecs 1420 return 0; 1421} 1422 1423int A2dpCodecConfigAacSink::getEffectiveMtu() const { 1424 // TODO: This method applies only to Source codecs 1425 return 0; 1426} 1427 1428bool A2dpCodecConfigAacSink::useRtpHeaderMarkerBit() const { 1429 // TODO: This method applies only to Source codecs 1430 return false; 1431} 1432 1433bool A2dpCodecConfigAacSink::updateEncoderUserConfig( 1434 UNUSED_ATTR const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, 1435 UNUSED_ATTR bool* p_restart_input, UNUSED_ATTR bool* p_restart_output, 1436 UNUSED_ATTR bool* p_config_updated) { 1437 // TODO: This method applies only to Source codecs 1438 return false; 1439} 1440