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
load_func(const char * func_name)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
A2DP_VendorLoadEncoderLdac(void)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
A2DP_VendorUnloadEncoderLdac(void)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
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)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
updateEncoderUserConfig(const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)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.
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)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
a2dp_vendor_ldac_encoder_cleanup(void)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
a2dp_vendor_ldac_feeding_reset(void)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
a2dp_vendor_ldac_feeding_flush(void)521 void a2dp_vendor_ldac_feeding_flush(void) {
522 a2dp_ldac_encoder_cb.ldac_feeding_state.counter = 0;
523 }
524
a2dp_vendor_ldac_get_encoder_interval_ms(void)525 period_ms_t a2dp_vendor_ldac_get_encoder_interval_ms(void) {
526 return A2DP_LDAC_ENCODER_INTERVAL_MS;
527 }
528
a2dp_vendor_ldac_send_frames(uint64_t timestamp_us)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.
a2dp_ldac_get_num_frame_iteration(uint8_t * num_of_iterations,uint8_t * num_of_frames,uint64_t timestamp_us)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
a2dp_ldac_encode_frames(uint8_t nb_frame)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
a2dp_ldac_read_feeding(uint8_t * read_buffer)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
quality_mode_index_to_name(int quality_mode_index)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
a2dp_vendor_ldac_set_transmit_queue_length(size_t transmit_queue_length)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
encoderIntervalMs() const741 period_ms_t A2dpCodecConfigLdac::encoderIntervalMs() const {
742 return a2dp_vendor_ldac_get_encoder_interval_ms();
743 }
744
debug_codec_dump(int fd)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