1 /* 2 * Copyright (C) 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 #define LOG_TAG "a2dp_aac_encoder" 18 19 #include "a2dp_aac_encoder.h" 20 21 #include <inttypes.h> 22 #include <stdio.h> 23 #include <string.h> 24 25 #include <aacenc_lib.h> 26 #include <base/logging.h> 27 28 #include "a2dp_aac.h" 29 #include "bt_common.h" 30 #include "osi/include/log.h" 31 #include "osi/include/osi.h" 32 33 // 34 // Encoder for AAC Source Codec 35 // 36 37 // A2DP AAC encoder interval in milliseconds 38 #define A2DP_AAC_ENCODER_INTERVAL_MS 20 39 40 // offset 41 #if (BTA_AV_CO_CP_SCMS_T == TRUE) 42 #define A2DP_AAC_OFFSET (AVDT_MEDIA_OFFSET + 1) 43 #else 44 #define A2DP_AAC_OFFSET AVDT_MEDIA_OFFSET 45 #endif 46 47 typedef struct { 48 uint32_t sample_rate; 49 uint8_t channel_mode; 50 uint8_t bits_per_sample; 51 uint32_t frame_length; // Samples per channel in a frame 52 uint8_t input_channels_n; // Number of channels 53 int max_encoded_buffer_bytes; // Max encoded bytes per frame 54 } tA2DP_AAC_ENCODER_PARAMS; 55 56 typedef struct { 57 uint32_t counter; 58 uint32_t bytes_per_tick; /* pcm bytes read each media task tick */ 59 uint64_t last_frame_us; 60 } tA2DP_AAC_FEEDING_STATE; 61 62 typedef struct { 63 uint64_t session_start_us; 64 65 size_t media_read_total_expected_packets; 66 size_t media_read_total_expected_reads_count; 67 size_t media_read_total_expected_read_bytes; 68 69 size_t media_read_total_dropped_packets; 70 size_t media_read_total_actual_reads_count; 71 size_t media_read_total_actual_read_bytes; 72 } a2dp_aac_encoder_stats_t; 73 74 typedef struct { 75 a2dp_source_read_callback_t read_callback; 76 a2dp_source_enqueue_callback_t enqueue_callback; 77 uint16_t TxAaMtuSize; 78 79 bool use_SCMS_T; 80 bool is_peer_edr; // True if the peer device supports EDR 81 bool peer_supports_3mbps; // True if the peer device supports 3Mbps EDR 82 uint16_t peer_mtu; // MTU of the A2DP peer 83 uint32_t timestamp; // Timestamp for the A2DP frames 84 85 HANDLE_AACENCODER aac_handle; 86 bool has_aac_handle; // True if aac_handle is valid 87 88 tA2DP_FEEDING_PARAMS feeding_params; 89 tA2DP_AAC_ENCODER_PARAMS aac_encoder_params; 90 tA2DP_AAC_FEEDING_STATE aac_feeding_state; 91 92 a2dp_aac_encoder_stats_t stats; 93 } tA2DP_AAC_ENCODER_CB; 94 95 static tA2DP_AAC_ENCODER_CB a2dp_aac_encoder_cb; 96 97 static void a2dp_aac_encoder_update(uint16_t peer_mtu, 98 A2dpCodecConfig* a2dp_codec_config, 99 bool* p_restart_input, 100 bool* p_restart_output, 101 bool* p_config_updated); 102 static void a2dp_aac_get_num_frame_iteration(uint8_t* num_of_iterations, 103 uint8_t* num_of_frames, 104 uint64_t timestamp_us); 105 static void a2dp_aac_encode_frames(uint8_t nb_frame); 106 static bool a2dp_aac_read_feeding(uint8_t* read_buffer); 107 108 bool A2DP_LoadEncoderAac(void) { 109 // Nothing to do - the library is statically linked 110 return true; 111 } 112 113 void A2DP_UnloadEncoderAac(void) { 114 // Nothing to do - the library is statically linked 115 if (a2dp_aac_encoder_cb.has_aac_handle) 116 aacEncClose(&a2dp_aac_encoder_cb.aac_handle); 117 memset(&a2dp_aac_encoder_cb, 0, sizeof(a2dp_aac_encoder_cb)); 118 } 119 120 void a2dp_aac_encoder_init(const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, 121 A2dpCodecConfig* a2dp_codec_config, 122 a2dp_source_read_callback_t read_callback, 123 a2dp_source_enqueue_callback_t enqueue_callback) { 124 if (a2dp_aac_encoder_cb.has_aac_handle) 125 aacEncClose(&a2dp_aac_encoder_cb.aac_handle); 126 memset(&a2dp_aac_encoder_cb, 0, sizeof(a2dp_aac_encoder_cb)); 127 128 a2dp_aac_encoder_cb.stats.session_start_us = time_get_os_boottime_us(); 129 130 a2dp_aac_encoder_cb.read_callback = read_callback; 131 a2dp_aac_encoder_cb.enqueue_callback = enqueue_callback; 132 a2dp_aac_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr; 133 a2dp_aac_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps; 134 a2dp_aac_encoder_cb.peer_mtu = p_peer_params->peer_mtu; 135 a2dp_aac_encoder_cb.timestamp = 0; 136 137 a2dp_aac_encoder_cb.use_SCMS_T = false; // TODO: should be a parameter 138 #if (BTA_AV_CO_CP_SCMS_T == TRUE) 139 a2dp_aac_encoder_cb.use_SCMS_T = true; 140 #endif 141 142 // NOTE: Ignore the restart_input / restart_output flags - this initization 143 // happens when the connection is (re)started. 144 bool restart_input = false; 145 bool restart_output = false; 146 bool config_updated = false; 147 a2dp_aac_encoder_update(a2dp_aac_encoder_cb.peer_mtu, a2dp_codec_config, 148 &restart_input, &restart_output, &config_updated); 149 } 150 151 bool A2dpCodecConfigAac::updateEncoderUserConfig( 152 const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, bool* p_restart_input, 153 bool* p_restart_output, bool* p_config_updated) { 154 a2dp_aac_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr; 155 a2dp_aac_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps; 156 a2dp_aac_encoder_cb.peer_mtu = p_peer_params->peer_mtu; 157 a2dp_aac_encoder_cb.timestamp = 0; 158 159 if (a2dp_aac_encoder_cb.peer_mtu == 0) { 160 LOG_ERROR(LOG_TAG, 161 "%s: Cannot update the codec encoder for %s: " 162 "invalid peer MTU", 163 __func__, name().c_str()); 164 return false; 165 } 166 167 a2dp_aac_encoder_update(a2dp_aac_encoder_cb.peer_mtu, this, p_restart_input, 168 p_restart_output, p_config_updated); 169 return true; 170 } 171 172 // Update the A2DP AAC encoder. 173 // |peer_mtu| is the peer MTU. 174 // |a2dp_codec_config| is the A2DP codec to use for the update. 175 static void a2dp_aac_encoder_update(uint16_t peer_mtu, 176 A2dpCodecConfig* a2dp_codec_config, 177 bool* p_restart_input, 178 bool* p_restart_output, 179 bool* p_config_updated) { 180 tA2DP_AAC_ENCODER_PARAMS* p_encoder_params = 181 &a2dp_aac_encoder_cb.aac_encoder_params; 182 uint8_t codec_info[AVDT_CODEC_SIZE]; 183 AACENC_ERROR aac_error; 184 int aac_param_value, aac_sampling_freq, aac_peak_bit_rate; 185 186 *p_restart_input = false; 187 *p_restart_output = false; 188 *p_config_updated = false; 189 190 if (!a2dp_aac_encoder_cb.has_aac_handle) { 191 AACENC_ERROR aac_error = aacEncOpen(&a2dp_aac_encoder_cb.aac_handle, 0, 192 2 /* max 2 channels: stereo */); 193 if (aac_error != AACENC_OK) { 194 LOG_ERROR(LOG_TAG, "%s: Cannot open AAC encoder handle: AAC error 0x%x", 195 __func__, aac_error); 196 return; // TODO: Return an error? 197 } 198 a2dp_aac_encoder_cb.has_aac_handle = true; 199 } 200 201 if (!a2dp_codec_config->copyOutOtaCodecConfig(codec_info)) { 202 LOG_ERROR(LOG_TAG, 203 "%s: Cannot update the codec encoder for %s: " 204 "invalid codec config", 205 __func__, a2dp_codec_config->name().c_str()); 206 return; 207 } 208 const uint8_t* p_codec_info = codec_info; 209 210 // The feeding parameters 211 tA2DP_FEEDING_PARAMS* p_feeding_params = &a2dp_aac_encoder_cb.feeding_params; 212 p_feeding_params->sample_rate = A2DP_GetTrackSampleRateAac(p_codec_info); 213 p_feeding_params->bits_per_sample = 214 a2dp_codec_config->getAudioBitsPerSample(); 215 p_feeding_params->channel_count = A2DP_GetTrackChannelCountAac(p_codec_info); 216 LOG_DEBUG(LOG_TAG, "%s: sample_rate=%u bits_per_sample=%u channel_count=%u", 217 __func__, p_feeding_params->sample_rate, 218 p_feeding_params->bits_per_sample, p_feeding_params->channel_count); 219 220 // The codec parameters 221 p_encoder_params->sample_rate = 222 a2dp_aac_encoder_cb.feeding_params.sample_rate; 223 p_encoder_params->channel_mode = A2DP_GetChannelModeCodeAac(p_codec_info); 224 225 uint16_t mtu_size = BT_DEFAULT_BUFFER_SIZE - A2DP_AAC_OFFSET - sizeof(BT_HDR); 226 if (mtu_size < peer_mtu) { 227 a2dp_aac_encoder_cb.TxAaMtuSize = mtu_size; 228 } else { 229 a2dp_aac_encoder_cb.TxAaMtuSize = peer_mtu; 230 } 231 232 LOG_DEBUG(LOG_TAG, "%s: MTU=%d, peer_mtu=%d", __func__, 233 a2dp_aac_encoder_cb.TxAaMtuSize, peer_mtu); 234 LOG_DEBUG(LOG_TAG, "%s: sample_rate: %d channel_mode: %d ", __func__, 235 p_encoder_params->sample_rate, p_encoder_params->channel_mode); 236 237 // Set the encoder's parameters: Audio Object Type - MANDATORY 238 // A2DP_AAC_OBJECT_TYPE_MPEG2_LC -> AOT_AAC_LC 239 // A2DP_AAC_OBJECT_TYPE_MPEG4_LC -> AOT_AAC_LC 240 // A2DP_AAC_OBJECT_TYPE_MPEG4_LTP -> AOT_AAC_LTP 241 // A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE -> AOT_AAC_SCAL 242 aac_param_value = AOT_AAC_LC; 243 int object_type = A2DP_GetObjectTypeCodeAac(p_codec_info); 244 switch (object_type) { 245 case A2DP_AAC_OBJECT_TYPE_MPEG2_LC: 246 aac_param_value = AOT_AAC_LC; 247 break; 248 case A2DP_AAC_OBJECT_TYPE_MPEG4_LC: 249 aac_param_value = AOT_AAC_LC; 250 break; 251 case A2DP_AAC_OBJECT_TYPE_MPEG4_LTP: 252 aac_param_value = AOT_AAC_LTP; 253 break; 254 case A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE: 255 aac_param_value = AOT_AAC_SCAL; 256 break; 257 default: 258 LOG_ERROR(LOG_TAG, 259 "%s: Cannot set AAC parameter AACENC_AOT: " 260 "invalid object type %d", 261 __func__, object_type); 262 return; // TODO: Return an error? 263 } 264 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, AACENC_AOT, 265 aac_param_value); 266 if (aac_error != AACENC_OK) { 267 LOG_ERROR(LOG_TAG, 268 "%s: Cannot set AAC parameter AACENC_AOT to %d: " 269 "AAC error 0x%x", 270 __func__, aac_param_value, aac_error); 271 return; // TODO: Return an error? 272 } 273 274 // Set the encoder's parameters: audioMuxVersion 275 aac_param_value = 2; // audioMuxVersion = "2" 276 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 277 AACENC_AUDIOMUXVER, aac_param_value); 278 if (aac_error != AACENC_OK) { 279 LOG_ERROR(LOG_TAG, 280 "%s: Cannot set AAC parameter AACENC_AUDIOMUXVER to %d: " 281 "AAC error 0x%x", 282 __func__, aac_param_value, aac_error); 283 return; // TODO: Return an error? 284 } 285 286 // Set the encoder's parameters: Signaling mode of the extension AOT 287 aac_param_value = 1; // Signaling mode of the extension AOT = 1 288 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 289 AACENC_SIGNALING_MODE, aac_param_value); 290 if (aac_error != AACENC_OK) { 291 LOG_ERROR(LOG_TAG, 292 "%s: Cannot set AAC parameter AACENC_SIGNALING_MODE to %d: " 293 "AAC error 0x%x", 294 __func__, aac_param_value, aac_error); 295 return; // TODO: Return an error? 296 } 297 298 // Set the encoder's parameters: Sample Rate - MANDATORY 299 aac_param_value = A2DP_GetTrackSampleRateAac(p_codec_info); 300 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 301 AACENC_SAMPLERATE, aac_param_value); 302 if (aac_error != AACENC_OK) { 303 LOG_ERROR(LOG_TAG, 304 "%s: Cannot set AAC parameter AACENC_SAMPLERATE to %d: " 305 "AAC error 0x%x", 306 __func__, aac_param_value, aac_error); 307 return; // TODO: Return an error? 308 } 309 aac_sampling_freq = aac_param_value; // Save for extra usage below 310 311 // Set the encoder's parameters: Bit Rate - MANDATORY 312 aac_param_value = A2DP_GetBitRateAac(p_codec_info); 313 // Calculate the bit rate from MTU and sampling frequency 314 aac_peak_bit_rate = 315 A2DP_ComputeMaxBitRateAac(p_codec_info, a2dp_aac_encoder_cb.TxAaMtuSize); 316 aac_param_value = std::min(aac_param_value, aac_peak_bit_rate); 317 LOG_DEBUG(LOG_TAG, "%s: MTU = %d Sampling Frequency = %d Bit Rate = %d", 318 __func__, a2dp_aac_encoder_cb.TxAaMtuSize, aac_sampling_freq, 319 aac_param_value); 320 if (aac_param_value == -1) { 321 LOG_ERROR(LOG_TAG, 322 "%s: Cannot set AAC parameter AACENC_BITRATE: " 323 "invalid codec bit rate", 324 __func__); 325 return; // TODO: Return an error? 326 } 327 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 328 AACENC_BITRATE, aac_param_value); 329 if (aac_error != AACENC_OK) { 330 LOG_ERROR(LOG_TAG, 331 "%s: Cannot set AAC parameter AACENC_BITRATE to %d: " 332 "AAC error 0x%x", 333 __func__, aac_param_value, aac_error); 334 return; // TODO: Return an error? 335 } 336 337 // Set the encoder's parameters: PEAK Bit Rate 338 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 339 AACENC_PEAK_BITRATE, aac_peak_bit_rate); 340 if (aac_error != AACENC_OK) { 341 LOG_ERROR(LOG_TAG, 342 "%s: Cannot set AAC parameter AACENC_PEAK_BITRATE to %d: " 343 "AAC error 0x%x", 344 __func__, aac_peak_bit_rate, aac_error); 345 return; // TODO: Return an error? 346 } 347 348 // Set the encoder's parameters: Channel Mode - MANDATORY 349 if (A2DP_GetTrackChannelCountAac(p_codec_info) == 1) { 350 aac_param_value = MODE_1; // Mono 351 } else { 352 aac_param_value = MODE_2; // Stereo 353 } 354 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 355 AACENC_CHANNELMODE, aac_param_value); 356 if (aac_error != AACENC_OK) { 357 LOG_ERROR(LOG_TAG, 358 "%s: Cannot set AAC parameter AACENC_CHANNELMODE to %d: " 359 "AAC error 0x%x", 360 __func__, aac_param_value, aac_error); 361 return; // TODO: Return an error? 362 } 363 364 // Set the encoder's parameters: Transport Type 365 aac_param_value = TT_MP4_LATM_MCP1; // muxConfigPresent = 1 366 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 367 AACENC_TRANSMUX, aac_param_value); 368 if (aac_error != AACENC_OK) { 369 LOG_ERROR(LOG_TAG, 370 "%s: Cannot set AAC parameter AACENC_TRANSMUX to %d: " 371 "AAC error 0x%x", 372 __func__, aac_param_value, aac_error); 373 return; // TODO: Return an error? 374 } 375 376 // Set the encoder's parameters: Header Period 377 aac_param_value = 1; 378 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 379 AACENC_HEADER_PERIOD, aac_param_value); 380 if (aac_error != AACENC_OK) { 381 LOG_ERROR(LOG_TAG, 382 "%s: Cannot set AAC parameter AACENC_HEADER_PERIOD to %d: " 383 "AAC error 0x%x", 384 __func__, aac_param_value, aac_error); 385 return; // TODO: Return an error? 386 } 387 388 // Set the encoder's parameters: Variable Bit Rate Support 389 aac_param_value = A2DP_GetVariableBitRateSupportAac(p_codec_info); 390 if (aac_param_value == -1) { 391 LOG_ERROR(LOG_TAG, 392 "%s: Cannot set AAC parameter AACENC_BITRATEMODE: " 393 "invalid codec bit rate mode", 394 __func__); 395 return; // TODO: Return an error? 396 } 397 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, 398 AACENC_BITRATEMODE, aac_param_value); 399 if (aac_error != AACENC_OK) { 400 LOG_ERROR(LOG_TAG, 401 "%s: Cannot set AAC parameter AACENC_BITRATEMODE to %d: " 402 "AAC error 0x%x", 403 __func__, aac_param_value, aac_error); 404 return; // TODO: Return an error? 405 } 406 407 // Mark the end of setting the encoder's parameters 408 aac_error = 409 aacEncEncode(a2dp_aac_encoder_cb.aac_handle, NULL, NULL, NULL, NULL); 410 if (aac_error != AACENC_OK) { 411 LOG_ERROR(LOG_TAG, 412 "%s: Cannot complete setting the AAC parameters: AAC error 0x%x", 413 __func__, aac_error); 414 return; // TODO: Return an error? 415 } 416 417 // Retrieve the encoder info so we can save the frame length 418 AACENC_InfoStruct aac_info; 419 aac_error = aacEncInfo(a2dp_aac_encoder_cb.aac_handle, &aac_info); 420 if (aac_error != AACENC_OK) { 421 LOG_ERROR(LOG_TAG, 422 "%s: Cannot retrieve the AAC encoder info: AAC error 0x%x", 423 __func__, aac_error); 424 return; // TODO: Return an error? 425 } 426 p_encoder_params->frame_length = aac_info.frameLength; 427 p_encoder_params->input_channels_n = aac_info.inputChannels; 428 p_encoder_params->max_encoded_buffer_bytes = aac_info.maxOutBufBytes; 429 LOG_DEBUG(LOG_TAG, 430 "%s: AAC frame_length = %u input_channels_n = %u " 431 "max_encoded_buffer_bytes = %d", 432 __func__, p_encoder_params->frame_length, 433 p_encoder_params->input_channels_n, 434 p_encoder_params->max_encoded_buffer_bytes); 435 } 436 437 void a2dp_aac_encoder_cleanup(void) { 438 if (a2dp_aac_encoder_cb.has_aac_handle) 439 aacEncClose(&a2dp_aac_encoder_cb.aac_handle); 440 memset(&a2dp_aac_encoder_cb, 0, sizeof(a2dp_aac_encoder_cb)); 441 } 442 443 void a2dp_aac_feeding_reset(void) { 444 /* By default, just clear the entire state */ 445 memset(&a2dp_aac_encoder_cb.aac_feeding_state, 0, 446 sizeof(a2dp_aac_encoder_cb.aac_feeding_state)); 447 448 a2dp_aac_encoder_cb.aac_feeding_state.bytes_per_tick = 449 (a2dp_aac_encoder_cb.feeding_params.sample_rate * 450 a2dp_aac_encoder_cb.feeding_params.bits_per_sample / 8 * 451 a2dp_aac_encoder_cb.feeding_params.channel_count * 452 A2DP_AAC_ENCODER_INTERVAL_MS) / 453 1000; 454 455 LOG_DEBUG(LOG_TAG, "%s: PCM bytes per tick %u", __func__, 456 a2dp_aac_encoder_cb.aac_feeding_state.bytes_per_tick); 457 } 458 459 void a2dp_aac_feeding_flush(void) { 460 a2dp_aac_encoder_cb.aac_feeding_state.counter = 0; 461 } 462 463 period_ms_t a2dp_aac_get_encoder_interval_ms(void) { 464 return A2DP_AAC_ENCODER_INTERVAL_MS; 465 } 466 467 void a2dp_aac_send_frames(uint64_t timestamp_us) { 468 uint8_t nb_frame = 0; 469 uint8_t nb_iterations = 0; 470 471 a2dp_aac_get_num_frame_iteration(&nb_iterations, &nb_frame, timestamp_us); 472 LOG_VERBOSE(LOG_TAG, "%s: Sending %d frames per iteration, %d iterations", 473 __func__, nb_frame, nb_iterations); 474 if (nb_frame == 0) return; 475 476 for (uint8_t counter = 0; counter < nb_iterations; counter++) { 477 // Transcode frame and enqueue 478 a2dp_aac_encode_frames(nb_frame); 479 } 480 } 481 482 // Obtains the number of frames to send and number of iterations 483 // to be used. |num_of_iterations| and |num_of_frames| parameters 484 // are used as output param for returning the respective values. 485 static void a2dp_aac_get_num_frame_iteration(uint8_t* num_of_iterations, 486 uint8_t* num_of_frames, 487 uint64_t timestamp_us) { 488 uint32_t result = 0; 489 uint8_t nof = 0; 490 uint8_t noi = 1; 491 492 uint32_t pcm_bytes_per_frame = 493 a2dp_aac_encoder_cb.aac_encoder_params.frame_length * 494 a2dp_aac_encoder_cb.feeding_params.channel_count * 495 a2dp_aac_encoder_cb.feeding_params.bits_per_sample / 8; 496 LOG_VERBOSE(LOG_TAG, "%s: pcm_bytes_per_frame %u", __func__, 497 pcm_bytes_per_frame); 498 499 uint32_t us_this_tick = A2DP_AAC_ENCODER_INTERVAL_MS * 1000; 500 uint64_t now_us = timestamp_us; 501 if (a2dp_aac_encoder_cb.aac_feeding_state.last_frame_us != 0) 502 us_this_tick = 503 (now_us - a2dp_aac_encoder_cb.aac_feeding_state.last_frame_us); 504 a2dp_aac_encoder_cb.aac_feeding_state.last_frame_us = now_us; 505 506 a2dp_aac_encoder_cb.aac_feeding_state.counter += 507 a2dp_aac_encoder_cb.aac_feeding_state.bytes_per_tick * us_this_tick / 508 (A2DP_AAC_ENCODER_INTERVAL_MS * 1000); 509 510 result = a2dp_aac_encoder_cb.aac_feeding_state.counter / pcm_bytes_per_frame; 511 a2dp_aac_encoder_cb.aac_feeding_state.counter -= result * pcm_bytes_per_frame; 512 nof = result; 513 514 LOG_VERBOSE(LOG_TAG, "%s: effective num of frames %u, iterations %u", 515 __func__, nof, noi); 516 517 *num_of_frames = nof; 518 *num_of_iterations = noi; 519 } 520 521 static void a2dp_aac_encode_frames(uint8_t nb_frame) { 522 tA2DP_AAC_ENCODER_PARAMS* p_encoder_params = 523 &a2dp_aac_encoder_cb.aac_encoder_params; 524 tA2DP_FEEDING_PARAMS* p_feeding_params = &a2dp_aac_encoder_cb.feeding_params; 525 uint8_t remain_nb_frame = nb_frame; 526 uint8_t read_buffer[BT_DEFAULT_BUFFER_SIZE]; 527 int pcm_bytes_per_frame = p_encoder_params->frame_length * 528 p_feeding_params->channel_count * 529 p_feeding_params->bits_per_sample / 8; 530 CHECK(pcm_bytes_per_frame <= static_cast<int>(sizeof(read_buffer))); 531 532 // Setup the input buffer 533 AACENC_BufDesc in_buf_desc; 534 void* in_buf_vector[1] = {nullptr}; 535 int in_buf_identifiers[1] = {IN_AUDIO_DATA}; 536 int in_buf_sizes[1] = {pcm_bytes_per_frame}; 537 int in_buf_element_sizes[1] = {p_feeding_params->bits_per_sample / 8}; 538 in_buf_desc.numBufs = 1; 539 in_buf_desc.bufs = in_buf_vector; 540 in_buf_desc.bufferIdentifiers = in_buf_identifiers; 541 in_buf_desc.bufSizes = in_buf_sizes; 542 in_buf_desc.bufElSizes = in_buf_element_sizes; 543 544 // Setup the output buffer (partially) 545 AACENC_BufDesc out_buf_desc; 546 void* out_buf_vector[1] = {nullptr}; 547 int out_buf_identifiers[1] = {OUT_BITSTREAM_DATA}; 548 int out_buf_sizes[1] = {p_encoder_params->max_encoded_buffer_bytes}; 549 // NOTE: out_buf_element_sizes below is probably unused by the encoder 550 int out_buf_element_sizes[1] = {p_feeding_params->bits_per_sample / 8}; 551 out_buf_desc.numBufs = 1; 552 out_buf_desc.bufs = out_buf_vector; 553 out_buf_desc.bufferIdentifiers = out_buf_identifiers; 554 out_buf_desc.bufSizes = out_buf_sizes; 555 out_buf_desc.bufElSizes = out_buf_element_sizes; 556 CHECK(p_encoder_params->max_encoded_buffer_bytes <= 557 static_cast<int>(BT_DEFAULT_BUFFER_SIZE - sizeof(BT_HDR))); 558 559 AACENC_InArgs aac_in_args; 560 aac_in_args.numInSamples = 561 p_encoder_params->frame_length * p_feeding_params->channel_count; 562 aac_in_args.numAncBytes = 0; 563 564 AACENC_OutArgs aac_out_args = { 565 .numOutBytes = 0, .numInSamples = 0, .numAncBytes = 0}; 566 567 uint32_t count; 568 int written = 0; 569 570 while (nb_frame) { 571 BT_HDR* p_buf = (BT_HDR*)osi_malloc(BT_DEFAULT_BUFFER_SIZE); 572 p_buf->offset = A2DP_AAC_OFFSET; 573 p_buf->len = 0; 574 p_buf->layer_specific = 0; 575 a2dp_aac_encoder_cb.stats.media_read_total_expected_packets++; 576 577 count = 0; 578 do { 579 // 580 // Read the PCM data and encode it 581 // 582 if (a2dp_aac_read_feeding(read_buffer)) { 583 uint8_t* packet = (uint8_t*)(p_buf + 1) + p_buf->offset + p_buf->len; 584 if (!a2dp_aac_encoder_cb.has_aac_handle) { 585 LOG_ERROR(LOG_TAG, "%s: invalid AAC handle", __func__); 586 a2dp_aac_encoder_cb.stats.media_read_total_dropped_packets++; 587 osi_free(p_buf); 588 return; 589 } 590 in_buf_vector[0] = read_buffer; 591 out_buf_vector[0] = packet + count; 592 AACENC_ERROR aac_error = 593 aacEncEncode(a2dp_aac_encoder_cb.aac_handle, &in_buf_desc, 594 &out_buf_desc, &aac_in_args, &aac_out_args); 595 if (aac_error != AACENC_OK) { 596 LOG_ERROR(LOG_TAG, "%s: AAC encoding error: 0x%x", __func__, 597 aac_error); 598 a2dp_aac_encoder_cb.stats.media_read_total_dropped_packets++; 599 osi_free(p_buf); 600 return; 601 } 602 written = aac_out_args.numOutBytes; 603 count += written; 604 p_buf->len += written; 605 nb_frame--; 606 p_buf->layer_specific++; // added a frame to the buffer 607 } else { 608 LOG_WARN(LOG_TAG, "%s: underflow %d", __func__, nb_frame); 609 a2dp_aac_encoder_cb.aac_feeding_state.counter += 610 nb_frame * p_encoder_params->frame_length * 611 p_feeding_params->channel_count * 612 p_feeding_params->bits_per_sample / 8; 613 614 // no more pcm to read 615 nb_frame = 0; 616 } 617 } while ((written == 0) && nb_frame); 618 619 // NOTE: We don't check whether the packet will fit in the MTU, 620 // because AAC doesn't give us control over the encoded frame size. 621 // If the packet is larger than the MTU, it will be fragmented before 622 // transmission. 623 if (p_buf->len) { 624 /* 625 * Timestamp of the media packet header represent the TS of the 626 * first frame, i.e the timestamp before including this frame. 627 */ 628 *((uint32_t*)(p_buf + 1)) = a2dp_aac_encoder_cb.timestamp; 629 630 a2dp_aac_encoder_cb.timestamp += 631 p_buf->layer_specific * p_encoder_params->frame_length; 632 633 uint8_t done_nb_frame = remain_nb_frame - nb_frame; 634 remain_nb_frame = nb_frame; 635 if (!a2dp_aac_encoder_cb.enqueue_callback(p_buf, done_nb_frame)) return; 636 } else { 637 a2dp_aac_encoder_cb.stats.media_read_total_dropped_packets++; 638 osi_free(p_buf); 639 } 640 } 641 } 642 643 static bool a2dp_aac_read_feeding(uint8_t* read_buffer) { 644 uint32_t read_size = a2dp_aac_encoder_cb.aac_encoder_params.frame_length * 645 a2dp_aac_encoder_cb.feeding_params.channel_count * 646 a2dp_aac_encoder_cb.feeding_params.bits_per_sample / 8; 647 648 a2dp_aac_encoder_cb.stats.media_read_total_expected_reads_count++; 649 a2dp_aac_encoder_cb.stats.media_read_total_expected_read_bytes += read_size; 650 651 /* Read Data from UIPC channel */ 652 uint32_t nb_byte_read = 653 a2dp_aac_encoder_cb.read_callback(read_buffer, read_size); 654 a2dp_aac_encoder_cb.stats.media_read_total_actual_read_bytes += nb_byte_read; 655 656 if (nb_byte_read < read_size) { 657 if (nb_byte_read == 0) return false; 658 659 /* Fill the unfilled part of the read buffer with silence (0) */ 660 memset(((uint8_t*)read_buffer) + nb_byte_read, 0, read_size - nb_byte_read); 661 nb_byte_read = read_size; 662 } 663 a2dp_aac_encoder_cb.stats.media_read_total_actual_reads_count++; 664 665 return true; 666 } 667 668 period_ms_t A2dpCodecConfigAac::encoderIntervalMs() const { 669 return a2dp_aac_get_encoder_interval_ms(); 670 } 671 672 void A2dpCodecConfigAac::debug_codec_dump(int fd) { 673 a2dp_aac_encoder_stats_t* stats = &a2dp_aac_encoder_cb.stats; 674 675 A2dpCodecConfig::debug_codec_dump(fd); 676 677 dprintf(fd, 678 " Packet counts (expected/dropped) : %zu / " 679 "%zu\n", 680 stats->media_read_total_expected_packets, 681 stats->media_read_total_dropped_packets); 682 683 dprintf(fd, 684 " PCM read counts (expected/actual) : %zu / " 685 "%zu\n", 686 stats->media_read_total_expected_reads_count, 687 stats->media_read_total_actual_reads_count); 688 689 dprintf(fd, 690 " PCM read bytes (expected/actual) : %zu / " 691 "%zu\n", 692 stats->media_read_total_expected_read_bytes, 693 stats->media_read_total_actual_read_bytes); 694 } 695
