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
load_func(const char * func_name)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
A2DP_VendorLoadEncoderLdac(void)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
A2DP_VendorUnloadEncoderLdac(void)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
a2dp_vendor_ldac_encoder_init(const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,A2dpCodecConfig * a2dp_codec_config,a2dp_source_read_callback_t read_callback,a2dp_source_enqueue_callback_t enqueue_callback)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
updateEncoderUserConfig(const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)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.
a2dp_vendor_ldac_encoder_update(uint16_t peer_mtu,A2dpCodecConfig * a2dp_codec_config,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)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
a2dp_vendor_ldac_encoder_cleanup(void)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
a2dp_vendor_ldac_feeding_reset(void)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
a2dp_vendor_ldac_feeding_flush(void)532 void a2dp_vendor_ldac_feeding_flush(void) {
533 a2dp_ldac_encoder_cb.ldac_feeding_state.counter = 0;
534 }
535
a2dp_vendor_ldac_get_encoder_interval_ms(void)536 period_ms_t a2dp_vendor_ldac_get_encoder_interval_ms(void) {
537 return A2DP_LDAC_ENCODER_INTERVAL_MS;
538 }
539
a2dp_vendor_ldac_send_frames(uint64_t timestamp_us)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.
a2dp_ldac_get_num_frame_iteration(uint8_t * num_of_iterations,uint8_t * num_of_frames,uint64_t timestamp_us)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
a2dp_ldac_encode_frames(uint8_t nb_frame)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
a2dp_ldac_read_feeding(uint8_t * read_buffer,uint32_t * bytes_read)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
quality_mode_index_to_name(int quality_mode_index)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
a2dp_vendor_ldac_set_transmit_queue_length(size_t transmit_queue_length)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
encoderIntervalMs() const762 period_ms_t A2dpCodecConfigLdac::encoderIntervalMs() const {
763 return a2dp_vendor_ldac_get_encoder_interval_ms();
764 }
765
getEffectiveMtu() const766 int A2dpCodecConfigLdac::getEffectiveMtu() const {
767 return a2dp_ldac_encoder_cb.TxAaMtuSize;
768 }
769
debug_codec_dump(int fd)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