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_aptx_hd_encoder"
18 
19 #include "a2dp_vendor_aptx_hd_encoder.h"
20 
21 #include <dlfcn.h>
22 #include <inttypes.h>
23 #include <stdio.h>
24 #include <string.h>
25 
26 #include "a2dp_vendor.h"
27 #include "a2dp_vendor_aptx_hd.h"
28 #include "bt_common.h"
29 #include "osi/include/log.h"
30 #include "osi/include/osi.h"
31 
32 //
33 // Encoder for aptX-HD Source Codec
34 //
35 
36 //
37 // The aptX-HD encoder shared library, and the functions to use
38 //
39 static const char* APTX_HD_ENCODER_LIB_NAME = "libaptXHD_encoder.so";
40 static void* aptx_hd_encoder_lib_handle = NULL;
41 
42 static const char* APTX_HD_ENCODER_INIT_NAME = "aptxhdbtenc_init";
43 typedef int (*tAPTX_HD_ENCODER_INIT)(void* state, short endian);
44 
45 static const char* APTX_HD_ENCODER_ENCODE_STEREO_NAME =
46     "aptxhdbtenc_encodestereo";
47 typedef int (*tAPTX_HD_ENCODER_ENCODE_STEREO)(void* state, void* pcmL,
48                                               void* pcmR, void* buffer);
49 
50 static const char* APTX_HD_ENCODER_SIZEOF_PARAMS_NAME = "SizeofAptxhdbtenc";
51 typedef int (*tAPTX_HD_ENCODER_SIZEOF_PARAMS)(void);
52 
53 static tAPTX_HD_ENCODER_INIT aptx_hd_encoder_init_func;
54 static tAPTX_HD_ENCODER_ENCODE_STEREO aptx_hd_encoder_encode_stereo_func;
55 static tAPTX_HD_ENCODER_SIZEOF_PARAMS aptx_hd_encoder_sizeof_params_func;
56 
57 // offset
58 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
59 #define A2DP_APTX_HD_OFFSET (AVDT_MEDIA_OFFSET + 1)
60 #else
61 #define A2DP_APTX_HD_OFFSET AVDT_MEDIA_OFFSET
62 #endif
63 
64 #define A2DP_APTX_HD_MAX_PCM_BYTES_PER_READ 1024
65 
66 typedef struct {
67   uint64_t sleep_time_ns;
68   uint32_t pcm_reads;
69   uint32_t pcm_bytes_per_read;
70   uint32_t aptx_hd_bytes;
71   uint32_t frame_size_counter;
72 } tAPTX_HD_FRAMING_PARAMS;
73 
74 typedef struct {
75   uint64_t session_start_us;
76 
77   size_t media_read_total_expected_packets;
78   size_t media_read_total_expected_reads_count;
79   size_t media_read_total_expected_read_bytes;
80 
81   size_t media_read_total_dropped_packets;
82   size_t media_read_total_actual_reads_count;
83   size_t media_read_total_actual_read_bytes;
84 } a2dp_aptx_hd_encoder_stats_t;
85 
86 typedef struct {
87   a2dp_source_read_callback_t read_callback;
88   a2dp_source_enqueue_callback_t enqueue_callback;
89 
90   bool use_SCMS_T;
91   bool is_peer_edr;          // True if the peer device supports EDR
92   bool peer_supports_3mbps;  // True if the peer device supports 3Mbps EDR
93   uint16_t peer_mtu;         // // MTU of the A2DP peer
94   uint32_t timestamp;        // Timestamp for the A2DP frames
95 
96   tA2DP_FEEDING_PARAMS feeding_params;
97   tAPTX_HD_FRAMING_PARAMS framing_params;
98   void* aptx_hd_encoder_state;
99   a2dp_aptx_hd_encoder_stats_t stats;
100 } tA2DP_APTX_HD_ENCODER_CB;
101 
102 static tA2DP_APTX_HD_ENCODER_CB a2dp_aptx_hd_encoder_cb;
103 
104 static void a2dp_vendor_aptx_hd_encoder_update(
105     uint16_t peer_mtu, A2dpCodecConfig* a2dp_codec_config,
106     bool* p_restart_input, bool* p_restart_output, bool* p_config_updated);
107 static void aptx_hd_init_framing_params(
108     tAPTX_HD_FRAMING_PARAMS* framing_params);
109 static void aptx_hd_update_framing_params(
110     tAPTX_HD_FRAMING_PARAMS* framing_params);
111 static size_t aptx_hd_encode_24bit(tAPTX_HD_FRAMING_PARAMS* framing_params,
112                                    size_t* data_out_index, uint32_t* data32_in,
113                                    uint8_t* data_out);
114 
A2DP_VendorLoadEncoderAptxHd(void)115 bool A2DP_VendorLoadEncoderAptxHd(void) {
116   if (aptx_hd_encoder_lib_handle != NULL) return true;  // Already loaded
117 
118   // Open the encoder library
119   aptx_hd_encoder_lib_handle = dlopen(APTX_HD_ENCODER_LIB_NAME, RTLD_NOW);
120   if (aptx_hd_encoder_lib_handle == NULL) {
121     LOG_ERROR(LOG_TAG, "%s: cannot open aptX-HD encoder library %s: %s",
122               __func__, APTX_HD_ENCODER_LIB_NAME, dlerror());
123     return false;
124   }
125 
126   aptx_hd_encoder_init_func = (tAPTX_HD_ENCODER_INIT)dlsym(
127       aptx_hd_encoder_lib_handle, APTX_HD_ENCODER_INIT_NAME);
128   if (aptx_hd_encoder_init_func == NULL) {
129     LOG_ERROR(LOG_TAG,
130               "%s: cannot find function '%s' in the encoder library: %s",
131               __func__, APTX_HD_ENCODER_INIT_NAME, dlerror());
132     A2DP_VendorUnloadEncoderAptxHd();
133     return false;
134   }
135 
136   aptx_hd_encoder_encode_stereo_func = (tAPTX_HD_ENCODER_ENCODE_STEREO)dlsym(
137       aptx_hd_encoder_lib_handle, APTX_HD_ENCODER_ENCODE_STEREO_NAME);
138   if (aptx_hd_encoder_encode_stereo_func == NULL) {
139     LOG_ERROR(LOG_TAG,
140               "%s: cannot find function '%s' in the encoder library: %s",
141               __func__, APTX_HD_ENCODER_ENCODE_STEREO_NAME, dlerror());
142     A2DP_VendorUnloadEncoderAptxHd();
143     return false;
144   }
145 
146   aptx_hd_encoder_sizeof_params_func = (tAPTX_HD_ENCODER_SIZEOF_PARAMS)dlsym(
147       aptx_hd_encoder_lib_handle, APTX_HD_ENCODER_SIZEOF_PARAMS_NAME);
148   if (aptx_hd_encoder_sizeof_params_func == NULL) {
149     LOG_ERROR(LOG_TAG,
150               "%s: cannot find function '%s' in the encoder library: %s",
151               __func__, APTX_HD_ENCODER_SIZEOF_PARAMS_NAME, dlerror());
152     A2DP_VendorUnloadEncoderAptxHd();
153     return false;
154   }
155 
156   return true;
157 }
158 
A2DP_VendorUnloadEncoderAptxHd(void)159 void A2DP_VendorUnloadEncoderAptxHd(void) {
160   aptx_hd_encoder_init_func = NULL;
161   aptx_hd_encoder_encode_stereo_func = NULL;
162   aptx_hd_encoder_sizeof_params_func = NULL;
163 
164   if (aptx_hd_encoder_lib_handle != NULL) {
165     dlclose(aptx_hd_encoder_lib_handle);
166     aptx_hd_encoder_lib_handle = NULL;
167   }
168 }
169 
a2dp_vendor_aptx_hd_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)170 void a2dp_vendor_aptx_hd_encoder_init(
171     const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params,
172     A2dpCodecConfig* a2dp_codec_config,
173     a2dp_source_read_callback_t read_callback,
174     a2dp_source_enqueue_callback_t enqueue_callback) {
175   memset(&a2dp_aptx_hd_encoder_cb, 0, sizeof(a2dp_aptx_hd_encoder_cb));
176 
177   a2dp_aptx_hd_encoder_cb.stats.session_start_us = time_get_os_boottime_us();
178 
179   a2dp_aptx_hd_encoder_cb.read_callback = read_callback;
180   a2dp_aptx_hd_encoder_cb.enqueue_callback = enqueue_callback;
181   a2dp_aptx_hd_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr;
182   a2dp_aptx_hd_encoder_cb.peer_supports_3mbps =
183       p_peer_params->peer_supports_3mbps;
184   a2dp_aptx_hd_encoder_cb.peer_mtu = p_peer_params->peer_mtu;
185   a2dp_aptx_hd_encoder_cb.timestamp = 0;
186 
187   /* aptX-HD encoder config */
188   a2dp_aptx_hd_encoder_cb.use_SCMS_T = false;  // TODO: should be a parameter
189 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
190   a2dp_aptx_hd_encoder_cb.use_SCMS_T = true;
191 #endif
192 
193   a2dp_aptx_hd_encoder_cb.aptx_hd_encoder_state =
194       osi_malloc(aptx_hd_encoder_sizeof_params_func());
195   if (a2dp_aptx_hd_encoder_cb.aptx_hd_encoder_state != NULL) {
196     aptx_hd_encoder_init_func(a2dp_aptx_hd_encoder_cb.aptx_hd_encoder_state, 0);
197   } else {
198     LOG_ERROR(LOG_TAG, "%s: Cannot allocate aptX-HD encoder state", __func__);
199     // TODO: Return an error?
200   }
201 
202   // NOTE: Ignore the restart_input / restart_output flags - this initization
203   // happens when the connection is (re)started.
204   bool restart_input = false;
205   bool restart_output = false;
206   bool config_updated = false;
207   a2dp_vendor_aptx_hd_encoder_update(a2dp_aptx_hd_encoder_cb.peer_mtu,
208                                      a2dp_codec_config, &restart_input,
209                                      &restart_output, &config_updated);
210 }
211 
updateEncoderUserConfig(const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)212 bool A2dpCodecConfigAptxHd::updateEncoderUserConfig(
213     const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, bool* p_restart_input,
214     bool* p_restart_output, bool* p_config_updated) {
215   a2dp_aptx_hd_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr;
216   a2dp_aptx_hd_encoder_cb.peer_supports_3mbps =
217       p_peer_params->peer_supports_3mbps;
218   a2dp_aptx_hd_encoder_cb.peer_mtu = p_peer_params->peer_mtu;
219   a2dp_aptx_hd_encoder_cb.timestamp = 0;
220 
221   if (a2dp_aptx_hd_encoder_cb.peer_mtu == 0) {
222     LOG_ERROR(LOG_TAG,
223               "%s: Cannot update the codec encoder for %s: "
224               "invalid peer MTU",
225               __func__, name().c_str());
226     return false;
227   }
228 
229   a2dp_vendor_aptx_hd_encoder_update(a2dp_aptx_hd_encoder_cb.peer_mtu, this,
230                                      p_restart_input, p_restart_output,
231                                      p_config_updated);
232   return true;
233 }
234 
235 // Update the A2DP aptX-HD encoder.
236 // |peer_mtu| is the peer MTU.
237 // |a2dp_codec_config| is the A2DP codec to use for the update.
a2dp_vendor_aptx_hd_encoder_update(uint16_t peer_mtu,A2dpCodecConfig * a2dp_codec_config,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)238 static void a2dp_vendor_aptx_hd_encoder_update(
239     uint16_t peer_mtu, A2dpCodecConfig* a2dp_codec_config,
240     bool* p_restart_input, bool* p_restart_output, bool* p_config_updated) {
241   uint8_t codec_info[AVDT_CODEC_SIZE];
242 
243   *p_restart_input = false;
244   *p_restart_output = false;
245   *p_config_updated = false;
246   if (!a2dp_codec_config->copyOutOtaCodecConfig(codec_info)) {
247     LOG_ERROR(LOG_TAG,
248               "%s: Cannot update the codec encoder for %s: "
249               "invalid codec config",
250               __func__, a2dp_codec_config->name().c_str());
251     return;
252   }
253   const uint8_t* p_codec_info = codec_info;
254 
255   // The feeding parameters
256   tA2DP_FEEDING_PARAMS* p_feeding_params =
257       &a2dp_aptx_hd_encoder_cb.feeding_params;
258   p_feeding_params->sample_rate =
259       A2DP_VendorGetTrackSampleRateAptxHd(p_codec_info);
260   p_feeding_params->bits_per_sample =
261       A2DP_VendorGetTrackBitsPerSampleAptxHd(p_codec_info);
262   p_feeding_params->channel_count =
263       A2DP_VendorGetTrackChannelCountAptxHd(p_codec_info);
264   LOG_DEBUG(LOG_TAG, "%s: sample_rate=%u bits_per_sample=%u channel_count=%u",
265             __func__, p_feeding_params->sample_rate,
266             p_feeding_params->bits_per_sample, p_feeding_params->channel_count);
267 
268   aptx_hd_init_framing_params(&a2dp_aptx_hd_encoder_cb.framing_params);
269 }
270 
a2dp_vendor_aptx_hd_encoder_cleanup(void)271 void a2dp_vendor_aptx_hd_encoder_cleanup(void) {
272   osi_free(a2dp_aptx_hd_encoder_cb.aptx_hd_encoder_state);
273   memset(&a2dp_aptx_hd_encoder_cb, 0, sizeof(a2dp_aptx_hd_encoder_cb));
274 }
275 
276 //
277 // Initialize the framing parameters, and set those that don't change
278 // while streaming (e.g., 'sleep_time_ns').
279 //
aptx_hd_init_framing_params(tAPTX_HD_FRAMING_PARAMS * framing_params)280 static void aptx_hd_init_framing_params(
281     tAPTX_HD_FRAMING_PARAMS* framing_params) {
282   framing_params->sleep_time_ns = 0;
283   framing_params->pcm_reads = 0;
284   framing_params->pcm_bytes_per_read = 0;
285   framing_params->aptx_hd_bytes = 0;
286   framing_params->frame_size_counter = 0;
287 
288   framing_params->sleep_time_ns = 9000000;
289 
290   LOG_DEBUG(LOG_TAG, "%s: sleep_time_ns = %" PRIu64, __func__,
291             framing_params->sleep_time_ns);
292 }
293 
294 //
295 // Set frame size and transmission interval needed to stream the required
296 // sample rate using 2-DH5 packets for aptX and 2-DH3 packets for aptX-LL.
297 // With SCMS-T enabled we need to reserve room for extra headers added later.
298 // Packets are always sent at equals time intervals but to achieve the
299 // required sample rate, the frame size needs to change on occasion.
300 //
301 // Also need to specify how many of the required PCM samples are read at a
302 // time:
303 //     aptx_bytes = pcm_reads * pcm_bytes_per_read / 4
304 // and
305 //     number of aptX samples produced = pcm_bytes_per_read / 16
306 //
aptx_hd_update_framing_params(tAPTX_HD_FRAMING_PARAMS * framing_params)307 static void aptx_hd_update_framing_params(
308     tAPTX_HD_FRAMING_PARAMS* framing_params) {
309   if (a2dp_aptx_hd_encoder_cb.feeding_params.sample_rate == 48000) {
310     framing_params->aptx_hd_bytes = 648;
311     framing_params->pcm_bytes_per_read = 24;
312     framing_params->pcm_reads = 108;
313   } else {
314     // Assume the sample rate is 44100
315 
316     //
317     // Total of 80 iterations:
318     // - Iteration 80: packet size 648, with 108 reads of 24 PCM bytes
319     // - Iterations 20, 40, 60: packet size 612, with 102 reads of 24 PCM bytes
320     // - All other iterations: packet size 594, with 99 reads of 24 PCM bytes
321     //
322     if (framing_params->frame_size_counter + 1 == 80) {
323       framing_params->aptx_hd_bytes = 648;
324       framing_params->pcm_bytes_per_read = 24;
325       framing_params->pcm_reads = 108;
326     } else if (((framing_params->frame_size_counter + 1) % 20) == 0) {
327       framing_params->aptx_hd_bytes = 612;
328       framing_params->pcm_bytes_per_read = 24;
329       framing_params->pcm_reads = 102;
330     } else {
331       framing_params->aptx_hd_bytes = 594;
332       framing_params->pcm_bytes_per_read = 24;
333       framing_params->pcm_reads = 99;
334     }
335     framing_params->frame_size_counter++;
336     if (framing_params->frame_size_counter == 80)
337       framing_params->frame_size_counter = 0;
338   }
339 
340   LOG_VERBOSE(LOG_TAG,
341               "%s: sleep_time_ns = %" PRIu64
342               " aptx_hd_bytes = %u "
343               "pcm_bytes_per_read = %u pcm_reads = %u frame_size_counter = %u",
344               __func__, framing_params->sleep_time_ns,
345               framing_params->aptx_hd_bytes, framing_params->pcm_bytes_per_read,
346               framing_params->pcm_reads, framing_params->frame_size_counter);
347 }
348 
a2dp_vendor_aptx_hd_feeding_reset(void)349 void a2dp_vendor_aptx_hd_feeding_reset(void) {
350   aptx_hd_init_framing_params(&a2dp_aptx_hd_encoder_cb.framing_params);
351 }
352 
a2dp_vendor_aptx_hd_feeding_flush(void)353 void a2dp_vendor_aptx_hd_feeding_flush(void) {
354   aptx_hd_init_framing_params(&a2dp_aptx_hd_encoder_cb.framing_params);
355 }
356 
a2dp_vendor_aptx_hd_get_encoder_interval_ms(void)357 period_ms_t a2dp_vendor_aptx_hd_get_encoder_interval_ms(void) {
358   return a2dp_aptx_hd_encoder_cb.framing_params.sleep_time_ns / (1000 * 1000);
359 }
360 
a2dp_vendor_aptx_hd_send_frames(uint64_t timestamp_us)361 void a2dp_vendor_aptx_hd_send_frames(uint64_t timestamp_us) {
362   tAPTX_HD_FRAMING_PARAMS* framing_params =
363       &a2dp_aptx_hd_encoder_cb.framing_params;
364 
365   // Prepare the packet to send
366   BT_HDR* p_buf = (BT_HDR*)osi_malloc(BT_DEFAULT_BUFFER_SIZE);
367   p_buf->offset = A2DP_APTX_HD_OFFSET;
368   p_buf->len = 0;
369   p_buf->layer_specific = 0;
370 
371   uint8_t* encoded_ptr = (uint8_t*)(p_buf + 1);
372   encoded_ptr += p_buf->offset;
373 
374   aptx_hd_update_framing_params(framing_params);
375 
376   //
377   // Read the PCM data and encode it
378   //
379   LOG_VERBOSE(LOG_TAG, "%s: %u PCM reads of size %u", __func__,
380               framing_params->pcm_reads, framing_params->pcm_bytes_per_read);
381   size_t encoded_ptr_index = 0;
382   size_t pcm_bytes_encoded = 0;
383   a2dp_aptx_hd_encoder_cb.stats.media_read_total_expected_packets++;
384   a2dp_aptx_hd_encoder_cb.stats.media_read_total_expected_reads_count +=
385       framing_params->pcm_reads;
386   a2dp_aptx_hd_encoder_cb.stats.media_read_total_expected_read_bytes +=
387       framing_params->pcm_reads * framing_params->pcm_bytes_per_read;
388   for (size_t reads = 0; reads < framing_params->pcm_reads; reads++) {
389     uint32_t
390         read_buffer32[A2DP_APTX_HD_MAX_PCM_BYTES_PER_READ / sizeof(uint32_t)];
391     size_t pcm_bytes_read = a2dp_aptx_hd_encoder_cb.read_callback(
392         (uint8_t*)read_buffer32, framing_params->pcm_bytes_per_read);
393     a2dp_aptx_hd_encoder_cb.stats.media_read_total_actual_read_bytes +=
394         pcm_bytes_read;
395     if (pcm_bytes_read < framing_params->pcm_bytes_per_read) {
396       LOG_WARN(LOG_TAG,
397                "%s: underflow at PCM reading iteration %zu: read %zu "
398                "instead of %d",
399                __func__, reads, pcm_bytes_read,
400                framing_params->pcm_bytes_per_read);
401       break;
402     }
403     a2dp_aptx_hd_encoder_cb.stats.media_read_total_actual_reads_count++;
404     pcm_bytes_encoded += aptx_hd_encode_24bit(
405         framing_params, &encoded_ptr_index, read_buffer32, encoded_ptr);
406   }
407 
408   // Compute the number of encoded bytes
409   const int COMPRESSION_RATIO = 4;
410   size_t encoded_bytes = pcm_bytes_encoded / COMPRESSION_RATIO;
411   p_buf->len += encoded_bytes;
412   LOG_VERBOSE(LOG_TAG, "%s: encoded %zu PCM bytes to %zu", __func__,
413               pcm_bytes_encoded, encoded_bytes);
414 
415   // Update the RTP timestamp
416   *((uint32_t*)(p_buf + 1)) = a2dp_aptx_hd_encoder_cb.timestamp;
417   const uint8_t BYTES_PER_FRAME = 3;
418   uint32_t rtp_timestamp =
419       (pcm_bytes_encoded /
420        a2dp_aptx_hd_encoder_cb.feeding_params.channel_count) /
421       BYTES_PER_FRAME;
422   a2dp_aptx_hd_encoder_cb.timestamp += rtp_timestamp;
423 
424   if (p_buf->len > 0) {
425     a2dp_aptx_hd_encoder_cb.enqueue_callback(p_buf, 1);
426   } else {
427     a2dp_aptx_hd_encoder_cb.stats.media_read_total_dropped_packets++;
428     osi_free(p_buf);
429   }
430 }
431 
aptx_hd_encode_24bit(tAPTX_HD_FRAMING_PARAMS * framing_params,size_t * data_out_index,uint32_t * data32_in,uint8_t * data_out)432 static size_t aptx_hd_encode_24bit(tAPTX_HD_FRAMING_PARAMS* framing_params,
433                                    size_t* data_out_index, uint32_t* data32_in,
434                                    uint8_t* data_out) {
435   size_t pcm_bytes_encoded = 0;
436   const uint8_t* p = (const uint8_t*)(data32_in);
437 
438   for (size_t aptx_hd_samples = 0;
439        aptx_hd_samples < framing_params->pcm_bytes_per_read / 24;
440        aptx_hd_samples++) {
441     uint32_t pcmL[4];
442     uint32_t pcmR[4];
443     uint32_t encoded_sample[2];
444 
445     // Expand from AUDIO_FORMAT_PCM_24_BIT_PACKED data (3 bytes per sample)
446     // into AUDIO_FORMAT_PCM_8_24_BIT (4 bytes per sample).
447     for (size_t i = 0; i < 4; i++) {
448       pcmL[i] = ((p[0] << 0) | (p[1] << 8) | (((int8_t)p[2]) << 16));
449       p += 3;
450       pcmR[i] = ((p[0] << 0) | (p[1] << 8) | (((int8_t)p[2]) << 16));
451       p += 3;
452     }
453 
454     aptx_hd_encoder_encode_stereo_func(
455         a2dp_aptx_hd_encoder_cb.aptx_hd_encoder_state, &pcmL, &pcmR,
456         &encoded_sample);
457 
458     uint8_t* encoded_ptr = (uint8_t*)&encoded_sample[0];
459     data_out[*data_out_index + 0] = *(encoded_ptr + 2);
460     data_out[*data_out_index + 1] = *(encoded_ptr + 1);
461     data_out[*data_out_index + 2] = *(encoded_ptr + 0);
462     data_out[*data_out_index + 3] = *(encoded_ptr + 6);
463     data_out[*data_out_index + 4] = *(encoded_ptr + 5);
464     data_out[*data_out_index + 5] = *(encoded_ptr + 4);
465 
466     pcm_bytes_encoded += 24;
467     *data_out_index += 6;
468   }
469 
470   return pcm_bytes_encoded;
471 }
472 
encoderIntervalMs() const473 period_ms_t A2dpCodecConfigAptxHd::encoderIntervalMs() const {
474   return a2dp_vendor_aptx_hd_get_encoder_interval_ms();
475 }
476 
debug_codec_dump(int fd)477 void A2dpCodecConfigAptxHd::debug_codec_dump(int fd) {
478   a2dp_aptx_hd_encoder_stats_t* stats = &a2dp_aptx_hd_encoder_cb.stats;
479 
480   A2dpCodecConfig::debug_codec_dump(fd);
481 
482   dprintf(fd,
483           "  Packet counts (expected/dropped)                        : %zu / "
484           "%zu\n",
485           stats->media_read_total_expected_packets,
486           stats->media_read_total_dropped_packets);
487 
488   dprintf(fd,
489           "  PCM read counts (expected/actual)                       : %zu / "
490           "%zu\n",
491           stats->media_read_total_expected_reads_count,
492           stats->media_read_total_actual_reads_count);
493 
494   dprintf(fd,
495           "  PCM read bytes (expected/actual)                        : %zu / "
496           "%zu\n",
497           stats->media_read_total_expected_read_bytes,
498           stats->media_read_total_actual_read_bytes);
499 }
500