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 #define LOG_TAG "a2dp_vendor_ldac_encoder" 18 #define ATRACE_TAG ATRACE_TAG_AUDIO 19 20 #include "a2dp_vendor_ldac_encoder.h" 21 22 #ifndef OS_GENERIC 23 #include <cutils/trace.h> 24 #endif 25 #include <dlfcn.h> 26 #include <inttypes.h> 27 #include <stdio.h> 28 #include <string.h> 29 30 #include <ldacBT.h> 31 32 #include "a2dp_vendor.h" 33 #include "a2dp_vendor_ldac.h" 34 #include "a2dp_vendor_ldac_abr.h" 35 #include "bt_common.h" 36 #include "osi/include/log.h" 37 #include "osi/include/osi.h" 38 39 // 40 // Encoder for LDAC Source Codec 41 // 42 43 // 44 // The LDAC encoder shared library, and the functions to use 45 // 46 static const char* LDAC_ENCODER_LIB_NAME = "libldacBT_enc.so"; 47 static void* ldac_encoder_lib_handle = NULL; 48 49 static const char* LDAC_GET_HANDLE_NAME = "ldacBT_get_handle"; 50 typedef HANDLE_LDAC_BT (*tLDAC_GET_HANDLE)(void); 51 52 static const char* LDAC_FREE_HANDLE_NAME = "ldacBT_free_handle"; 53 typedef void (*tLDAC_FREE_HANDLE)(HANDLE_LDAC_BT hLdacParam); 54 55 static const char* LDAC_CLOSE_HANDLE_NAME = "ldacBT_close_handle"; 56 typedef void (*tLDAC_CLOSE_HANDLE)(HANDLE_LDAC_BT hLdacParam); 57 58 static const char* LDAC_GET_VERSION_NAME = "ldacBT_get_version"; 59 typedef int (*tLDAC_GET_VERSION)(void); 60 61 static const char* LDAC_GET_BITRATE_NAME = "ldacBT_get_bitrate"; 62 typedef int (*tLDAC_GET_BITRATE)(HANDLE_LDAC_BT hLdacParam); 63 64 static const char* LDAC_GET_SAMPLING_FREQ_NAME = "ldacBT_get_sampling_freq"; 65 typedef int (*tLDAC_GET_SAMPLING_FREQ)(HANDLE_LDAC_BT hLdacParam); 66 67 static const char* LDAC_INIT_HANDLE_ENCODE_NAME = "ldacBT_init_handle_encode"; 68 typedef int (*tLDAC_INIT_HANDLE_ENCODE)(HANDLE_LDAC_BT hLdacParam, int mtu, 69 int eqmid, int channel_mode, 70 LDACBT_SMPL_FMT_T fmt, 71 int sampling_freq); 72 73 static const char* LDAC_ENCODE_NAME = "ldacBT_encode"; 74 typedef int (*tLDAC_ENCODE)(HANDLE_LDAC_BT hLdacParam, void* p_pcm, 75 int* p_pcm_encoded_byte, unsigned char* p_stream, 76 int* pframe_length_wrote, int* pframe_num); 77 78 static const char* LDAC_SET_EQMID_NAME = "ldacBT_set_eqmid"; 79 typedef int (*tLDAC_SET_EQMID)(HANDLE_LDAC_BT hLdacParam, int eqmid); 80 81 static const char* LDAC_ALTER_EQMID_PRIORITY_NAME = 82 "ldacBT_alter_eqmid_priority"; 83 typedef int (*tLDAC_ALTER_EQMID_PRIORITY)(HANDLE_LDAC_BT hLdacParam, 84 int priority); 85 86 static const char* LDAC_GET_EQMID_NAME = "ldacBT_get_eqmid"; 87 typedef int (*tLDAC_GET_EQMID)(HANDLE_LDAC_BT hLdacParam); 88 89 static const char* LDAC_GET_ERROR_CODE_NAME = "ldacBT_get_error_code"; 90 typedef int (*tLDAC_GET_ERROR_CODE)(HANDLE_LDAC_BT hLdacParam); 91 92 static tLDAC_GET_HANDLE ldac_get_handle_func; 93 static tLDAC_FREE_HANDLE ldac_free_handle_func; 94 static tLDAC_CLOSE_HANDLE ldac_close_handle_func; 95 static tLDAC_GET_VERSION ldac_get_version_func; 96 static tLDAC_GET_BITRATE ldac_get_bitrate_func; 97 static tLDAC_GET_SAMPLING_FREQ ldac_get_sampling_freq_func; 98 static tLDAC_INIT_HANDLE_ENCODE ldac_init_handle_encode_func; 99 static tLDAC_ENCODE ldac_encode_func; 100 static tLDAC_SET_EQMID ldac_set_eqmid_func; 101 static tLDAC_ALTER_EQMID_PRIORITY ldac_alter_eqmid_priority_func; 102 static tLDAC_GET_EQMID ldac_get_eqmid_func; 103 static tLDAC_GET_ERROR_CODE ldac_get_error_code_func; 104 105 // A2DP LDAC encoder interval in milliseconds 106 #define A2DP_LDAC_ENCODER_INTERVAL_MS 20 107 #define A2DP_LDAC_MEDIA_BYTES_PER_FRAME 128 108 109 // offset 110 #if (BTA_AV_CO_CP_SCMS_T == TRUE) 111 #define A2DP_LDAC_OFFSET (AVDT_MEDIA_OFFSET + A2DP_LDAC_MPL_HDR_LEN + 1) 112 #else 113 #define A2DP_LDAC_OFFSET (AVDT_MEDIA_OFFSET + A2DP_LDAC_MPL_HDR_LEN) 114 #endif 115 116 typedef struct { 117 uint32_t sample_rate; 118 uint8_t channel_mode; 119 uint8_t bits_per_sample; 120 int quality_mode_index; 121 int pcm_wlength; 122 LDACBT_SMPL_FMT_T pcm_fmt; 123 } tA2DP_LDAC_ENCODER_PARAMS; 124 125 typedef struct { 126 uint32_t counter; 127 uint32_t bytes_per_tick; /* pcm bytes read each media task tick */ 128 uint64_t last_frame_us; 129 } tA2DP_LDAC_FEEDING_STATE; 130 131 typedef struct { 132 uint64_t session_start_us; 133 134 size_t media_read_total_expected_packets; 135 size_t media_read_total_expected_reads_count; 136 size_t media_read_total_expected_read_bytes; 137 138 size_t media_read_total_dropped_packets; 139 size_t media_read_total_actual_reads_count; 140 size_t media_read_total_actual_read_bytes; 141 } a2dp_ldac_encoder_stats_t; 142 143 typedef struct { 144 a2dp_source_read_callback_t read_callback; 145 a2dp_source_enqueue_callback_t enqueue_callback; 146 uint16_t TxAaMtuSize; 147 size_t TxQueueLength; 148 149 bool use_SCMS_T; 150 bool is_peer_edr; // True if the peer device supports EDR 151 bool peer_supports_3mbps; // True if the peer device supports 3Mbps EDR 152 uint16_t peer_mtu; // MTU of the A2DP peer 153 uint32_t timestamp; // Timestamp for the A2DP frames 154 155 HANDLE_LDAC_BT ldac_handle; 156 bool has_ldac_handle; // True if ldac_handle is valid 157 158 HANDLE_LDAC_ABR ldac_abr_handle; 159 bool has_ldac_abr_handle; 160 int last_ldac_abr_eqmid; 161 size_t ldac_abr_adjustments; 162 163 tA2DP_FEEDING_PARAMS feeding_params; 164 tA2DP_LDAC_ENCODER_PARAMS ldac_encoder_params; 165 tA2DP_LDAC_FEEDING_STATE ldac_feeding_state; 166 167 a2dp_ldac_encoder_stats_t stats; 168 } tA2DP_LDAC_ENCODER_CB; 169 170 static bool ldac_abr_loaded = false; 171 172 static tA2DP_LDAC_ENCODER_CB a2dp_ldac_encoder_cb; 173 174 static void a2dp_vendor_ldac_encoder_update(uint16_t peer_mtu, 175 A2dpCodecConfig* a2dp_codec_config, 176 bool* p_restart_input, 177 bool* p_restart_output, 178 bool* p_config_updated); 179 static void a2dp_ldac_get_num_frame_iteration(uint8_t* num_of_iterations, 180 uint8_t* num_of_frames, 181 uint64_t timestamp_us); 182 static void a2dp_ldac_encode_frames(uint8_t nb_frame); 183 static bool a2dp_ldac_read_feeding(uint8_t* read_buffer, uint32_t* bytes_read); 184 static std::string quality_mode_index_to_name(int quality_mode_index); 185 186 static void* load_func(const char* func_name) { 187 void* func_ptr = dlsym(ldac_encoder_lib_handle, func_name); 188 if (func_ptr == NULL) { 189 LOG_ERROR(LOG_TAG, 190 "%s: cannot find function '%s' in the encoder library: %s", 191 __func__, func_name, dlerror()); 192 A2DP_VendorUnloadEncoderLdac(); 193 return NULL; 194 } 195 return func_ptr; 196 } 197 198 bool A2DP_VendorLoadEncoderLdac(void) { 199 if (ldac_encoder_lib_handle != NULL) return true; // Already loaded 200 201 // Initialize the control block 202 memset(&a2dp_ldac_encoder_cb, 0, sizeof(a2dp_ldac_encoder_cb)); 203 204 // Open the encoder library 205 ldac_encoder_lib_handle = dlopen(LDAC_ENCODER_LIB_NAME, RTLD_NOW); 206 if (ldac_encoder_lib_handle == NULL) { 207 LOG_ERROR(LOG_TAG, "%s: cannot open LDAC encoder library %s: %s", __func__, 208 LDAC_ENCODER_LIB_NAME, dlerror()); 209 return false; 210 } 211 212 // Load all functions 213 ldac_get_handle_func = (tLDAC_GET_HANDLE)load_func(LDAC_GET_HANDLE_NAME); 214 if (ldac_get_handle_func == NULL) return false; 215 ldac_free_handle_func = (tLDAC_FREE_HANDLE)load_func(LDAC_FREE_HANDLE_NAME); 216 if (ldac_free_handle_func == NULL) return false; 217 ldac_close_handle_func = 218 (tLDAC_CLOSE_HANDLE)load_func(LDAC_CLOSE_HANDLE_NAME); 219 if (ldac_close_handle_func == NULL) return false; 220 ldac_get_version_func = (tLDAC_GET_VERSION)load_func(LDAC_GET_VERSION_NAME); 221 if (ldac_get_version_func == NULL) return false; 222 ldac_get_bitrate_func = (tLDAC_GET_BITRATE)load_func(LDAC_GET_BITRATE_NAME); 223 if (ldac_get_bitrate_func == NULL) return false; 224 ldac_get_sampling_freq_func = 225 (tLDAC_GET_SAMPLING_FREQ)load_func(LDAC_GET_SAMPLING_FREQ_NAME); 226 if (ldac_get_sampling_freq_func == NULL) return false; 227 ldac_init_handle_encode_func = 228 (tLDAC_INIT_HANDLE_ENCODE)load_func(LDAC_INIT_HANDLE_ENCODE_NAME); 229 if (ldac_init_handle_encode_func == NULL) return false; 230 ldac_encode_func = (tLDAC_ENCODE)load_func(LDAC_ENCODE_NAME); 231 if (ldac_encode_func == NULL) return false; 232 ldac_set_eqmid_func = (tLDAC_SET_EQMID)load_func(LDAC_SET_EQMID_NAME); 233 if (ldac_set_eqmid_func == NULL) return false; 234 ldac_alter_eqmid_priority_func = 235 (tLDAC_ALTER_EQMID_PRIORITY)load_func(LDAC_ALTER_EQMID_PRIORITY_NAME); 236 if (ldac_alter_eqmid_priority_func == NULL) return false; 237 ldac_get_eqmid_func = (tLDAC_GET_EQMID)load_func(LDAC_GET_EQMID_NAME); 238 if (ldac_get_eqmid_func == NULL) return false; 239 ldac_get_error_code_func = 240 (tLDAC_GET_ERROR_CODE)load_func(LDAC_GET_ERROR_CODE_NAME); 241 if (ldac_get_error_code_func == NULL) return false; 242 243 if (!A2DP_VendorLoadLdacAbr()) { 244 LOG_WARN(LOG_TAG, "%s: cannot load the LDAC ABR library", __func__); 245 ldac_abr_loaded = false; 246 } else { 247 ldac_abr_loaded = true; 248 } 249 return true; 250 } 251 252 void A2DP_VendorUnloadEncoderLdac(void) { 253 // Cleanup any LDAC-related state 254 if (a2dp_ldac_encoder_cb.has_ldac_handle && ldac_free_handle_func != NULL) 255 ldac_free_handle_func(a2dp_ldac_encoder_cb.ldac_handle); 256 memset(&a2dp_ldac_encoder_cb, 0, sizeof(a2dp_ldac_encoder_cb)); 257 258 ldac_get_handle_func = NULL; 259 ldac_free_handle_func = NULL; 260 ldac_close_handle_func = NULL; 261 ldac_get_version_func = NULL; 262 ldac_get_bitrate_func = NULL; 263 ldac_get_sampling_freq_func = NULL; 264 ldac_init_handle_encode_func = NULL; 265 ldac_encode_func = NULL; 266 ldac_set_eqmid_func = NULL; 267 ldac_alter_eqmid_priority_func = NULL; 268 ldac_get_eqmid_func = NULL; 269 ldac_get_error_code_func = NULL; 270 271 if (ldac_encoder_lib_handle != NULL) { 272 dlclose(ldac_encoder_lib_handle); 273 ldac_encoder_lib_handle = NULL; 274 } 275 } 276 277 void a2dp_vendor_ldac_encoder_init( 278 const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, 279 A2dpCodecConfig* a2dp_codec_config, 280 a2dp_source_read_callback_t read_callback, 281 a2dp_source_enqueue_callback_t enqueue_callback) { 282 if (a2dp_ldac_encoder_cb.has_ldac_handle) 283 ldac_free_handle_func(a2dp_ldac_encoder_cb.ldac_handle); 284 if (a2dp_ldac_encoder_cb.has_ldac_abr_handle) 285 a2dp_ldac_abr_free_handle(a2dp_ldac_encoder_cb.ldac_abr_handle); 286 memset(&a2dp_ldac_encoder_cb, 0, sizeof(a2dp_ldac_encoder_cb)); 287 288 a2dp_ldac_encoder_cb.stats.session_start_us = time_get_os_boottime_us(); 289 290 a2dp_ldac_encoder_cb.read_callback = read_callback; 291 a2dp_ldac_encoder_cb.enqueue_callback = enqueue_callback; 292 a2dp_ldac_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr; 293 a2dp_ldac_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps; 294 a2dp_ldac_encoder_cb.peer_mtu = p_peer_params->peer_mtu; 295 a2dp_ldac_encoder_cb.timestamp = 0; 296 a2dp_ldac_encoder_cb.ldac_abr_handle = NULL; 297 a2dp_ldac_encoder_cb.has_ldac_abr_handle = false; 298 a2dp_ldac_encoder_cb.last_ldac_abr_eqmid = -1; 299 a2dp_ldac_encoder_cb.ldac_abr_adjustments = 0; 300 301 a2dp_ldac_encoder_cb.use_SCMS_T = false; // TODO: should be a parameter 302 #if (BTA_AV_CO_CP_SCMS_T == TRUE) 303 a2dp_ldac_encoder_cb.use_SCMS_T = true; 304 #endif 305 306 // NOTE: Ignore the restart_input / restart_output flags - this initization 307 // happens when the connection is (re)started. 308 bool restart_input = false; 309 bool restart_output = false; 310 bool config_updated = false; 311 a2dp_vendor_ldac_encoder_update(a2dp_ldac_encoder_cb.peer_mtu, 312 a2dp_codec_config, &restart_input, 313 &restart_output, &config_updated); 314 } 315 316 bool A2dpCodecConfigLdac::updateEncoderUserConfig( 317 const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, bool* p_restart_input, 318 bool* p_restart_output, bool* p_config_updated) { 319 a2dp_ldac_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr; 320 a2dp_ldac_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps; 321 a2dp_ldac_encoder_cb.peer_mtu = p_peer_params->peer_mtu; 322 a2dp_ldac_encoder_cb.timestamp = 0; 323 324 if (a2dp_ldac_encoder_cb.peer_mtu == 0) { 325 LOG_ERROR(LOG_TAG, 326 "%s: Cannot update the codec encoder for %s: " 327 "invalid peer MTU", 328 __func__, name().c_str()); 329 return false; 330 } 331 332 a2dp_vendor_ldac_encoder_update(a2dp_ldac_encoder_cb.peer_mtu, this, 333 p_restart_input, p_restart_output, 334 p_config_updated); 335 return true; 336 } 337 338 // Update the A2DP LDAC encoder. 339 // |peer_mtu| is the peer MTU. 340 // |a2dp_codec_config| is the A2DP codec to use for the update. 341 static void a2dp_vendor_ldac_encoder_update(uint16_t peer_mtu, 342 A2dpCodecConfig* a2dp_codec_config, 343 bool* p_restart_input, 344 bool* p_restart_output, 345 bool* p_config_updated) { 346 tA2DP_LDAC_ENCODER_PARAMS* p_encoder_params = 347 &a2dp_ldac_encoder_cb.ldac_encoder_params; 348 uint8_t codec_info[AVDT_CODEC_SIZE]; 349 350 *p_restart_input = false; 351 *p_restart_output = false; 352 *p_config_updated = false; 353 354 if (!a2dp_ldac_encoder_cb.has_ldac_handle) { 355 a2dp_ldac_encoder_cb.ldac_handle = ldac_get_handle_func(); 356 if (a2dp_ldac_encoder_cb.ldac_handle == NULL) { 357 LOG_ERROR(LOG_TAG, "%s: Cannot get LDAC encoder handle", __func__); 358 return; // TODO: Return an error? 359 } 360 a2dp_ldac_encoder_cb.has_ldac_handle = true; 361 } 362 CHECK(a2dp_ldac_encoder_cb.ldac_handle != nullptr); 363 364 if (!a2dp_codec_config->copyOutOtaCodecConfig(codec_info)) { 365 LOG_ERROR(LOG_TAG, 366 "%s: Cannot update the codec encoder for %s: " 367 "invalid codec config", 368 __func__, a2dp_codec_config->name().c_str()); 369 return; 370 } 371 const uint8_t* p_codec_info = codec_info; 372 btav_a2dp_codec_config_t codec_config = a2dp_codec_config->getCodecConfig(); 373 374 // The feeding parameters 375 tA2DP_FEEDING_PARAMS* p_feeding_params = &a2dp_ldac_encoder_cb.feeding_params; 376 p_feeding_params->sample_rate = 377 A2DP_VendorGetTrackSampleRateLdac(p_codec_info); 378 p_feeding_params->bits_per_sample = 379 a2dp_codec_config->getAudioBitsPerSample(); 380 p_feeding_params->channel_count = 381 A2DP_VendorGetTrackChannelCountLdac(p_codec_info); 382 LOG_DEBUG(LOG_TAG, "%s: sample_rate=%u bits_per_sample=%u channel_count=%u", 383 __func__, p_feeding_params->sample_rate, 384 p_feeding_params->bits_per_sample, p_feeding_params->channel_count); 385 a2dp_vendor_ldac_feeding_reset(); 386 387 // The codec parameters 388 p_encoder_params->sample_rate = 389 a2dp_ldac_encoder_cb.feeding_params.sample_rate; 390 p_encoder_params->channel_mode = 391 A2DP_VendorGetChannelModeCodeLdac(p_codec_info); 392 393 uint16_t mtu_size = 394 BT_DEFAULT_BUFFER_SIZE - A2DP_LDAC_OFFSET - sizeof(BT_HDR); 395 if (mtu_size < peer_mtu) { 396 a2dp_ldac_encoder_cb.TxAaMtuSize = mtu_size; 397 } else { 398 a2dp_ldac_encoder_cb.TxAaMtuSize = peer_mtu; 399 } 400 401 // Set the quality mode index 402 int old_quality_mode_index = p_encoder_params->quality_mode_index; 403 if (codec_config.codec_specific_1 != 0) { 404 p_encoder_params->quality_mode_index = codec_config.codec_specific_1 % 10; 405 LOG_DEBUG(LOG_TAG, "%s: setting quality mode to %s", __func__, 406 quality_mode_index_to_name(p_encoder_params->quality_mode_index) 407 .c_str()); 408 } else { 409 p_encoder_params->quality_mode_index = A2DP_LDAC_QUALITY_ABR; 410 LOG_DEBUG(LOG_TAG, "%s: setting quality mode to default %s", __func__, 411 quality_mode_index_to_name(p_encoder_params->quality_mode_index) 412 .c_str()); 413 } 414 415 int ldac_eqmid = LDAC_ABR_MODE_EQMID; 416 if (p_encoder_params->quality_mode_index == A2DP_LDAC_QUALITY_ABR) { 417 if (!ldac_abr_loaded) { 418 p_encoder_params->quality_mode_index = A2DP_LDAC_QUALITY_MID; 419 LOG_WARN( 420 LOG_TAG, 421 "%s: LDAC ABR library is not loaded, resetting quality mode to %s", 422 __func__, 423 quality_mode_index_to_name(p_encoder_params->quality_mode_index) 424 .c_str()); 425 } else { 426 LOG_DEBUG(LOG_TAG, "%s: changing mode from %s to %s", __func__, 427 quality_mode_index_to_name(old_quality_mode_index).c_str(), 428 quality_mode_index_to_name(p_encoder_params->quality_mode_index) 429 .c_str()); 430 if (a2dp_ldac_encoder_cb.ldac_abr_handle != NULL) { 431 LOG_DEBUG(LOG_TAG, "%s: already in LDAC ABR mode, do nothing.", 432 __func__); 433 } else { 434 LOG_DEBUG(LOG_TAG, "%s: get and init LDAC ABR handle.", __func__); 435 a2dp_ldac_encoder_cb.ldac_abr_handle = a2dp_ldac_abr_get_handle(); 436 if (a2dp_ldac_encoder_cb.ldac_abr_handle != NULL) { 437 a2dp_ldac_encoder_cb.has_ldac_abr_handle = true; 438 a2dp_ldac_encoder_cb.last_ldac_abr_eqmid = -1; 439 a2dp_ldac_encoder_cb.ldac_abr_adjustments = 0; 440 a2dp_ldac_abr_init(a2dp_ldac_encoder_cb.ldac_abr_handle, 441 A2DP_LDAC_ENCODER_INTERVAL_MS); 442 } else { 443 p_encoder_params->quality_mode_index = A2DP_LDAC_QUALITY_MID; 444 LOG_DEBUG( 445 LOG_TAG, 446 "%s: get LDAC ABR handle failed, resetting quality mode to %s.", 447 __func__, 448 quality_mode_index_to_name(p_encoder_params->quality_mode_index) 449 .c_str()); 450 } 451 } 452 } 453 } else { 454 ldac_eqmid = p_encoder_params->quality_mode_index; 455 LOG_DEBUG(LOG_TAG, "%s: in %s mode, free LDAC ABR handle.", __func__, 456 quality_mode_index_to_name(ldac_eqmid).c_str()); 457 if (a2dp_ldac_encoder_cb.has_ldac_abr_handle) { 458 a2dp_ldac_abr_free_handle(a2dp_ldac_encoder_cb.ldac_abr_handle); 459 a2dp_ldac_encoder_cb.ldac_abr_handle = NULL; 460 a2dp_ldac_encoder_cb.has_ldac_abr_handle = false; 461 a2dp_ldac_encoder_cb.last_ldac_abr_eqmid = -1; 462 a2dp_ldac_encoder_cb.ldac_abr_adjustments = 0; 463 } 464 } 465 466 if (p_encoder_params->quality_mode_index != old_quality_mode_index) 467 *p_config_updated = true; 468 469 p_encoder_params->pcm_wlength = 470 a2dp_ldac_encoder_cb.feeding_params.bits_per_sample >> 3; 471 // Set the Audio format from pcm_wlength 472 p_encoder_params->pcm_fmt = LDACBT_SMPL_FMT_S16; 473 if (p_encoder_params->pcm_wlength == 2) 474 p_encoder_params->pcm_fmt = LDACBT_SMPL_FMT_S16; 475 else if (p_encoder_params->pcm_wlength == 3) 476 p_encoder_params->pcm_fmt = LDACBT_SMPL_FMT_S24; 477 else if (p_encoder_params->pcm_wlength == 4) 478 p_encoder_params->pcm_fmt = LDACBT_SMPL_FMT_S32; 479 480 LOG_DEBUG(LOG_TAG, "%s: MTU=%d, peer_mtu=%d", __func__, 481 a2dp_ldac_encoder_cb.TxAaMtuSize, peer_mtu); 482 LOG_DEBUG(LOG_TAG, 483 "%s: sample_rate: %d channel_mode: %d " 484 "quality_mode_index: %d pcm_wlength: %d pcm_fmt: %d", 485 __func__, p_encoder_params->sample_rate, 486 p_encoder_params->channel_mode, 487 p_encoder_params->quality_mode_index, p_encoder_params->pcm_wlength, 488 p_encoder_params->pcm_fmt); 489 490 // Initialize the encoder. 491 // NOTE: MTU in the initialization must include the AVDT media header size. 492 int result = ldac_init_handle_encode_func( 493 a2dp_ldac_encoder_cb.ldac_handle, 494 a2dp_ldac_encoder_cb.TxAaMtuSize + AVDT_MEDIA_HDR_SIZE, ldac_eqmid, 495 p_encoder_params->channel_mode, p_encoder_params->pcm_fmt, 496 p_encoder_params->sample_rate); 497 if (result != 0) { 498 int err_code = ldac_get_error_code_func(a2dp_ldac_encoder_cb.ldac_handle); 499 LOG_ERROR(LOG_TAG, 500 "%s: error initializing the LDAC encoder: %d api_error = %d " 501 "handle_error = %d block_error = %d error_code = 0x%x", 502 __func__, result, LDACBT_API_ERR(err_code), 503 LDACBT_HANDLE_ERR(err_code), LDACBT_BLOCK_ERR(err_code), 504 err_code); 505 } 506 } 507 508 void a2dp_vendor_ldac_encoder_cleanup(void) { 509 if (a2dp_ldac_encoder_cb.has_ldac_abr_handle) 510 a2dp_ldac_abr_free_handle(a2dp_ldac_encoder_cb.ldac_abr_handle); 511 if (a2dp_ldac_encoder_cb.has_ldac_handle) 512 ldac_free_handle_func(a2dp_ldac_encoder_cb.ldac_handle); 513 memset(&a2dp_ldac_encoder_cb, 0, sizeof(a2dp_ldac_encoder_cb)); 514 } 515 516 void a2dp_vendor_ldac_feeding_reset(void) { 517 /* By default, just clear the entire state */ 518 memset(&a2dp_ldac_encoder_cb.ldac_feeding_state, 0, 519 sizeof(a2dp_ldac_encoder_cb.ldac_feeding_state)); 520 521 a2dp_ldac_encoder_cb.ldac_feeding_state.bytes_per_tick = 522 (a2dp_ldac_encoder_cb.feeding_params.sample_rate * 523 a2dp_ldac_encoder_cb.feeding_params.bits_per_sample / 8 * 524 a2dp_ldac_encoder_cb.feeding_params.channel_count * 525 A2DP_LDAC_ENCODER_INTERVAL_MS) / 526 1000; 527 528 LOG_DEBUG(LOG_TAG, "%s: PCM bytes per tick %u", __func__, 529 a2dp_ldac_encoder_cb.ldac_feeding_state.bytes_per_tick); 530 } 531 532 void a2dp_vendor_ldac_feeding_flush(void) { 533 a2dp_ldac_encoder_cb.ldac_feeding_state.counter = 0; 534 } 535 536 period_ms_t a2dp_vendor_ldac_get_encoder_interval_ms(void) { 537 return A2DP_LDAC_ENCODER_INTERVAL_MS; 538 } 539 540 void a2dp_vendor_ldac_send_frames(uint64_t timestamp_us) { 541 uint8_t nb_frame = 0; 542 uint8_t nb_iterations = 0; 543 544 a2dp_ldac_get_num_frame_iteration(&nb_iterations, &nb_frame, timestamp_us); 545 LOG_VERBOSE(LOG_TAG, "%s: Sending %d frames per iteration, %d iterations", 546 __func__, nb_frame, nb_iterations); 547 if (nb_frame == 0) return; 548 549 for (uint8_t counter = 0; counter < nb_iterations; counter++) { 550 if (a2dp_ldac_encoder_cb.has_ldac_abr_handle) { 551 int flag_enable = 1; 552 int prev_eqmid = a2dp_ldac_encoder_cb.last_ldac_abr_eqmid; 553 a2dp_ldac_encoder_cb.last_ldac_abr_eqmid = 554 a2dp_ldac_abr_proc(a2dp_ldac_encoder_cb.ldac_handle, 555 a2dp_ldac_encoder_cb.ldac_abr_handle, 556 a2dp_ldac_encoder_cb.TxQueueLength, flag_enable); 557 if (prev_eqmid != a2dp_ldac_encoder_cb.last_ldac_abr_eqmid) 558 a2dp_ldac_encoder_cb.ldac_abr_adjustments++; 559 #ifndef OS_GENERIC 560 ATRACE_INT("LDAC ABR level", a2dp_ldac_encoder_cb.last_ldac_abr_eqmid); 561 #endif 562 } 563 // Transcode frame and enqueue 564 a2dp_ldac_encode_frames(nb_frame); 565 } 566 } 567 568 // Obtains the number of frames to send and number of iterations 569 // to be used. |num_of_iterations| and |num_of_frames| parameters 570 // are used as output param for returning the respective values. 571 static void a2dp_ldac_get_num_frame_iteration(uint8_t* num_of_iterations, 572 uint8_t* num_of_frames, 573 uint64_t timestamp_us) { 574 uint32_t result = 0; 575 uint8_t nof = 0; 576 uint8_t noi = 1; 577 578 uint32_t pcm_bytes_per_frame = 579 A2DP_LDAC_MEDIA_BYTES_PER_FRAME * 580 a2dp_ldac_encoder_cb.feeding_params.channel_count * 581 a2dp_ldac_encoder_cb.feeding_params.bits_per_sample / 8; 582 LOG_VERBOSE(LOG_TAG, "%s: pcm_bytes_per_frame %u", __func__, 583 pcm_bytes_per_frame); 584 585 uint32_t us_this_tick = A2DP_LDAC_ENCODER_INTERVAL_MS * 1000; 586 uint64_t now_us = timestamp_us; 587 if (a2dp_ldac_encoder_cb.ldac_feeding_state.last_frame_us != 0) 588 us_this_tick = 589 (now_us - a2dp_ldac_encoder_cb.ldac_feeding_state.last_frame_us); 590 a2dp_ldac_encoder_cb.ldac_feeding_state.last_frame_us = now_us; 591 592 a2dp_ldac_encoder_cb.ldac_feeding_state.counter += 593 a2dp_ldac_encoder_cb.ldac_feeding_state.bytes_per_tick * us_this_tick / 594 (A2DP_LDAC_ENCODER_INTERVAL_MS * 1000); 595 596 result = 597 a2dp_ldac_encoder_cb.ldac_feeding_state.counter / pcm_bytes_per_frame; 598 a2dp_ldac_encoder_cb.ldac_feeding_state.counter -= 599 result * pcm_bytes_per_frame; 600 nof = result; 601 602 LOG_VERBOSE(LOG_TAG, "%s: effective num of frames %u, iterations %u", 603 __func__, nof, noi); 604 605 *num_of_frames = nof; 606 *num_of_iterations = noi; 607 } 608 609 static void a2dp_ldac_encode_frames(uint8_t nb_frame) { 610 tA2DP_LDAC_ENCODER_PARAMS* p_encoder_params = 611 &a2dp_ldac_encoder_cb.ldac_encoder_params; 612 uint8_t remain_nb_frame = nb_frame; 613 uint16_t ldac_frame_size; 614 uint8_t read_buffer[LDACBT_MAX_LSU * 4 /* byte/sample */ * 2 /* ch */]; 615 616 switch (p_encoder_params->sample_rate) { 617 case 176400: 618 case 192000: 619 ldac_frame_size = 512; // sample/ch 620 break; 621 case 88200: 622 case 96000: 623 ldac_frame_size = 256; // sample/ch 624 break; 625 case 44100: 626 case 48000: 627 default: 628 ldac_frame_size = 128; // sample/ch 629 break; 630 } 631 632 uint32_t count; 633 int32_t encode_count = 0; 634 int32_t out_frames = 0; 635 int written = 0; 636 637 uint32_t bytes_read = 0; 638 while (nb_frame) { 639 BT_HDR* p_buf = (BT_HDR*)osi_malloc(BT_DEFAULT_BUFFER_SIZE); 640 p_buf->offset = A2DP_LDAC_OFFSET; 641 p_buf->len = 0; 642 p_buf->layer_specific = 0; 643 a2dp_ldac_encoder_cb.stats.media_read_total_expected_packets++; 644 645 count = 0; 646 do { 647 // 648 // Read the PCM data and encode it 649 // 650 uint32_t temp_bytes_read = 0; 651 if (a2dp_ldac_read_feeding(read_buffer, &temp_bytes_read)) { 652 bytes_read += temp_bytes_read; 653 uint8_t* packet = (uint8_t*)(p_buf + 1) + p_buf->offset + p_buf->len; 654 if (a2dp_ldac_encoder_cb.ldac_handle == NULL) { 655 LOG_ERROR(LOG_TAG, "%s: invalid LDAC handle", __func__); 656 a2dp_ldac_encoder_cb.stats.media_read_total_dropped_packets++; 657 osi_free(p_buf); 658 return; 659 } 660 int result = ldac_encode_func( 661 a2dp_ldac_encoder_cb.ldac_handle, read_buffer, (int*)&encode_count, 662 packet + count, (int*)&written, (int*)&out_frames); 663 if (result != 0) { 664 int err_code = 665 ldac_get_error_code_func(a2dp_ldac_encoder_cb.ldac_handle); 666 LOG_ERROR(LOG_TAG, 667 "%s: LDAC encoding error: %d api_error = %d " 668 "handle_error = %d block_error = %d error_code = 0x%x", 669 __func__, result, LDACBT_API_ERR(err_code), 670 LDACBT_HANDLE_ERR(err_code), LDACBT_BLOCK_ERR(err_code), 671 err_code); 672 a2dp_ldac_encoder_cb.stats.media_read_total_dropped_packets++; 673 osi_free(p_buf); 674 return; 675 } 676 count += written; 677 p_buf->len += written; 678 nb_frame--; 679 p_buf->layer_specific += out_frames; // added a frame to the buffer 680 } else { 681 LOG_WARN(LOG_TAG, "%s: underflow %d", __func__, nb_frame); 682 a2dp_ldac_encoder_cb.ldac_feeding_state.counter += 683 nb_frame * LDACBT_ENC_LSU * 684 a2dp_ldac_encoder_cb.feeding_params.channel_count * 685 a2dp_ldac_encoder_cb.feeding_params.bits_per_sample / 8; 686 687 // no more pcm to read 688 nb_frame = 0; 689 } 690 } while ((written == 0) && nb_frame); 691 692 if (p_buf->len) { 693 /* 694 * Timestamp of the media packet header represent the TS of the 695 * first frame, i.e the timestamp before including this frame. 696 */ 697 *((uint32_t*)(p_buf + 1)) = a2dp_ldac_encoder_cb.timestamp; 698 699 a2dp_ldac_encoder_cb.timestamp += p_buf->layer_specific * ldac_frame_size; 700 701 uint8_t done_nb_frame = remain_nb_frame - nb_frame; 702 remain_nb_frame = nb_frame; 703 if (!a2dp_ldac_encoder_cb.enqueue_callback(p_buf, done_nb_frame, 704 bytes_read)) 705 return; 706 } else { 707 // NOTE: Unlike the execution path for other codecs, it is normal for 708 // LDAC to NOT write encoded data to the last buffer if there wasn't 709 // enough data to write to. That data is accumulated internally by 710 // the codec and included in the next iteration. Therefore, here we 711 // don't increment the "media_read_total_dropped_packets" counter. 712 osi_free(p_buf); 713 } 714 } 715 } 716 717 static bool a2dp_ldac_read_feeding(uint8_t* read_buffer, uint32_t* bytes_read) { 718 uint32_t read_size = LDACBT_ENC_LSU * 719 a2dp_ldac_encoder_cb.feeding_params.channel_count * 720 a2dp_ldac_encoder_cb.feeding_params.bits_per_sample / 8; 721 722 a2dp_ldac_encoder_cb.stats.media_read_total_expected_reads_count++; 723 a2dp_ldac_encoder_cb.stats.media_read_total_expected_read_bytes += read_size; 724 725 /* Read Data from UIPC channel */ 726 uint32_t nb_byte_read = 727 a2dp_ldac_encoder_cb.read_callback(read_buffer, read_size); 728 a2dp_ldac_encoder_cb.stats.media_read_total_actual_read_bytes += nb_byte_read; 729 730 if (nb_byte_read < read_size) { 731 if (nb_byte_read == 0) return false; 732 733 /* Fill the unfilled part of the read buffer with silence (0) */ 734 memset(((uint8_t*)read_buffer) + nb_byte_read, 0, read_size - nb_byte_read); 735 nb_byte_read = read_size; 736 } 737 a2dp_ldac_encoder_cb.stats.media_read_total_actual_reads_count++; 738 739 *bytes_read = nb_byte_read; 740 return true; 741 } 742 743 static std::string quality_mode_index_to_name(int quality_mode_index) { 744 switch (quality_mode_index) { 745 case A2DP_LDAC_QUALITY_HIGH: 746 return "HIGH"; 747 case A2DP_LDAC_QUALITY_MID: 748 return "MID"; 749 case A2DP_LDAC_QUALITY_LOW: 750 return "LOW"; 751 case A2DP_LDAC_QUALITY_ABR: 752 return "ABR"; 753 default: 754 return "Unknown"; 755 } 756 } 757 758 void a2dp_vendor_ldac_set_transmit_queue_length(size_t transmit_queue_length) { 759 a2dp_ldac_encoder_cb.TxQueueLength = transmit_queue_length; 760 } 761 762 period_ms_t A2dpCodecConfigLdac::encoderIntervalMs() const { 763 return a2dp_vendor_ldac_get_encoder_interval_ms(); 764 } 765 766 int A2dpCodecConfigLdac::getEffectiveMtu() const { 767 return a2dp_ldac_encoder_cb.TxAaMtuSize; 768 } 769 770 void A2dpCodecConfigLdac::debug_codec_dump(int fd) { 771 a2dp_ldac_encoder_stats_t* stats = &a2dp_ldac_encoder_cb.stats; 772 tA2DP_LDAC_ENCODER_PARAMS* p_encoder_params = 773 &a2dp_ldac_encoder_cb.ldac_encoder_params; 774 775 A2dpCodecConfig::debug_codec_dump(fd); 776 777 dprintf(fd, 778 " Packet counts (expected/dropped) : %zu / " 779 "%zu\n", 780 stats->media_read_total_expected_packets, 781 stats->media_read_total_dropped_packets); 782 783 dprintf(fd, 784 " PCM read counts (expected/actual) : %zu / " 785 "%zu\n", 786 stats->media_read_total_expected_reads_count, 787 stats->media_read_total_actual_reads_count); 788 789 dprintf(fd, 790 " PCM read bytes (expected/actual) : %zu / " 791 "%zu\n", 792 stats->media_read_total_expected_read_bytes, 793 stats->media_read_total_actual_read_bytes); 794 795 dprintf( 796 fd, " LDAC quality mode : %s\n", 797 quality_mode_index_to_name(p_encoder_params->quality_mode_index).c_str()); 798 799 dprintf(fd, 800 " LDAC transmission bitrate (Kbps) : %d\n", 801 ldac_get_bitrate_func(a2dp_ldac_encoder_cb.ldac_handle)); 802 803 dprintf(fd, 804 " LDAC saved transmit queue length : %zu\n", 805 a2dp_ldac_encoder_cb.TxQueueLength); 806 if (a2dp_ldac_encoder_cb.has_ldac_abr_handle) { 807 dprintf(fd, 808 " LDAC adaptive bit rate encode quality mode index : %d\n", 809 a2dp_ldac_encoder_cb.last_ldac_abr_eqmid); 810 dprintf(fd, 811 " LDAC adaptive bit rate adjustments : %zu\n", 812 a2dp_ldac_encoder_cb.ldac_abr_adjustments); 813 } 814 } 815
