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