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_aptx_encoder"
18
19 #include "a2dp_vendor_aptx_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.h"
28 #include "bt_common.h"
29 #include "osi/include/log.h"
30 #include "osi/include/osi.h"
31
32 //
33 // Encoder for aptX Source Codec
34 //
35
36 //
37 // The aptX encoder shared library, and the functions to use
38 //
39 static const char* APTX_ENCODER_LIB_NAME = "libaptX_encoder.so";
40 static void* aptx_encoder_lib_handle = NULL;
41
42 static const char* APTX_ENCODER_INIT_NAME = "aptxbtenc_init";
43 typedef int (*tAPTX_ENCODER_INIT)(void* state, short endian);
44
45 static const char* APTX_ENCODER_ENCODE_STEREO_NAME = "aptxbtenc_encodestereo";
46 typedef int (*tAPTX_ENCODER_ENCODE_STEREO)(void* state, void* pcmL, void* pcmR,
47 void* buffer);
48
49 static const char* APTX_ENCODER_SIZEOF_PARAMS_NAME = "SizeofAptxbtenc";
50 typedef int (*tAPTX_ENCODER_SIZEOF_PARAMS)(void);
51
52 static tAPTX_ENCODER_INIT aptx_encoder_init_func;
53 static tAPTX_ENCODER_ENCODE_STEREO aptx_encoder_encode_stereo_func;
54 static tAPTX_ENCODER_SIZEOF_PARAMS aptx_encoder_sizeof_params_func;
55
56 // offset
57 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
58 #define A2DP_APTX_OFFSET (AVDT_MEDIA_OFFSET + 1)
59 #else
60 // no RTP header for aptX classic
61 #define A2DP_APTX_OFFSET (AVDT_MEDIA_OFFSET - AVDT_MEDIA_HDR_SIZE)
62 #endif
63
64 #define A2DP_APTX_MAX_PCM_BYTES_PER_READ 4096
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_bytes;
71 uint32_t frame_size_counter;
72 } tAPTX_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_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_FRAMING_PARAMS framing_params;
98 void* aptx_encoder_state;
99 a2dp_aptx_encoder_stats_t stats;
100 } tA2DP_APTX_ENCODER_CB;
101
102 static tA2DP_APTX_ENCODER_CB a2dp_aptx_encoder_cb;
103
104 static void a2dp_vendor_aptx_encoder_update(uint16_t peer_mtu,
105 A2dpCodecConfig* a2dp_codec_config,
106 bool* p_restart_input,
107 bool* p_restart_output,
108 bool* p_config_updated);
109 static void aptx_init_framing_params(tAPTX_FRAMING_PARAMS* framing_params);
110 static void aptx_update_framing_params(tAPTX_FRAMING_PARAMS* framing_params);
111 static size_t aptx_encode_16bit(tAPTX_FRAMING_PARAMS* framing_params,
112 size_t* data_out_index, uint16_t* data16_in,
113 uint8_t* data_out);
114
A2DP_VendorLoadEncoderAptx(void)115 bool A2DP_VendorLoadEncoderAptx(void) {
116 if (aptx_encoder_lib_handle != NULL) return true; // Already loaded
117
118 // Open the encoder library
119 aptx_encoder_lib_handle = dlopen(APTX_ENCODER_LIB_NAME, RTLD_NOW);
120 if (aptx_encoder_lib_handle == NULL) {
121 LOG_ERROR(LOG_TAG, "%s: cannot open aptX encoder library %s: %s", __func__,
122 APTX_ENCODER_LIB_NAME, dlerror());
123 return false;
124 }
125
126 aptx_encoder_init_func = (tAPTX_ENCODER_INIT)dlsym(aptx_encoder_lib_handle,
127 APTX_ENCODER_INIT_NAME);
128 if (aptx_encoder_init_func == NULL) {
129 LOG_ERROR(LOG_TAG,
130 "%s: cannot find function '%s' in the encoder library: %s",
131 __func__, APTX_ENCODER_INIT_NAME, dlerror());
132 A2DP_VendorUnloadEncoderAptx();
133 return false;
134 }
135
136 aptx_encoder_encode_stereo_func = (tAPTX_ENCODER_ENCODE_STEREO)dlsym(
137 aptx_encoder_lib_handle, APTX_ENCODER_ENCODE_STEREO_NAME);
138 if (aptx_encoder_encode_stereo_func == NULL) {
139 LOG_ERROR(LOG_TAG,
140 "%s: cannot find function '%s' in the encoder library: %s",
141 __func__, APTX_ENCODER_ENCODE_STEREO_NAME, dlerror());
142 A2DP_VendorUnloadEncoderAptx();
143 return false;
144 }
145
146 aptx_encoder_sizeof_params_func = (tAPTX_ENCODER_SIZEOF_PARAMS)dlsym(
147 aptx_encoder_lib_handle, APTX_ENCODER_SIZEOF_PARAMS_NAME);
148 if (aptx_encoder_sizeof_params_func == NULL) {
149 LOG_ERROR(LOG_TAG,
150 "%s: cannot find function '%s' in the encoder library: %s",
151 __func__, APTX_ENCODER_SIZEOF_PARAMS_NAME, dlerror());
152 A2DP_VendorUnloadEncoderAptx();
153 return false;
154 }
155
156 return true;
157 }
158
A2DP_VendorUnloadEncoderAptx(void)159 void A2DP_VendorUnloadEncoderAptx(void) {
160 aptx_encoder_init_func = NULL;
161 aptx_encoder_encode_stereo_func = NULL;
162 aptx_encoder_sizeof_params_func = NULL;
163
164 if (aptx_encoder_lib_handle != NULL) {
165 dlclose(aptx_encoder_lib_handle);
166 aptx_encoder_lib_handle = NULL;
167 }
168 }
169
a2dp_vendor_aptx_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_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_encoder_cb, 0, sizeof(a2dp_aptx_encoder_cb));
176
177 a2dp_aptx_encoder_cb.stats.session_start_us = time_get_os_boottime_us();
178
179 a2dp_aptx_encoder_cb.read_callback = read_callback;
180 a2dp_aptx_encoder_cb.enqueue_callback = enqueue_callback;
181 a2dp_aptx_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr;
182 a2dp_aptx_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps;
183 a2dp_aptx_encoder_cb.peer_mtu = p_peer_params->peer_mtu;
184 a2dp_aptx_encoder_cb.timestamp = 0;
185
186 /* aptX encoder config */
187 a2dp_aptx_encoder_cb.use_SCMS_T = false; // TODO: should be a parameter
188 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
189 a2dp_aptx_encoder_cb.use_SCMS_T = true;
190 #endif
191
192 a2dp_aptx_encoder_cb.aptx_encoder_state =
193 osi_malloc(aptx_encoder_sizeof_params_func());
194 if (a2dp_aptx_encoder_cb.aptx_encoder_state != NULL) {
195 aptx_encoder_init_func(a2dp_aptx_encoder_cb.aptx_encoder_state, 0);
196 } else {
197 LOG_ERROR(LOG_TAG, "%s: Cannot allocate aptX encoder state", __func__);
198 // TODO: Return an error?
199 }
200
201 // NOTE: Ignore the restart_input / restart_output flags - this initization
202 // happens when the connection is (re)started.
203 bool restart_input = false;
204 bool restart_output = false;
205 bool config_updated = false;
206 a2dp_vendor_aptx_encoder_update(a2dp_aptx_encoder_cb.peer_mtu,
207 a2dp_codec_config, &restart_input,
208 &restart_output, &config_updated);
209 }
210
updateEncoderUserConfig(const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)211 bool A2dpCodecConfigAptx::updateEncoderUserConfig(
212 const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, bool* p_restart_input,
213 bool* p_restart_output, bool* p_config_updated) {
214 a2dp_aptx_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr;
215 a2dp_aptx_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps;
216 a2dp_aptx_encoder_cb.peer_mtu = p_peer_params->peer_mtu;
217 a2dp_aptx_encoder_cb.timestamp = 0;
218
219 if (a2dp_aptx_encoder_cb.peer_mtu == 0) {
220 LOG_ERROR(LOG_TAG,
221 "%s: Cannot update the codec encoder for %s: "
222 "invalid peer MTU",
223 __func__, name().c_str());
224 return false;
225 }
226
227 a2dp_vendor_aptx_encoder_update(a2dp_aptx_encoder_cb.peer_mtu, this,
228 p_restart_input, p_restart_output,
229 p_config_updated);
230 return true;
231 }
232
233 // Update the A2DP aptX encoder.
234 // |peer_mtu| is the peer MTU.
235 // |a2dp_codec_config| is the A2DP codec to use for the update.
a2dp_vendor_aptx_encoder_update(uint16_t peer_mtu,A2dpCodecConfig * a2dp_codec_config,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)236 static void a2dp_vendor_aptx_encoder_update(uint16_t peer_mtu,
237 A2dpCodecConfig* a2dp_codec_config,
238 bool* p_restart_input,
239 bool* p_restart_output,
240 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 = &a2dp_aptx_encoder_cb.feeding_params;
257 p_feeding_params->sample_rate =
258 A2DP_VendorGetTrackSampleRateAptx(p_codec_info);
259 p_feeding_params->bits_per_sample =
260 a2dp_codec_config->getAudioBitsPerSample();
261 p_feeding_params->channel_count =
262 A2DP_VendorGetTrackChannelCountAptx(p_codec_info);
263 LOG_DEBUG(LOG_TAG, "%s: sample_rate=%u bits_per_sample=%u channel_count=%u",
264 __func__, p_feeding_params->sample_rate,
265 p_feeding_params->bits_per_sample, p_feeding_params->channel_count);
266 a2dp_vendor_aptx_feeding_reset();
267 }
268
a2dp_vendor_aptx_encoder_cleanup(void)269 void a2dp_vendor_aptx_encoder_cleanup(void) {
270 osi_free(a2dp_aptx_encoder_cb.aptx_encoder_state);
271 memset(&a2dp_aptx_encoder_cb, 0, sizeof(a2dp_aptx_encoder_cb));
272 }
273
274 //
275 // Initialize the framing parameters, and set those that don't change
276 // while streaming (e.g., 'sleep_time_ns').
277 //
aptx_init_framing_params(tAPTX_FRAMING_PARAMS * framing_params)278 static void aptx_init_framing_params(tAPTX_FRAMING_PARAMS* framing_params) {
279 framing_params->sleep_time_ns = 0;
280 framing_params->pcm_reads = 0;
281 framing_params->pcm_bytes_per_read = 0;
282 framing_params->aptx_bytes = 0;
283 framing_params->frame_size_counter = 0;
284
285 if (a2dp_aptx_encoder_cb.feeding_params.sample_rate == 48000) {
286 if (a2dp_aptx_encoder_cb.use_SCMS_T) {
287 framing_params->sleep_time_ns = 13000000;
288 } else {
289 framing_params->sleep_time_ns = 14000000;
290 }
291 } else {
292 // Assume the sample rate is 44100
293 if (a2dp_aptx_encoder_cb.use_SCMS_T) {
294 framing_params->sleep_time_ns = 14000000;
295 } else {
296 framing_params->sleep_time_ns = 15000000;
297 }
298 }
299
300 LOG_DEBUG(LOG_TAG, "%s: sleep_time_ns = %" PRIu64, __func__,
301 framing_params->sleep_time_ns);
302 }
303
304 //
305 // Set frame size and transmission interval needed to stream the required
306 // sample rate using 2-DH5 packets for aptX and 2-DH3 packets for aptX-LL.
307 // With SCMS-T enabled we need to reserve room for extra headers added later.
308 // Packets are always sent at equals time intervals but to achieve the
309 // required sample rate, the frame size needs to change on occasion.
310 //
311 // Also need to specify how many of the required PCM samples are read at a
312 // time:
313 // aptx_bytes = pcm_reads * pcm_bytes_per_read / 4
314 // and
315 // number of aptX samples produced = pcm_bytes_per_read / 16
316 //
aptx_update_framing_params(tAPTX_FRAMING_PARAMS * framing_params)317 static void aptx_update_framing_params(tAPTX_FRAMING_PARAMS* framing_params) {
318 if (a2dp_aptx_encoder_cb.feeding_params.sample_rate == 48000) {
319 if (a2dp_aptx_encoder_cb.use_SCMS_T) {
320 framing_params->aptx_bytes = 624;
321 framing_params->pcm_bytes_per_read = 208;
322 framing_params->pcm_reads = 12;
323 } else {
324 framing_params->aptx_bytes = 672;
325 framing_params->pcm_bytes_per_read = 224;
326 framing_params->pcm_reads = 12;
327 }
328 } else {
329 // Assume the sample rate is 44100
330 if (a2dp_aptx_encoder_cb.use_SCMS_T) {
331 if (++framing_params->frame_size_counter < 20) {
332 framing_params->aptx_bytes = 616;
333 framing_params->pcm_bytes_per_read = 224;
334 framing_params->pcm_reads = 11;
335 } else {
336 framing_params->aptx_bytes = 644;
337 framing_params->pcm_bytes_per_read = 368;
338 framing_params->pcm_reads = 7;
339 framing_params->frame_size_counter = 0;
340 }
341 } else {
342 if (++framing_params->frame_size_counter < 8) {
343 framing_params->aptx_bytes = 660;
344 framing_params->pcm_bytes_per_read = 240;
345 framing_params->pcm_reads = 11;
346 } else {
347 framing_params->aptx_bytes = 672;
348 framing_params->pcm_bytes_per_read = 224;
349 framing_params->pcm_reads = 12;
350 framing_params->frame_size_counter = 0;
351 }
352 }
353 }
354
355 LOG_VERBOSE(LOG_TAG,
356 "%s: sleep_time_ns = %" PRIu64
357 " aptx_bytes = %u "
358 "pcm_bytes_per_read = %u pcm_reads = %u frame_size_counter = %u",
359 __func__, framing_params->sleep_time_ns,
360 framing_params->aptx_bytes, framing_params->pcm_bytes_per_read,
361 framing_params->pcm_reads, framing_params->frame_size_counter);
362 }
363
a2dp_vendor_aptx_feeding_reset(void)364 void a2dp_vendor_aptx_feeding_reset(void) {
365 aptx_init_framing_params(&a2dp_aptx_encoder_cb.framing_params);
366 }
367
a2dp_vendor_aptx_feeding_flush(void)368 void a2dp_vendor_aptx_feeding_flush(void) {
369 aptx_init_framing_params(&a2dp_aptx_encoder_cb.framing_params);
370 }
371
a2dp_vendor_aptx_get_encoder_interval_ms(void)372 period_ms_t a2dp_vendor_aptx_get_encoder_interval_ms(void) {
373 return a2dp_aptx_encoder_cb.framing_params.sleep_time_ns / (1000 * 1000);
374 }
375
a2dp_vendor_aptx_send_frames(uint64_t timestamp_us)376 void a2dp_vendor_aptx_send_frames(uint64_t timestamp_us) {
377 tAPTX_FRAMING_PARAMS* framing_params = &a2dp_aptx_encoder_cb.framing_params;
378
379 // Prepare the packet to send
380 BT_HDR* p_buf = (BT_HDR*)osi_malloc(BT_DEFAULT_BUFFER_SIZE);
381 p_buf->offset = A2DP_APTX_OFFSET;
382 p_buf->len = 0;
383 p_buf->layer_specific = 0;
384
385 uint8_t* encoded_ptr = (uint8_t*)(p_buf + 1);
386 encoded_ptr += p_buf->offset;
387
388 aptx_update_framing_params(framing_params);
389
390 //
391 // Read the PCM data and encode it
392 //
393 uint16_t read_buffer16[A2DP_APTX_MAX_PCM_BYTES_PER_READ / sizeof(uint16_t)];
394 uint32_t expected_read_bytes =
395 framing_params->pcm_reads * framing_params->pcm_bytes_per_read;
396 size_t encoded_ptr_index = 0;
397 size_t pcm_bytes_encoded = 0;
398 uint32_t bytes_read = 0;
399
400 a2dp_aptx_encoder_cb.stats.media_read_total_expected_packets++;
401 a2dp_aptx_encoder_cb.stats.media_read_total_expected_reads_count++;
402 a2dp_aptx_encoder_cb.stats.media_read_total_expected_read_bytes +=
403 expected_read_bytes;
404
405 LOG_VERBOSE(LOG_TAG, "%s: PCM read of size %u", __func__,
406 expected_read_bytes);
407 bytes_read = a2dp_aptx_encoder_cb.read_callback((uint8_t*)read_buffer16,
408 expected_read_bytes);
409 a2dp_aptx_encoder_cb.stats.media_read_total_actual_read_bytes += bytes_read;
410 if (bytes_read < expected_read_bytes) {
411 LOG_WARN(LOG_TAG,
412 "%s: underflow at PCM reading: read %u bytes instead of %u",
413 __func__, bytes_read, expected_read_bytes);
414 a2dp_aptx_encoder_cb.stats.media_read_total_dropped_packets++;
415 osi_free(p_buf);
416 return;
417 }
418 a2dp_aptx_encoder_cb.stats.media_read_total_actual_reads_count++;
419
420 for (uint32_t reads = 0, offset = 0; reads < framing_params->pcm_reads;
421 reads++, offset +=
422 (framing_params->pcm_bytes_per_read / sizeof(uint16_t))) {
423 pcm_bytes_encoded += aptx_encode_16bit(framing_params, &encoded_ptr_index,
424 read_buffer16 + offset, encoded_ptr);
425 }
426
427 // Compute the number of encoded bytes
428 const int COMPRESSION_RATIO = 4;
429 size_t encoded_bytes = pcm_bytes_encoded / COMPRESSION_RATIO;
430 p_buf->len += encoded_bytes;
431 LOG_VERBOSE(LOG_TAG, "%s: encoded %zu PCM bytes to %zu", __func__,
432 pcm_bytes_encoded, encoded_bytes);
433
434 // Update the RTP timestamp
435 *((uint32_t*)(p_buf + 1)) = a2dp_aptx_encoder_cb.timestamp;
436 const uint8_t BYTES_PER_FRAME = 2;
437 uint32_t rtp_timestamp =
438 (pcm_bytes_encoded / a2dp_aptx_encoder_cb.feeding_params.channel_count) /
439 BYTES_PER_FRAME;
440 a2dp_aptx_encoder_cb.timestamp += rtp_timestamp;
441
442 if (p_buf->len > 0) {
443 a2dp_aptx_encoder_cb.enqueue_callback(p_buf, 1, bytes_read);
444 } else {
445 a2dp_aptx_encoder_cb.stats.media_read_total_dropped_packets++;
446 osi_free(p_buf);
447 }
448 }
449
aptx_encode_16bit(tAPTX_FRAMING_PARAMS * framing_params,size_t * data_out_index,uint16_t * data16_in,uint8_t * data_out)450 static size_t aptx_encode_16bit(tAPTX_FRAMING_PARAMS* framing_params,
451 size_t* data_out_index, uint16_t* data16_in,
452 uint8_t* data_out) {
453 size_t pcm_bytes_encoded = 0;
454 size_t frame = 0;
455
456 for (size_t aptx_samples = 0;
457 aptx_samples < framing_params->pcm_bytes_per_read / 16; aptx_samples++) {
458 uint32_t pcmL[4];
459 uint32_t pcmR[4];
460 uint16_t encoded_sample[2];
461
462 for (size_t i = 0, j = frame; i < 4; i++, j++) {
463 pcmL[i] = (uint16_t) * (data16_in + (2 * j));
464 pcmR[i] = (uint16_t) * (data16_in + ((2 * j) + 1));
465 }
466
467 aptx_encoder_encode_stereo_func(a2dp_aptx_encoder_cb.aptx_encoder_state,
468 &pcmL, &pcmR, &encoded_sample);
469
470 data_out[*data_out_index + 0] = (uint8_t)((encoded_sample[0] >> 8) & 0xff);
471 data_out[*data_out_index + 1] = (uint8_t)((encoded_sample[0] >> 0) & 0xff);
472 data_out[*data_out_index + 2] = (uint8_t)((encoded_sample[1] >> 8) & 0xff);
473 data_out[*data_out_index + 3] = (uint8_t)((encoded_sample[1] >> 0) & 0xff);
474
475 frame += 4;
476 pcm_bytes_encoded += 16;
477 *data_out_index += 4;
478 }
479
480 return pcm_bytes_encoded;
481 }
482
encoderIntervalMs() const483 period_ms_t A2dpCodecConfigAptx::encoderIntervalMs() const {
484 return a2dp_vendor_aptx_get_encoder_interval_ms();
485 }
486
getEffectiveMtu() const487 int A2dpCodecConfigAptx::getEffectiveMtu() const {
488 return a2dp_aptx_encoder_cb.peer_mtu;
489 }
490
debug_codec_dump(int fd)491 void A2dpCodecConfigAptx::debug_codec_dump(int fd) {
492 a2dp_aptx_encoder_stats_t* stats = &a2dp_aptx_encoder_cb.stats;
493
494 A2dpCodecConfig::debug_codec_dump(fd);
495
496 dprintf(fd,
497 " Packet counts (expected/dropped) : %zu / "
498 "%zu\n",
499 stats->media_read_total_expected_packets,
500 stats->media_read_total_dropped_packets);
501
502 dprintf(fd,
503 " PCM read counts (expected/actual) : %zu / "
504 "%zu\n",
505 stats->media_read_total_expected_reads_count,
506 stats->media_read_total_actual_reads_count);
507
508 dprintf(fd,
509 " PCM read bytes (expected/actual) : %zu / "
510 "%zu\n",
511 stats->media_read_total_expected_read_bytes,
512 stats->media_read_total_actual_read_bytes);
513 }
514