1 /******************************************************************************
2 *
3 * Copyright (C) 2009-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 **
21 ** Name: btif_media_task.c
22 **
23 ** Description: This is the multimedia module for the BTIF system. It
24 ** contains task implementations AV, HS and HF profiles
25 ** audio & video processing
26 **
27 ******************************************************************************/
28
29 #define LOG_TAG "bt_btif_media"
30
31 #include <assert.h>
32 #include <fcntl.h>
33 #include <limits.h>
34 #include <pthread.h>
35 #include <stdint.h>
36 #include <stdio.h>
37 #include <string.h>
38 #include <sys/stat.h>
39 #include <sys/time.h>
40 #include <sys/types.h>
41 #include <unistd.h>
42
43 #include <hardware/bluetooth.h>
44
45 #include "a2d_api.h"
46 #include "a2d_int.h"
47 #include "a2d_sbc.h"
48 #include "audio_a2dp_hw.h"
49 #include "bt_target.h"
50 #include "bta_api.h"
51 #include "bta_av_api.h"
52 #include "bta_av_ci.h"
53 #include "bta_av_sbc.h"
54 #include "bta_sys.h"
55 #include "bta_sys_int.h"
56 #include "btif_av.h"
57 #include "btif_av_co.h"
58 #include "btif_media.h"
59 #include "btif_sm.h"
60 #include "btif_util.h"
61 #include "btu.h"
62 #include "bt_common.h"
63 #include "device/include/controller.h"
64 #include "l2c_api.h"
65 #include "osi/include/alarm.h"
66 #include "osi/include/fixed_queue.h"
67 #include "osi/include/log.h"
68 #include "osi/include/metrics.h"
69 #include "osi/include/mutex.h"
70 #include "osi/include/thread.h"
71
72 #if (BTA_AV_INCLUDED == TRUE)
73 #include "sbc_encoder.h"
74 #endif
75
76 #if (BTA_AV_SINK_INCLUDED == TRUE)
77 #include "oi_codec_sbc.h"
78 #include "oi_status.h"
79 #endif
80
81 #ifdef USE_AUDIO_TRACK
82 #include "btif_avrcp_audio_track.h"
83 #endif
84
85 #if (BTA_AV_SINK_INCLUDED == TRUE)
86 OI_CODEC_SBC_DECODER_CONTEXT context;
87 OI_UINT32 contextData[CODEC_DATA_WORDS(2, SBC_CODEC_FAST_FILTER_BUFFERS)];
88 OI_INT16 pcmData[15*SBC_MAX_SAMPLES_PER_FRAME*SBC_MAX_CHANNELS];
89 #endif
90
91 /*****************************************************************************
92 ** Constants
93 *****************************************************************************/
94 #ifndef AUDIO_CHANNEL_OUT_MONO
95 #define AUDIO_CHANNEL_OUT_MONO 0x01
96 #endif
97
98 #ifndef AUDIO_CHANNEL_OUT_STEREO
99 #define AUDIO_CHANNEL_OUT_STEREO 0x03
100 #endif
101
102 /* BTIF media cmd event definition : BTIF_MEDIA_TASK_CMD */
103 enum
104 {
105 BTIF_MEDIA_START_AA_TX = 1,
106 BTIF_MEDIA_STOP_AA_TX,
107 BTIF_MEDIA_AA_RX_RDY,
108 BTIF_MEDIA_UIPC_RX_RDY,
109 BTIF_MEDIA_SBC_ENC_INIT,
110 BTIF_MEDIA_SBC_ENC_UPDATE,
111 BTIF_MEDIA_SBC_DEC_INIT,
112 BTIF_MEDIA_VIDEO_DEC_INIT,
113 BTIF_MEDIA_FLUSH_AA_TX,
114 BTIF_MEDIA_FLUSH_AA_RX,
115 BTIF_MEDIA_AUDIO_FEEDING_INIT,
116 BTIF_MEDIA_AUDIO_RECEIVING_INIT,
117 BTIF_MEDIA_AUDIO_SINK_CFG_UPDATE,
118 BTIF_MEDIA_AUDIO_SINK_CLEAR_TRACK,
119 BTIF_MEDIA_AUDIO_SINK_SET_FOCUS_STATE
120 };
121
122 enum {
123 MEDIA_TASK_STATE_OFF = 0,
124 MEDIA_TASK_STATE_ON = 1,
125 MEDIA_TASK_STATE_SHUTTING_DOWN = 2
126 };
127
128 /* Macro to multiply the media task tick */
129 #ifndef BTIF_MEDIA_NUM_TICK
130 #define BTIF_MEDIA_NUM_TICK 1
131 #endif
132
133 /* Media task tick in milliseconds, must be set to multiple of
134 (1000/TICKS_PER_SEC) (10) */
135
136 #define BTIF_MEDIA_TIME_TICK (20 * BTIF_MEDIA_NUM_TICK)
137 #define A2DP_DATA_READ_POLL_MS (BTIF_MEDIA_TIME_TICK / 2)
138 #define BTIF_SINK_MEDIA_TIME_TICK_MS (20 * BTIF_MEDIA_NUM_TICK)
139
140
141 /* buffer pool */
142 #define BTIF_MEDIA_AA_BUF_SIZE BT_DEFAULT_BUFFER_SIZE
143
144 /* offset */
145 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
146 #define BTIF_MEDIA_AA_SBC_OFFSET (AVDT_MEDIA_OFFSET + BTA_AV_SBC_HDR_SIZE + 1)
147 #else
148 #define BTIF_MEDIA_AA_SBC_OFFSET (AVDT_MEDIA_OFFSET + BTA_AV_SBC_HDR_SIZE)
149 #endif
150
151 /* Define the bitrate step when trying to match bitpool value */
152 #ifndef BTIF_MEDIA_BITRATE_STEP
153 #define BTIF_MEDIA_BITRATE_STEP 5
154 #endif
155
156 #ifndef BTIF_A2DP_DEFAULT_BITRATE
157 /* High quality quality setting @ 44.1 khz */
158 #define BTIF_A2DP_DEFAULT_BITRATE 328
159 #endif
160
161 #ifndef BTIF_A2DP_NON_EDR_MAX_RATE
162 #define BTIF_A2DP_NON_EDR_MAX_RATE 229
163 #endif
164
165 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
166 /* A2DP header will contain a CP header of size 1 */
167 #define A2DP_HDR_SIZE 2
168 #else
169 #define A2DP_HDR_SIZE 1
170 #endif
171 #define MAX_SBC_HQ_FRAME_SIZE_44_1 119
172 #define MAX_SBC_HQ_FRAME_SIZE_48 115
173
174 /* 2DH5 payload size of 679 bytes - (4 bytes L2CAP Header + 12 bytes AVDTP Header) */
175 #define MAX_2MBPS_AVDTP_MTU 663
176 #define USEC_PER_SEC 1000000L
177 #define TPUT_STATS_INTERVAL_US (3000*1000)
178
179 /**
180 * CONGESTION COMPENSATION CTRL ::
181 *
182 * Thus setting controls how many buffers we will hold in media task
183 * during temp link congestion. Together with the stack buffer queues
184 * it controls much temporary a2dp link congestion we can
185 * compensate for. It however also depends on the default run level of sinks
186 * jitterbuffers. Depending on type of sink this would vary.
187 * Ideally the (SRC) max tx buffer capacity should equal the sinks
188 * jitterbuffer runlevel including any intermediate buffers on the way
189 * towards the sinks codec.
190 */
191 #ifndef MAX_PCM_FRAME_NUM_PER_TICK
192 #define MAX_PCM_FRAME_NUM_PER_TICK 14
193 #endif
194 #define MAX_PCM_ITER_NUM_PER_TICK 3
195
196 /**
197 * The typical runlevel of the tx queue size is ~1 buffer
198 * but due to link flow control or thread preemption in lower
199 * layers we might need to temporarily buffer up data.
200 */
201 #define MAX_OUTPUT_A2DP_FRAME_QUEUE_SZ (MAX_PCM_FRAME_NUM_PER_TICK * 2)
202
203 /* In case of A2DP SINK, we will delay start by 5 AVDTP Packets*/
204 #define MAX_A2DP_DELAYED_START_FRAME_COUNT 5
205 #define PACKET_PLAYED_PER_TICK_48 8
206 #define PACKET_PLAYED_PER_TICK_44 7
207 #define PACKET_PLAYED_PER_TICK_32 5
208 #define PACKET_PLAYED_PER_TICK_16 3
209
210 /* Readability constants */
211 #define SBC_FRAME_HEADER_SIZE_BYTES 4 // A2DP Spec v1.3, 12.4, Table 12.12
212 #define SBC_SCALE_FACTOR_BITS 4 // A2DP Spec v1.3, 12.4, Table 12.13
213
214 typedef struct {
215 // Counter for total updates
216 size_t total_updates;
217
218 // Last update timestamp (in us)
219 uint64_t last_update_us;
220
221 // Counter for overdue scheduling
222 size_t overdue_scheduling_count;
223
224 // Accumulated overdue scheduling deviations (in us)
225 uint64_t total_overdue_scheduling_delta_us;
226
227 // Max. overdue scheduling delta time (in us)
228 uint64_t max_overdue_scheduling_delta_us;
229
230 // Counter for premature scheduling
231 size_t premature_scheduling_count;
232
233 // Accumulated premature scheduling deviations (in us)
234 uint64_t total_premature_scheduling_delta_us;
235
236 // Max. premature scheduling delta time (in us)
237 uint64_t max_premature_scheduling_delta_us;
238
239 // Counter for exact scheduling
240 size_t exact_scheduling_count;
241
242 // Accumulated and counted scheduling time (in us)
243 uint64_t total_scheduling_time_us;
244 } scheduling_stats_t;
245
246 typedef struct {
247 uint64_t session_start_us;
248 uint64_t session_end_us;
249
250 scheduling_stats_t tx_queue_enqueue_stats;
251 scheduling_stats_t tx_queue_dequeue_stats;
252
253 size_t tx_queue_total_frames;
254 size_t tx_queue_max_frames_per_packet;
255
256 uint64_t tx_queue_total_queueing_time_us;
257 uint64_t tx_queue_max_queueing_time_us;
258
259 size_t tx_queue_total_readbuf_calls;
260 uint64_t tx_queue_last_readbuf_us;
261
262 size_t tx_queue_total_flushed_messages;
263 uint64_t tx_queue_last_flushed_us;
264
265 size_t tx_queue_total_dropped_messages;
266 size_t tx_queue_max_dropped_messages;
267 size_t tx_queue_dropouts;
268 uint64_t tx_queue_last_dropouts_us;
269
270 size_t media_read_total_underflow_bytes;
271 size_t media_read_total_underflow_count;
272 uint64_t media_read_last_underflow_us;
273
274 size_t media_read_total_underrun_bytes;
275 size_t media_read_total_underrun_count;
276 uint64_t media_read_last_underrun_us;
277
278 size_t media_read_total_expected_frames;
279 size_t media_read_max_expected_frames;
280 size_t media_read_expected_count;
281
282 size_t media_read_total_limited_frames;
283 size_t media_read_max_limited_frames;
284 size_t media_read_limited_count;
285 } btif_media_stats_t;
286
287 typedef struct
288 {
289 UINT16 num_frames_to_be_processed;
290 UINT16 len;
291 UINT16 offset;
292 UINT16 layer_specific;
293 } tBT_SBC_HDR;
294
295 typedef struct
296 {
297 UINT32 aa_frame_counter;
298 INT32 aa_feed_counter;
299 INT32 aa_feed_residue;
300 UINT32 counter;
301 UINT32 bytes_per_tick; /* pcm bytes read each media task tick */
302 } tBTIF_AV_MEDIA_FEEDINGS_PCM_STATE;
303
304 typedef union
305 {
306 tBTIF_AV_MEDIA_FEEDINGS_PCM_STATE pcm;
307 } tBTIF_AV_MEDIA_FEEDINGS_STATE;
308
309 typedef struct
310 {
311 #if (BTA_AV_INCLUDED == TRUE)
312 fixed_queue_t *TxAaQ;
313 fixed_queue_t *RxSbcQ;
314 UINT16 TxAaMtuSize;
315 UINT32 timestamp;
316 UINT8 TxTranscoding;
317 tBTIF_AV_FEEDING_MODE feeding_mode;
318 tBTIF_AV_MEDIA_FEEDINGS media_feeding;
319 tBTIF_AV_MEDIA_FEEDINGS_STATE media_feeding_state;
320 SBC_ENC_PARAMS encoder;
321 UINT8 busy_level;
322 void* av_sm_hdl;
323 UINT8 a2dp_cmd_pending; /* we can have max one command pending */
324 BOOLEAN tx_flush; /* discards any outgoing data when true */
325 BOOLEAN rx_flush; /* discards any incoming data when true */
326 UINT8 peer_sep;
327 BOOLEAN data_channel_open;
328 UINT8 frames_to_process;
329 UINT8 tx_sbc_frames;
330
331 UINT32 sample_rate;
332 UINT8 channel_count;
333 #ifdef USE_AUDIO_TRACK
334 btif_media_audio_focus_state rx_audio_focus_state;
335 void *audio_track;
336 #endif
337 alarm_t *media_alarm;
338 alarm_t *decode_alarm;
339 btif_media_stats_t stats;
340 btif_media_stats_t accumulated_stats;
341 #endif
342 } tBTIF_MEDIA_CB;
343
344 typedef struct {
345 long long rx;
346 long long rx_tot;
347 long long tx;
348 long long tx_tot;
349 long long ts_prev_us;
350 } t_stat;
351
352 static UINT64 last_frame_us = 0;
353
354 static void btif_a2dp_data_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event);
355 static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event);
356 static void btif_a2dp_encoder_update(void);
357 #if (BTA_AV_SINK_INCLUDED == TRUE)
358 extern OI_STATUS OI_CODEC_SBC_DecodeFrame(OI_CODEC_SBC_DECODER_CONTEXT *context,
359 const OI_BYTE **frameData,
360 unsigned long *frameBytes,
361 OI_INT16 *pcmData,
362 unsigned long *pcmBytes);
363 extern OI_STATUS OI_CODEC_SBC_DecoderReset(OI_CODEC_SBC_DECODER_CONTEXT *context,
364 unsigned long *decoderData,
365 unsigned long decoderDataBytes,
366 OI_UINT8 maxChannels,
367 OI_UINT8 pcmStride,
368 OI_BOOL enhanced);
369 #endif
370 static void btif_media_flush_q(fixed_queue_t *p_q);
371 static void btif_media_task_aa_handle_stop_decoding(void );
372 static void btif_media_task_aa_rx_flush(void);
373
374 static UINT8 calculate_max_frames_per_packet();
375 static const char *dump_media_event(UINT16 event);
376 static void btif_media_thread_init(void *context);
377 static void btif_media_thread_cleanup(void *context);
378 static void btif_media_thread_handle_cmd(fixed_queue_t *queue, void *context);
379
380 /* Handle incoming media packets A2DP SINK streaming*/
381 #if (BTA_AV_SINK_INCLUDED == TRUE)
382 static void btif_media_task_handle_inc_media(tBT_SBC_HDR*p_msg);
383 #endif
384
385 #if (BTA_AV_INCLUDED == TRUE)
386 static void btif_media_send_aa_frame(uint64_t timestamp_us);
387 static void btif_media_task_feeding_state_reset(void);
388 static void btif_media_task_aa_start_tx(void);
389 static void btif_media_task_aa_stop_tx(void);
390 static void btif_media_task_enc_init(BT_HDR *p_msg);
391 static void btif_media_task_enc_update(BT_HDR *p_msg);
392 static void btif_media_task_audio_feeding_init(BT_HDR *p_msg);
393 static void btif_media_task_aa_tx_flush(BT_HDR *p_msg);
394 static void btif_media_aa_prep_2_send(UINT8 nb_frame, uint64_t timestamp_us);
395 #if (BTA_AV_SINK_INCLUDED == TRUE)
396 static void btif_media_task_aa_handle_decoder_reset(BT_HDR *p_msg);
397 static void btif_media_task_aa_handle_clear_track(void);
398 #endif
399 static void btif_media_task_aa_handle_start_decoding(void);
400 #endif
401 BOOLEAN btif_media_task_clear_track(void);
402
403 static void btif_media_task_aa_handle_timer(UNUSED_ATTR void *context);
404 static void btif_media_task_avk_handle_timer(UNUSED_ATTR void *context);
405 extern BOOLEAN btif_hf_is_call_idle();
406
407 static tBTIF_MEDIA_CB btif_media_cb;
408 static int media_task_running = MEDIA_TASK_STATE_OFF;
409
410 static fixed_queue_t *btif_media_cmd_msg_queue;
411 static thread_t *worker_thread;
412
413 /*****************************************************************************
414 ** Misc helper functions
415 *****************************************************************************/
btif_a2dp_source_accumulate_scheduling_stats(scheduling_stats_t * src,scheduling_stats_t * dst)416 void btif_a2dp_source_accumulate_scheduling_stats(scheduling_stats_t* src,
417 scheduling_stats_t* dst) {
418 dst->total_updates += src->total_updates;
419 dst->last_update_us = src->last_update_us;
420 dst->overdue_scheduling_count += src->overdue_scheduling_count;
421 dst->total_overdue_scheduling_delta_us += src->total_overdue_scheduling_delta_us;
422 if (src->max_overdue_scheduling_delta_us > dst->max_overdue_scheduling_delta_us) {
423 dst->max_overdue_scheduling_delta_us = src->max_overdue_scheduling_delta_us;
424 }
425 dst->premature_scheduling_count += src->premature_scheduling_count;
426 dst->total_premature_scheduling_delta_us += src->total_premature_scheduling_delta_us;
427 if (src->max_premature_scheduling_delta_us > dst->max_premature_scheduling_delta_us) {
428 dst->max_premature_scheduling_delta_us = src->max_premature_scheduling_delta_us;
429 }
430 dst->exact_scheduling_count += src->exact_scheduling_count;
431 dst->total_scheduling_time_us += src->total_scheduling_time_us;
432 }
433
btif_a2dp_source_accumulate_stats(btif_media_stats_t * src,btif_media_stats_t * dst)434 void btif_a2dp_source_accumulate_stats(btif_media_stats_t* src,
435 btif_media_stats_t* dst) {
436 dst->tx_queue_total_frames += src->tx_queue_total_frames;
437 if (src->tx_queue_max_frames_per_packet > dst->tx_queue_max_frames_per_packet) {
438 dst->tx_queue_max_frames_per_packet = src->tx_queue_max_frames_per_packet;
439 }
440 dst->tx_queue_total_queueing_time_us += src->tx_queue_total_queueing_time_us;
441 if (src->tx_queue_max_queueing_time_us > dst->tx_queue_max_queueing_time_us) {
442 dst->tx_queue_max_queueing_time_us = src->tx_queue_max_queueing_time_us;
443 }
444 dst->tx_queue_total_readbuf_calls += src->tx_queue_total_readbuf_calls;
445 dst->tx_queue_last_readbuf_us = src->tx_queue_last_readbuf_us;
446 dst->tx_queue_total_flushed_messages += src->tx_queue_total_flushed_messages;
447 dst->tx_queue_last_flushed_us = src->tx_queue_last_flushed_us;
448 dst->tx_queue_total_dropped_messages += src->tx_queue_total_dropped_messages;
449 if (src->tx_queue_max_dropped_messages > dst->tx_queue_max_dropped_messages) {
450 dst->tx_queue_max_dropped_messages = src->tx_queue_max_dropped_messages;
451 }
452 dst->tx_queue_dropouts += src->tx_queue_dropouts;
453 dst->tx_queue_last_dropouts_us = src->tx_queue_last_dropouts_us;
454 dst->media_read_total_underflow_bytes +=
455 src->media_read_total_underflow_bytes;
456 dst->media_read_total_underflow_count +=
457 src->media_read_total_underflow_count;
458 dst->media_read_last_underflow_us = src->media_read_last_underflow_us;
459 dst->media_read_total_underrun_bytes += src->media_read_total_underrun_bytes;
460 dst->media_read_total_underflow_count += src->media_read_total_underrun_count;
461 dst->media_read_last_underrun_us = src->media_read_last_underrun_us;
462 dst->media_read_total_expected_frames += src->media_read_total_expected_frames;
463 if (src->media_read_max_expected_frames > dst->media_read_max_expected_frames) {
464 dst->media_read_max_expected_frames = src->media_read_max_expected_frames;
465 }
466 dst->media_read_expected_count += src->media_read_expected_count;
467 dst->media_read_total_limited_frames += src->media_read_total_limited_frames;
468 if (src->media_read_max_limited_frames > dst->media_read_max_limited_frames) {
469 dst->media_read_max_limited_frames = src->media_read_max_limited_frames;
470 }
471 dst->media_read_limited_count += src->media_read_limited_count;
472 btif_a2dp_source_accumulate_scheduling_stats(&src->tx_queue_enqueue_stats,
473 &dst->tx_queue_enqueue_stats);
474 btif_a2dp_source_accumulate_scheduling_stats(&src->tx_queue_dequeue_stats,
475 &dst->tx_queue_dequeue_stats);
476 memset(src, 0, sizeof(btif_media_stats_t));
477 }
478
update_scheduling_stats(scheduling_stats_t * stats,uint64_t now_us,uint64_t expected_delta)479 static void update_scheduling_stats(scheduling_stats_t *stats,
480 uint64_t now_us, uint64_t expected_delta)
481 {
482 uint64_t last_us = stats->last_update_us;
483
484 stats->total_updates++;
485 stats->last_update_us = now_us;
486
487 if (last_us == 0)
488 return; // First update: expected delta doesn't apply
489
490 uint64_t deadline_us = last_us + expected_delta;
491 if (deadline_us < now_us) {
492 // Overdue scheduling
493 uint64_t delta_us = now_us - deadline_us;
494 // Ignore extreme outliers
495 if (delta_us < 10 * expected_delta) {
496 if (stats->max_overdue_scheduling_delta_us < delta_us)
497 stats->max_overdue_scheduling_delta_us = delta_us;
498 stats->total_overdue_scheduling_delta_us += delta_us;
499 stats->overdue_scheduling_count++;
500 stats->total_scheduling_time_us += now_us - last_us;
501 }
502 } else if (deadline_us > now_us) {
503 // Premature scheduling
504 uint64_t delta_us = deadline_us - now_us;
505 // Ignore extreme outliers
506 if (delta_us < 10 * expected_delta) {
507 if (stats->max_premature_scheduling_delta_us < delta_us)
508 stats->max_premature_scheduling_delta_us = delta_us;
509 stats->total_premature_scheduling_delta_us += delta_us;
510 stats->premature_scheduling_count++;
511 stats->total_scheduling_time_us += now_us - last_us;
512 }
513 } else {
514 // On-time scheduling
515 stats->exact_scheduling_count++;
516 stats->total_scheduling_time_us += now_us - last_us;
517 }
518 }
519
time_now_us()520 static UINT64 time_now_us()
521 {
522 struct timespec ts_now;
523 clock_gettime(CLOCK_BOOTTIME, &ts_now);
524 return ((UINT64)ts_now.tv_sec * USEC_PER_SEC) + ((UINT64)ts_now.tv_nsec / 1000);
525 }
526
log_tstamps_us(char * comment,uint64_t now_us)527 static void log_tstamps_us(char *comment, uint64_t now_us)
528 {
529 static uint64_t prev_us = 0;
530 APPL_TRACE_DEBUG("[%s] ts %08llu, diff : %08llu, queue sz %d", comment, now_us, now_us - prev_us,
531 fixed_queue_length(btif_media_cb.TxAaQ));
532 prev_us = now_us;
533 }
534
dump_media_event(UINT16 event)535 UNUSED_ATTR static const char *dump_media_event(UINT16 event)
536 {
537 switch (event)
538 {
539 CASE_RETURN_STR(BTIF_MEDIA_START_AA_TX)
540 CASE_RETURN_STR(BTIF_MEDIA_STOP_AA_TX)
541 CASE_RETURN_STR(BTIF_MEDIA_AA_RX_RDY)
542 CASE_RETURN_STR(BTIF_MEDIA_UIPC_RX_RDY)
543 CASE_RETURN_STR(BTIF_MEDIA_SBC_ENC_INIT)
544 CASE_RETURN_STR(BTIF_MEDIA_SBC_ENC_UPDATE)
545 CASE_RETURN_STR(BTIF_MEDIA_SBC_DEC_INIT)
546 CASE_RETURN_STR(BTIF_MEDIA_VIDEO_DEC_INIT)
547 CASE_RETURN_STR(BTIF_MEDIA_FLUSH_AA_TX)
548 CASE_RETURN_STR(BTIF_MEDIA_FLUSH_AA_RX)
549 CASE_RETURN_STR(BTIF_MEDIA_AUDIO_FEEDING_INIT)
550 CASE_RETURN_STR(BTIF_MEDIA_AUDIO_RECEIVING_INIT)
551 CASE_RETURN_STR(BTIF_MEDIA_AUDIO_SINK_CFG_UPDATE)
552 CASE_RETURN_STR(BTIF_MEDIA_AUDIO_SINK_CLEAR_TRACK)
553 CASE_RETURN_STR(BTIF_MEDIA_AUDIO_SINK_SET_FOCUS_STATE)
554
555 default:
556 return "UNKNOWN MEDIA EVENT";
557 }
558 }
559
btm_read_rssi_cb(void * data)560 static void btm_read_rssi_cb(void *data)
561 {
562 if (data == NULL)
563 {
564 LOG_ERROR(LOG_TAG, "%s RSSI request timed out", __func__);
565 return;
566 }
567
568 tBTM_RSSI_RESULTS *result = (tBTM_RSSI_RESULTS*)data;
569 if (result->status != BTM_SUCCESS)
570 {
571 LOG_ERROR(LOG_TAG, "%s unable to read remote RSSI (status %d)",
572 __func__, result->status);
573 return;
574 }
575
576 char temp_buffer[20] = {0};
577 LOG_WARN(LOG_TAG, "%s device: %s, rssi: %d", __func__,
578 bdaddr_to_string((bt_bdaddr_t *)result->rem_bda, temp_buffer,
579 sizeof(temp_buffer)),
580 result->rssi);
581 }
582
583 /*****************************************************************************
584 ** A2DP CTRL PATH
585 *****************************************************************************/
586
dump_a2dp_ctrl_event(UINT8 event)587 static const char* dump_a2dp_ctrl_event(UINT8 event)
588 {
589 switch (event)
590 {
591 CASE_RETURN_STR(A2DP_CTRL_CMD_NONE)
592 CASE_RETURN_STR(A2DP_CTRL_CMD_CHECK_READY)
593 CASE_RETURN_STR(A2DP_CTRL_CMD_START)
594 CASE_RETURN_STR(A2DP_CTRL_CMD_STOP)
595 CASE_RETURN_STR(A2DP_CTRL_CMD_SUSPEND)
596 CASE_RETURN_STR(A2DP_CTRL_CMD_OFFLOAD_START)
597
598 default:
599 return "UNKNOWN MSG ID";
600 }
601 }
602
btif_audiopath_detached(void)603 static void btif_audiopath_detached(void)
604 {
605 APPL_TRACE_EVENT("## AUDIO PATH DETACHED ##");
606
607 /* send stop request only if we are actively streaming and haven't received
608 a stop request. Potentially audioflinger detached abnormally */
609 if (alarm_is_scheduled(btif_media_cb.media_alarm)) {
610 /* post stop event and wait for audio path to stop */
611 btif_dispatch_sm_event(BTIF_AV_STOP_STREAM_REQ_EVT, NULL, 0);
612 }
613 }
614
a2dp_cmd_acknowledge(int status)615 static void a2dp_cmd_acknowledge(int status)
616 {
617 UINT8 ack = status;
618
619 APPL_TRACE_EVENT("## a2dp ack : %s, status %d ##",
620 dump_a2dp_ctrl_event(btif_media_cb.a2dp_cmd_pending), status);
621
622 /* sanity check */
623 if (btif_media_cb.a2dp_cmd_pending == A2DP_CTRL_CMD_NONE)
624 {
625 APPL_TRACE_ERROR("warning : no command pending, ignore ack");
626 return;
627 }
628
629 /* clear pending */
630 btif_media_cb.a2dp_cmd_pending = A2DP_CTRL_CMD_NONE;
631
632 /* acknowledge start request */
633 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &ack, 1);
634 }
635
636
btif_recv_ctrl_data(void)637 static void btif_recv_ctrl_data(void)
638 {
639 UINT8 cmd = 0;
640 int n;
641 n = UIPC_Read(UIPC_CH_ID_AV_CTRL, NULL, &cmd, 1);
642
643 /* detach on ctrl channel means audioflinger process was terminated */
644 if (n == 0)
645 {
646 APPL_TRACE_EVENT("CTRL CH DETACHED");
647 UIPC_Close(UIPC_CH_ID_AV_CTRL);
648 /* we can operate only on datachannel, if af client wants to
649 do send additional commands the ctrl channel would be reestablished */
650 //btif_audiopath_detached();
651 return;
652 }
653
654 APPL_TRACE_DEBUG("a2dp-ctrl-cmd : %s", dump_a2dp_ctrl_event(cmd));
655
656 btif_media_cb.a2dp_cmd_pending = cmd;
657
658 switch (cmd)
659 {
660 case A2DP_CTRL_CMD_CHECK_READY:
661
662 if (media_task_running == MEDIA_TASK_STATE_SHUTTING_DOWN)
663 {
664 APPL_TRACE_WARNING("%s: A2DP command %s while media task shutting down",
665 __func__, dump_a2dp_ctrl_event(cmd));
666 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
667 return;
668 }
669
670 /* check whether av is ready to setup a2dp datapath */
671 if ((btif_av_stream_ready() == TRUE) || (btif_av_stream_started_ready() == TRUE))
672 {
673 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
674 }
675 else
676 {
677 APPL_TRACE_WARNING("%s: A2DP command %s while AV stream is not ready",
678 __func__, dump_a2dp_ctrl_event(cmd));
679 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
680 }
681 break;
682
683 case A2DP_CTRL_CMD_START:
684 /* Don't sent START request to stack while we are in call.
685 Some headsets like the Sony MW600, don't allow AVDTP START
686 in call and respond BAD_STATE. */
687 if (!btif_hf_is_call_idle())
688 {
689 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_INCALL_FAILURE);
690 break;
691 }
692
693 if (alarm_is_scheduled(btif_media_cb.media_alarm))
694 {
695 APPL_TRACE_WARNING("%s: A2DP command %s when media alarm already scheduled",
696 __func__, dump_a2dp_ctrl_event(cmd));
697 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
698 break;
699 }
700
701 if (btif_av_stream_ready() == TRUE)
702 {
703 /* setup audio data channel listener */
704 UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);
705
706 /* post start event and wait for audio path to open */
707 btif_dispatch_sm_event(BTIF_AV_START_STREAM_REQ_EVT, NULL, 0);
708
709 #if (BTA_AV_SINK_INCLUDED == TRUE)
710 if (btif_media_cb.peer_sep == AVDT_TSEP_SRC)
711 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
712 #endif
713 }
714 else if (btif_av_stream_started_ready())
715 {
716 /* already started, setup audio data channel listener
717 and ack back immediately */
718 UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);
719
720 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
721 }
722 else
723 {
724 APPL_TRACE_WARNING("%s: A2DP command %s while AV stream is not ready",
725 __func__, dump_a2dp_ctrl_event(cmd));
726 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
727 break;
728 }
729 break;
730
731 case A2DP_CTRL_CMD_STOP:
732 if (btif_media_cb.peer_sep == AVDT_TSEP_SNK &&
733 (!alarm_is_scheduled(btif_media_cb.media_alarm)))
734 {
735 /* we are already stopped, just ack back */
736 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
737 break;
738 }
739
740 btif_dispatch_sm_event(BTIF_AV_STOP_STREAM_REQ_EVT, NULL, 0);
741 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
742 break;
743
744 case A2DP_CTRL_CMD_SUSPEND:
745 /* local suspend */
746 if (btif_av_stream_started_ready())
747 {
748 btif_dispatch_sm_event(BTIF_AV_SUSPEND_STREAM_REQ_EVT, NULL, 0);
749 }
750 else
751 {
752 /* if we are not in started state, just ack back ok and let
753 audioflinger close the channel. This can happen if we are
754 remotely suspended, clear REMOTE SUSPEND Flag */
755 btif_av_clear_remote_suspend_flag();
756 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
757 }
758 break;
759
760 case A2DP_CTRL_GET_AUDIO_CONFIG:
761 {
762 uint32_t sample_rate = btif_media_cb.sample_rate;
763 uint8_t channel_count = btif_media_cb.channel_count;
764
765 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
766 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, (UINT8 *)&sample_rate, 4);
767 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &channel_count, 1);
768 break;
769 }
770
771 case A2DP_CTRL_CMD_OFFLOAD_START:
772 btif_dispatch_sm_event(BTIF_AV_OFFLOAD_START_REQ_EVT, NULL, 0);
773 break;
774
775 default:
776 APPL_TRACE_ERROR("UNSUPPORTED CMD (%d)", cmd);
777 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
778 break;
779 }
780 APPL_TRACE_DEBUG("a2dp-ctrl-cmd : %s DONE", dump_a2dp_ctrl_event(cmd));
781 }
782
btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id,tUIPC_EVENT event)783 static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event)
784 {
785 UNUSED(ch_id);
786
787 APPL_TRACE_DEBUG("A2DP-CTRL-CHANNEL EVENT %s", dump_uipc_event(event));
788
789 switch (event)
790 {
791 case UIPC_OPEN_EVT:
792 /* fetch av statemachine handle */
793 btif_media_cb.av_sm_hdl = btif_av_get_sm_handle();
794 break;
795
796 case UIPC_CLOSE_EVT:
797 /* restart ctrl server unless we are shutting down */
798 if (media_task_running == MEDIA_TASK_STATE_ON)
799 UIPC_Open(UIPC_CH_ID_AV_CTRL , btif_a2dp_ctrl_cb);
800 break;
801
802 case UIPC_RX_DATA_READY_EVT:
803 btif_recv_ctrl_data();
804 break;
805
806 default :
807 APPL_TRACE_ERROR("### A2DP-CTRL-CHANNEL EVENT %d NOT HANDLED ###", event);
808 break;
809 }
810 }
811
btif_a2dp_data_cb(tUIPC_CH_ID ch_id,tUIPC_EVENT event)812 static void btif_a2dp_data_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event)
813 {
814 UNUSED(ch_id);
815
816 APPL_TRACE_DEBUG("BTIF MEDIA (A2DP-DATA) EVENT %s", dump_uipc_event(event));
817
818 switch (event)
819 {
820 case UIPC_OPEN_EVT:
821
822 /* read directly from media task from here on (keep callback for
823 connection events */
824 UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_REMOVE_ACTIVE_READSET, NULL);
825 UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_SET_READ_POLL_TMO,
826 (void *)A2DP_DATA_READ_POLL_MS);
827
828 if (btif_media_cb.peer_sep == AVDT_TSEP_SNK) {
829 /* Start the media task to encode SBC */
830 btif_media_task_start_aa_req();
831
832 /* make sure we update any changed sbc encoder params */
833 btif_a2dp_encoder_update();
834 }
835 btif_media_cb.data_channel_open = TRUE;
836
837 /* ack back when media task is fully started */
838 break;
839
840 case UIPC_CLOSE_EVT:
841 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
842 btif_audiopath_detached();
843 btif_media_cb.data_channel_open = FALSE;
844 break;
845
846 default :
847 APPL_TRACE_ERROR("### A2DP-DATA EVENT %d NOT HANDLED ###", event);
848 break;
849 }
850 }
851
852
853 /*****************************************************************************
854 ** BTIF ADAPTATION
855 *****************************************************************************/
856
btif_media_task_get_sbc_rate(void)857 static UINT16 btif_media_task_get_sbc_rate(void)
858 {
859 UINT16 rate = BTIF_A2DP_DEFAULT_BITRATE;
860
861 /* restrict bitrate if a2dp link is non-edr */
862 if (!btif_av_is_peer_edr())
863 {
864 rate = BTIF_A2DP_NON_EDR_MAX_RATE;
865 APPL_TRACE_DEBUG("non-edr a2dp sink detected, restrict rate to %d", rate);
866 }
867
868 return rate;
869 }
870
btif_a2dp_encoder_init(void)871 static void btif_a2dp_encoder_init(void)
872 {
873 UINT16 minmtu;
874 tBTIF_MEDIA_INIT_AUDIO msg;
875 tA2D_SBC_CIE sbc_config;
876
877 /* lookup table for converting channel mode */
878 UINT16 codec_mode_tbl[5] = { SBC_JOINT_STEREO, SBC_STEREO, SBC_DUAL, 0, SBC_MONO };
879
880 /* lookup table for converting number of blocks */
881 UINT16 codec_block_tbl[5] = { 16, 12, 8, 0, 4 };
882
883 /* lookup table to convert freq */
884 UINT16 freq_block_tbl[5] = { SBC_sf48000, SBC_sf44100, SBC_sf32000, 0, SBC_sf16000 };
885
886 APPL_TRACE_DEBUG("btif_a2dp_encoder_init");
887
888 /* Retrieve the current SBC configuration (default if currently not used) */
889 bta_av_co_audio_get_sbc_config(&sbc_config, &minmtu);
890 msg.NumOfSubBands = (sbc_config.num_subbands == A2D_SBC_IE_SUBBAND_4) ? 4 : 8;
891 msg.NumOfBlocks = codec_block_tbl[sbc_config.block_len >> 5];
892 msg.AllocationMethod = (sbc_config.alloc_mthd == A2D_SBC_IE_ALLOC_MD_L) ? SBC_LOUDNESS : SBC_SNR;
893 msg.ChannelMode = codec_mode_tbl[sbc_config.ch_mode >> 1];
894 msg.SamplingFreq = freq_block_tbl[sbc_config.samp_freq >> 5];
895 msg.MtuSize = minmtu;
896
897 APPL_TRACE_EVENT("msg.ChannelMode %x", msg.ChannelMode);
898
899 /* Init the media task to encode SBC properly */
900 btif_media_task_enc_init_req(&msg);
901 }
902
btif_a2dp_encoder_update(void)903 static void btif_a2dp_encoder_update(void)
904 {
905 UINT16 minmtu;
906 tA2D_SBC_CIE sbc_config;
907 tBTIF_MEDIA_UPDATE_AUDIO msg;
908 UINT8 pref_min;
909 UINT8 pref_max;
910
911 APPL_TRACE_DEBUG("btif_a2dp_encoder_update");
912
913 /* Retrieve the current SBC configuration (default if currently not used) */
914 bta_av_co_audio_get_sbc_config(&sbc_config, &minmtu);
915
916 APPL_TRACE_DEBUG("btif_a2dp_encoder_update: Common min_bitpool:%d(0x%x) max_bitpool:%d(0x%x)",
917 sbc_config.min_bitpool, sbc_config.min_bitpool,
918 sbc_config.max_bitpool, sbc_config.max_bitpool);
919
920 if (sbc_config.min_bitpool > sbc_config.max_bitpool)
921 {
922 APPL_TRACE_ERROR("btif_a2dp_encoder_update: ERROR btif_a2dp_encoder_update min_bitpool > max_bitpool");
923 }
924
925 /* check if remote sink has a preferred bitpool range */
926 if (bta_av_co_get_remote_bitpool_pref(&pref_min, &pref_max) == TRUE)
927 {
928 /* adjust our preferred bitpool with the remote preference if within
929 our capable range */
930
931 if (pref_min < sbc_config.min_bitpool)
932 pref_min = sbc_config.min_bitpool;
933
934 if (pref_max > sbc_config.max_bitpool)
935 pref_max = sbc_config.max_bitpool;
936
937 msg.MinBitPool = pref_min;
938 msg.MaxBitPool = pref_max;
939
940 if ((pref_min != sbc_config.min_bitpool) || (pref_max != sbc_config.max_bitpool))
941 {
942 APPL_TRACE_EVENT("## adjusted our bitpool range to peer pref [%d:%d] ##",
943 pref_min, pref_max);
944 }
945 }
946 else
947 {
948 msg.MinBitPool = sbc_config.min_bitpool;
949 msg.MaxBitPool = sbc_config.max_bitpool;
950 }
951
952 msg.MinMtuSize = minmtu;
953
954 /* Update the media task to encode SBC properly */
955 btif_media_task_enc_update_req(&msg);
956 }
957
btif_a2dp_start_media_task(void)958 bool btif_a2dp_start_media_task(void)
959 {
960 if (media_task_running != MEDIA_TASK_STATE_OFF)
961 {
962 APPL_TRACE_ERROR("warning : media task already running");
963 return false;
964 }
965
966 APPL_TRACE_EVENT("## A2DP START MEDIA THREAD ##");
967
968 btif_media_cmd_msg_queue = fixed_queue_new(SIZE_MAX);
969
970 /* start a2dp media task */
971 worker_thread = thread_new("media_worker");
972 if (worker_thread == NULL)
973 goto error_exit;
974
975 fixed_queue_register_dequeue(btif_media_cmd_msg_queue,
976 thread_get_reactor(worker_thread),
977 btif_media_thread_handle_cmd,
978 NULL);
979
980 thread_post(worker_thread, btif_media_thread_init, NULL);
981 APPL_TRACE_EVENT("## A2DP MEDIA THREAD STARTED ##");
982
983 return true;
984
985 error_exit:;
986 APPL_TRACE_ERROR("%s unable to start up media thread", __func__);
987 return false;
988 }
989
btif_a2dp_stop_media_task(void)990 void btif_a2dp_stop_media_task(void)
991 {
992 APPL_TRACE_EVENT("## A2DP STOP MEDIA THREAD ##");
993
994 // Stop timer
995 alarm_free(btif_media_cb.media_alarm);
996 btif_media_cb.media_alarm = NULL;
997
998 // Exit thread
999 fixed_queue_free(btif_media_cmd_msg_queue, NULL);
1000 btif_media_cmd_msg_queue = NULL;
1001 thread_post(worker_thread, btif_media_thread_cleanup, NULL);
1002 thread_free(worker_thread);
1003 worker_thread = NULL;
1004 }
1005
1006 /*****************************************************************************
1007 **
1008 ** Function btif_a2dp_on_init
1009 **
1010 ** Description
1011 **
1012 ** Returns
1013 **
1014 *******************************************************************************/
1015
btif_a2dp_on_init(void)1016 void btif_a2dp_on_init(void)
1017 {
1018 #ifdef USE_AUDIO_TRACK
1019 btif_media_cb.rx_audio_focus_state = BTIF_MEDIA_FOCUS_NOT_GRANTED;
1020 btif_media_cb.audio_track = NULL;
1021 #endif
1022 }
1023
1024
1025 /*****************************************************************************
1026 **
1027 ** Function btif_a2dp_setup_codec
1028 **
1029 ** Description
1030 **
1031 ** Returns
1032 **
1033 *******************************************************************************/
1034
btif_a2dp_setup_codec(void)1035 void btif_a2dp_setup_codec(void)
1036 {
1037 tBTIF_AV_MEDIA_FEEDINGS media_feeding;
1038 tBTIF_STATUS status;
1039
1040 APPL_TRACE_EVENT("## A2DP SETUP CODEC ##");
1041
1042 mutex_global_lock();
1043
1044 /* for now hardcode 44.1 khz 16 bit stereo PCM format */
1045 media_feeding.cfg.pcm.sampling_freq = BTIF_A2DP_SRC_SAMPLING_RATE;
1046 media_feeding.cfg.pcm.bit_per_sample = BTIF_A2DP_SRC_BIT_DEPTH;
1047 media_feeding.cfg.pcm.num_channel = BTIF_A2DP_SRC_NUM_CHANNELS;
1048 media_feeding.format = BTIF_AV_CODEC_PCM;
1049
1050 if (bta_av_co_audio_set_codec(&media_feeding, &status))
1051 {
1052 tBTIF_MEDIA_INIT_AUDIO_FEEDING mfeed;
1053
1054 /* Init the encoding task */
1055 btif_a2dp_encoder_init();
1056
1057 /* Build the media task configuration */
1058 mfeed.feeding = media_feeding;
1059 mfeed.feeding_mode = BTIF_AV_FEEDING_ASYNCHRONOUS;
1060 /* Send message to Media task to configure transcoding */
1061 btif_media_task_audio_feeding_init_req(&mfeed);
1062 }
1063
1064 mutex_global_unlock();
1065 }
1066
1067
1068 /*****************************************************************************
1069 **
1070 ** Function btif_a2dp_on_idle
1071 **
1072 ** Description
1073 **
1074 ** Returns
1075 **
1076 *******************************************************************************/
1077
btif_a2dp_on_idle(void)1078 void btif_a2dp_on_idle(void)
1079 {
1080 APPL_TRACE_EVENT("## ON A2DP IDLE ## peer_sep = %d", btif_media_cb.peer_sep);
1081 if (btif_media_cb.peer_sep == AVDT_TSEP_SNK)
1082 {
1083 /* Make sure media task is stopped */
1084 btif_media_task_stop_aa_req();
1085 }
1086
1087 bta_av_co_init();
1088 #if (BTA_AV_SINK_INCLUDED == TRUE)
1089 if (btif_media_cb.peer_sep == AVDT_TSEP_SRC)
1090 {
1091 btif_media_cb.rx_flush = TRUE;
1092 btif_media_task_aa_rx_flush_req();
1093 btif_media_task_aa_handle_stop_decoding();
1094 btif_media_task_clear_track();
1095 APPL_TRACE_DEBUG("Stopped BT track");
1096 }
1097 #endif
1098 }
1099
1100 /*****************************************************************************
1101 **
1102 ** Function btif_a2dp_on_open
1103 **
1104 ** Description
1105 **
1106 ** Returns
1107 **
1108 *******************************************************************************/
1109
btif_a2dp_on_open(void)1110 void btif_a2dp_on_open(void)
1111 {
1112 APPL_TRACE_EVENT("## ON A2DP OPEN ##");
1113
1114 /* always use callback to notify socket events */
1115 UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);
1116 }
1117
1118 /*******************************************************************************
1119 **
1120 ** Function btif_media_task_clear_track
1121 **
1122 ** Description
1123 **
1124 ** Returns TRUE is success
1125 **
1126 *******************************************************************************/
btif_media_task_clear_track(void)1127 BOOLEAN btif_media_task_clear_track(void)
1128 {
1129 BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
1130
1131 p_buf->event = BTIF_MEDIA_AUDIO_SINK_CLEAR_TRACK;
1132 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1133
1134 return TRUE;
1135 }
1136
1137 /*****************************************************************************
1138 **
1139 ** Function btif_reset_decoder
1140 **
1141 ** Description
1142 **
1143 ** Returns
1144 **
1145 *******************************************************************************/
1146
btif_reset_decoder(UINT8 * p_av)1147 void btif_reset_decoder(UINT8 *p_av)
1148 {
1149 tBTIF_MEDIA_SINK_CFG_UPDATE *p_buf =
1150 osi_malloc(sizeof(tBTIF_MEDIA_SINK_CFG_UPDATE));
1151
1152 APPL_TRACE_EVENT("btif_reset_decoder");
1153 APPL_TRACE_DEBUG("btif_reset_decoder p_codec_info[%x:%x:%x:%x:%x:%x]",
1154 p_av[1], p_av[2], p_av[3],
1155 p_av[4], p_av[5], p_av[6]);
1156
1157 memcpy(p_buf->codec_info,p_av, AVDT_CODEC_SIZE);
1158 p_buf->hdr.event = BTIF_MEDIA_AUDIO_SINK_CFG_UPDATE;
1159
1160 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1161 }
1162
1163 /*****************************************************************************
1164 **
1165 ** Function btif_a2dp_on_started
1166 **
1167 ** Description
1168 **
1169 ** Returns
1170 **
1171 *******************************************************************************/
1172
btif_a2dp_on_started(tBTA_AV_START * p_av,BOOLEAN pending_start)1173 BOOLEAN btif_a2dp_on_started(tBTA_AV_START *p_av, BOOLEAN pending_start)
1174 {
1175 BOOLEAN ack = FALSE;
1176
1177 APPL_TRACE_EVENT("## ON A2DP STARTED ##");
1178
1179 if (p_av == NULL)
1180 {
1181 /* ack back a local start request */
1182 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
1183 return TRUE;
1184 }
1185
1186 if (p_av->status == BTA_AV_SUCCESS)
1187 {
1188 if (p_av->suspending == FALSE)
1189 {
1190 if (p_av->initiator)
1191 {
1192 if (pending_start) {
1193 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
1194 ack = TRUE;
1195 }
1196 }
1197 else
1198 {
1199 /* we were remotely started, make sure codec
1200 is setup before datapath is started */
1201 btif_a2dp_setup_codec();
1202 }
1203
1204 /* media task is autostarted upon a2dp audiopath connection */
1205 }
1206 }
1207 else if (pending_start)
1208 {
1209 APPL_TRACE_WARNING("%s: A2DP start request failed: status = %d",
1210 __func__, p_av->status);
1211 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
1212 ack = TRUE;
1213 }
1214 return ack;
1215 }
1216
1217
1218 /*****************************************************************************
1219 **
1220 ** Function btif_a2dp_ack_fail
1221 **
1222 ** Description
1223 **
1224 ** Returns
1225 **
1226 *******************************************************************************/
1227
btif_a2dp_ack_fail(void)1228 void btif_a2dp_ack_fail(void)
1229 {
1230 APPL_TRACE_EVENT("## A2DP_CTRL_ACK_FAILURE ##");
1231 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
1232 }
1233
1234 /*****************************************************************************
1235 **
1236 ** Function btif_a2dp_on_stopped
1237 **
1238 ** Description
1239 **
1240 ** Returns
1241 **
1242 *******************************************************************************/
1243
btif_a2dp_on_stopped(tBTA_AV_SUSPEND * p_av)1244 void btif_a2dp_on_stopped(tBTA_AV_SUSPEND *p_av)
1245 {
1246 APPL_TRACE_EVENT("## ON A2DP STOPPED ##");
1247 if (btif_media_cb.peer_sep == AVDT_TSEP_SRC) /* Handling for A2DP SINK cases*/
1248 {
1249 btif_media_cb.rx_flush = TRUE;
1250 btif_media_task_aa_rx_flush_req();
1251 btif_media_task_aa_handle_stop_decoding();
1252 #ifndef USE_AUDIO_TRACK
1253 UIPC_Close(UIPC_CH_ID_AV_AUDIO);
1254 #endif
1255 btif_media_cb.data_channel_open = FALSE;
1256 return;
1257 }
1258 /* allow using this api for other than suspend */
1259 if (p_av != NULL)
1260 {
1261 if (p_av->status != BTA_AV_SUCCESS)
1262 {
1263 APPL_TRACE_EVENT("AV STOP FAILED (%d)", p_av->status);
1264
1265 if (p_av->initiator) {
1266 APPL_TRACE_WARNING("%s: A2DP stop request failed: status = %d",
1267 __func__, p_av->status);
1268 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
1269 }
1270 return;
1271 }
1272 }
1273
1274 /* ensure tx frames are immediately suspended */
1275 btif_media_cb.tx_flush = 1;
1276
1277 /* request to stop media task */
1278 btif_media_task_aa_tx_flush_req();
1279 btif_media_task_stop_aa_req();
1280
1281 /* once stream is fully stopped we will ack back */
1282 }
1283
1284
1285 /*****************************************************************************
1286 **
1287 ** Function btif_a2dp_on_suspended
1288 **
1289 ** Description
1290 **
1291 ** Returns
1292 **
1293 *******************************************************************************/
1294
btif_a2dp_on_suspended(tBTA_AV_SUSPEND * p_av)1295 void btif_a2dp_on_suspended(tBTA_AV_SUSPEND *p_av)
1296 {
1297 APPL_TRACE_EVENT("## ON A2DP SUSPENDED ##");
1298 if (btif_media_cb.peer_sep == AVDT_TSEP_SRC)
1299 {
1300 btif_media_cb.rx_flush = TRUE;
1301 btif_media_task_aa_rx_flush_req();
1302 btif_media_task_aa_handle_stop_decoding();
1303 #ifndef USE_AUDIO_TRACK
1304 UIPC_Close(UIPC_CH_ID_AV_AUDIO);
1305 #endif
1306 return;
1307 }
1308
1309 /* check for status failures */
1310 if (p_av->status != BTA_AV_SUCCESS)
1311 {
1312 if (p_av->initiator == TRUE) {
1313 APPL_TRACE_WARNING("%s: A2DP suspend request failed: status = %d",
1314 __func__, p_av->status);
1315 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE);
1316 }
1317 }
1318
1319 /* once stream is fully stopped we will ack back */
1320
1321 /* ensure tx frames are immediately flushed */
1322 btif_media_cb.tx_flush = 1;
1323
1324 /* stop timer tick */
1325 btif_media_task_stop_aa_req();
1326 }
1327
1328
1329 /*****************************************************************************
1330 **
1331 ** Function btif_a2dp_on_offload_started
1332 **
1333 ** Description
1334 **
1335 ** Returns
1336 **
1337 *******************************************************************************/
btif_a2dp_on_offload_started(tBTA_AV_STATUS status)1338 void btif_a2dp_on_offload_started(tBTA_AV_STATUS status)
1339 {
1340 tA2DP_CTRL_ACK ack;
1341 APPL_TRACE_EVENT("%s status %d", __func__, status);
1342
1343 switch (status) {
1344 case BTA_AV_SUCCESS:
1345 ack = A2DP_CTRL_ACK_SUCCESS;
1346 break;
1347
1348 case BTA_AV_FAIL_RESOURCES:
1349 APPL_TRACE_ERROR("%s FAILED UNSUPPORTED", __func__);
1350 ack = A2DP_CTRL_ACK_UNSUPPORTED;
1351 break;
1352 default:
1353 APPL_TRACE_ERROR("%s FAILED: status = %d", __func__, status);
1354 ack = A2DP_CTRL_ACK_FAILURE;
1355 break;
1356 }
1357 a2dp_cmd_acknowledge(ack);
1358 }
1359
1360 /* when true media task discards any rx frames */
btif_a2dp_set_rx_flush(BOOLEAN enable)1361 void btif_a2dp_set_rx_flush(BOOLEAN enable)
1362 {
1363 APPL_TRACE_EVENT("## DROP RX %d ##", enable);
1364 btif_media_cb.rx_flush = enable;
1365 }
1366
1367 /* when true media task discards any tx frames */
btif_a2dp_set_tx_flush(BOOLEAN enable)1368 void btif_a2dp_set_tx_flush(BOOLEAN enable)
1369 {
1370 APPL_TRACE_EVENT("## DROP TX %d ##", enable);
1371 btif_media_cb.tx_flush = enable;
1372 }
1373
1374 #ifdef USE_AUDIO_TRACK
btif_a2dp_set_audio_focus_state(btif_media_audio_focus_state state)1375 void btif_a2dp_set_audio_focus_state(btif_media_audio_focus_state state)
1376 {
1377 tBTIF_MEDIA_SINK_FOCUS_UPDATE *p_buf =
1378 osi_malloc(sizeof(tBTIF_MEDIA_SINK_FOCUS_UPDATE));
1379
1380 APPL_TRACE_EVENT("%s", __func__);
1381
1382 p_buf->focus_state = state;
1383 p_buf->hdr.event = BTIF_MEDIA_AUDIO_SINK_SET_FOCUS_STATE;
1384 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1385 }
1386
btif_a2dp_set_audio_track_gain(float gain)1387 void btif_a2dp_set_audio_track_gain(float gain)
1388 {
1389 APPL_TRACE_DEBUG("%s set gain to %f", __func__, gain);
1390 BtifAvrcpSetAudioTrackGain(btif_media_cb.audio_track, gain);
1391 }
1392 #endif
1393
1394 #if (BTA_AV_SINK_INCLUDED == TRUE)
btif_media_task_avk_handle_timer(UNUSED_ATTR void * context)1395 static void btif_media_task_avk_handle_timer(UNUSED_ATTR void *context)
1396 {
1397 tBT_SBC_HDR *p_msg;
1398 int num_sbc_frames;
1399 int num_frames_to_process;
1400
1401 if (fixed_queue_is_empty(btif_media_cb.RxSbcQ))
1402 {
1403 APPL_TRACE_DEBUG(" QUE EMPTY ");
1404 }
1405 else
1406 {
1407 #ifdef USE_AUDIO_TRACK
1408 /* Don't Do anything in case of Not granted */
1409 if (btif_media_cb.rx_audio_focus_state == BTIF_MEDIA_FOCUS_NOT_GRANTED)
1410 {
1411 APPL_TRACE_DEBUG("%s skipping frames since focus is not present.", __func__);
1412 return;
1413 }
1414 /* play only in BTIF_MEDIA_FOCUS_GRANTED case */
1415 #endif
1416 if (btif_media_cb.rx_flush == TRUE)
1417 {
1418 btif_media_flush_q(btif_media_cb.RxSbcQ);
1419 return;
1420 }
1421
1422 num_frames_to_process = btif_media_cb.frames_to_process;
1423 APPL_TRACE_DEBUG(" Process Frames + ");
1424
1425 do
1426 {
1427 p_msg = (tBT_SBC_HDR *)fixed_queue_try_peek_first(btif_media_cb.RxSbcQ);
1428 if (p_msg == NULL)
1429 return;
1430 num_sbc_frames = p_msg->num_frames_to_be_processed; /* num of frames in Que Packets */
1431 APPL_TRACE_DEBUG(" Frames left in topmost packet %d", num_sbc_frames);
1432 APPL_TRACE_DEBUG(" Remaining frames to process in tick %d", num_frames_to_process);
1433 APPL_TRACE_DEBUG(" Num of Packets in Que %d",
1434 fixed_queue_length(btif_media_cb.RxSbcQ));
1435
1436 if ( num_sbc_frames > num_frames_to_process) /* Que Packet has more frames*/
1437 {
1438 p_msg->num_frames_to_be_processed= num_frames_to_process;
1439 btif_media_task_handle_inc_media(p_msg);
1440 p_msg->num_frames_to_be_processed = num_sbc_frames - num_frames_to_process;
1441 num_frames_to_process = 0;
1442 break;
1443 }
1444 else /* Que packet has less frames */
1445 {
1446 btif_media_task_handle_inc_media(p_msg);
1447 p_msg = (tBT_SBC_HDR *)fixed_queue_try_dequeue(btif_media_cb.RxSbcQ);
1448 if( p_msg == NULL )
1449 {
1450 APPL_TRACE_ERROR("Insufficient data in que ");
1451 break;
1452 }
1453 num_frames_to_process = num_frames_to_process - p_msg->num_frames_to_be_processed;
1454 osi_free(p_msg);
1455 }
1456 } while(num_frames_to_process > 0);
1457
1458 APPL_TRACE_DEBUG(" Process Frames - ");
1459 }
1460 }
1461 #else
btif_media_task_avk_handle_timer(UNUSED_ATTR void * context)1462 static void btif_media_task_avk_handle_timer(UNUSED_ATTR void *context) {}
1463 #endif
1464
btif_media_task_aa_handle_timer(UNUSED_ATTR void * context)1465 static void btif_media_task_aa_handle_timer(UNUSED_ATTR void *context)
1466 {
1467 uint64_t timestamp_us = time_now_us();
1468 log_tstamps_us("media task tx timer", timestamp_us);
1469
1470 #if (BTA_AV_INCLUDED == TRUE)
1471 if (alarm_is_scheduled(btif_media_cb.media_alarm))
1472 {
1473 btif_media_send_aa_frame(timestamp_us);
1474 update_scheduling_stats(&btif_media_cb.stats.tx_queue_enqueue_stats,
1475 timestamp_us,
1476 BTIF_SINK_MEDIA_TIME_TICK_MS * 1000);
1477 }
1478 else
1479 {
1480 APPL_TRACE_ERROR("ERROR Media task Scheduled after Suspend");
1481 }
1482 #endif
1483 }
1484
1485 #if (BTA_AV_INCLUDED == TRUE)
btif_media_task_aa_handle_uipc_rx_rdy(void)1486 static void btif_media_task_aa_handle_uipc_rx_rdy(void)
1487 {
1488 /* process all the UIPC data */
1489 btif_media_aa_prep_2_send(0xFF, time_now_us());
1490
1491 /* send it */
1492 LOG_VERBOSE(LOG_TAG, "%s calls bta_av_ci_src_data_ready", __func__);
1493 bta_av_ci_src_data_ready(BTA_AV_CHNL_AUDIO);
1494 }
1495 #endif
1496
btif_media_thread_init(UNUSED_ATTR void * context)1497 static void btif_media_thread_init(UNUSED_ATTR void *context) {
1498 // Check to make sure the platform has 8 bits/byte since
1499 // we're using that in frame size calculations now.
1500 assert(CHAR_BIT == 8);
1501
1502 memset(&btif_media_cb, 0, sizeof(btif_media_cb));
1503
1504 UIPC_Init(NULL);
1505
1506 #if (BTA_AV_INCLUDED == TRUE)
1507 btif_media_cb.TxAaQ = fixed_queue_new(SIZE_MAX);
1508 btif_media_cb.RxSbcQ = fixed_queue_new(SIZE_MAX);
1509 UIPC_Open(UIPC_CH_ID_AV_CTRL , btif_a2dp_ctrl_cb);
1510 #endif
1511
1512 raise_priority_a2dp(TASK_HIGH_MEDIA);
1513 media_task_running = MEDIA_TASK_STATE_ON;
1514 metrics_log_bluetooth_session_start(CONNECTION_TECHNOLOGY_TYPE_BREDR, 0);
1515 }
1516
btif_media_thread_cleanup(UNUSED_ATTR void * context)1517 static void btif_media_thread_cleanup(UNUSED_ATTR void *context) {
1518 /* make sure no channels are restarted while shutting down */
1519 media_task_running = MEDIA_TASK_STATE_SHUTTING_DOWN;
1520
1521 /* this calls blocks until uipc is fully closed */
1522 UIPC_Close(UIPC_CH_ID_ALL);
1523
1524 #if (BTA_AV_INCLUDED == TRUE)
1525 fixed_queue_free(btif_media_cb.TxAaQ, NULL);
1526 btif_media_cb.TxAaQ = NULL;
1527 fixed_queue_free(btif_media_cb.RxSbcQ, NULL);
1528 btif_media_cb.RxSbcQ = NULL;
1529 #endif
1530
1531 /* Clear media task flag */
1532 media_task_running = MEDIA_TASK_STATE_OFF;
1533 metrics_log_bluetooth_session_end(DISCONNECT_REASON_UNKNOWN, 0);
1534 }
1535
1536 /*******************************************************************************
1537 **
1538 ** Function btif_media_task_send_cmd_evt
1539 **
1540 ** Description
1541 **
1542 ** Returns TRUE is success
1543 **
1544 *******************************************************************************/
btif_media_task_send_cmd_evt(UINT16 Evt)1545 BOOLEAN btif_media_task_send_cmd_evt(UINT16 Evt)
1546 {
1547 BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
1548
1549 p_buf->event = Evt;
1550 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1551
1552 return TRUE;
1553 }
1554
1555 /*******************************************************************************
1556 **
1557 ** Function btif_media_flush_q
1558 **
1559 ** Description
1560 **
1561 ** Returns void
1562 **
1563 *******************************************************************************/
btif_media_flush_q(fixed_queue_t * p_q)1564 static void btif_media_flush_q(fixed_queue_t *p_q)
1565 {
1566 while (! fixed_queue_is_empty(p_q))
1567 {
1568 osi_free(fixed_queue_try_dequeue(p_q));
1569 }
1570 }
1571
btif_media_thread_handle_cmd(fixed_queue_t * queue,UNUSED_ATTR void * context)1572 static void btif_media_thread_handle_cmd(fixed_queue_t *queue, UNUSED_ATTR void *context)
1573 {
1574 BT_HDR *p_msg = (BT_HDR *)fixed_queue_dequeue(queue);
1575 LOG_VERBOSE(LOG_TAG, "btif_media_thread_handle_cmd : %d %s", p_msg->event,
1576 dump_media_event(p_msg->event));
1577
1578 switch (p_msg->event)
1579 {
1580 #if (BTA_AV_INCLUDED == TRUE)
1581 case BTIF_MEDIA_START_AA_TX:
1582 btif_media_task_aa_start_tx();
1583 break;
1584 case BTIF_MEDIA_STOP_AA_TX:
1585 btif_media_task_aa_stop_tx();
1586 break;
1587 case BTIF_MEDIA_SBC_ENC_INIT:
1588 btif_media_task_enc_init(p_msg);
1589 break;
1590 case BTIF_MEDIA_SBC_ENC_UPDATE:
1591 btif_media_task_enc_update(p_msg);
1592 break;
1593 case BTIF_MEDIA_AUDIO_FEEDING_INIT:
1594 btif_media_task_audio_feeding_init(p_msg);
1595 break;
1596 case BTIF_MEDIA_FLUSH_AA_TX:
1597 btif_media_task_aa_tx_flush(p_msg);
1598 break;
1599 case BTIF_MEDIA_UIPC_RX_RDY:
1600 btif_media_task_aa_handle_uipc_rx_rdy();
1601 break;
1602 #ifdef USE_AUDIO_TRACK
1603 case BTIF_MEDIA_AUDIO_SINK_SET_FOCUS_STATE:
1604 if(!btif_av_is_connected())
1605 break;
1606 btif_media_cb.rx_audio_focus_state = ((tBTIF_MEDIA_SINK_FOCUS_UPDATE *)p_msg)->focus_state;
1607 APPL_TRACE_DEBUG("Setting focus state to %d ",btif_media_cb.rx_audio_focus_state);
1608 break;
1609 #endif
1610 case BTIF_MEDIA_AUDIO_SINK_CFG_UPDATE:
1611 #if (BTA_AV_SINK_INCLUDED == TRUE)
1612 btif_media_task_aa_handle_decoder_reset(p_msg);
1613 #endif
1614 break;
1615 case BTIF_MEDIA_AUDIO_SINK_CLEAR_TRACK:
1616 #if (BTA_AV_SINK_INCLUDED == TRUE)
1617 btif_media_task_aa_handle_clear_track();
1618 #endif
1619 break;
1620 case BTIF_MEDIA_FLUSH_AA_RX:
1621 btif_media_task_aa_rx_flush();
1622 break;
1623 #endif
1624 default:
1625 APPL_TRACE_ERROR("ERROR in %s unknown event %d", __func__, p_msg->event);
1626 }
1627 osi_free(p_msg);
1628 LOG_VERBOSE(LOG_TAG, "%s: %s DONE", __func__, dump_media_event(p_msg->event));
1629 }
1630
1631 #if (BTA_AV_SINK_INCLUDED == TRUE)
1632 /*******************************************************************************
1633 **
1634 ** Function btif_media_task_handle_inc_media
1635 **
1636 ** Description
1637 **
1638 ** Returns void
1639 **
1640 *******************************************************************************/
btif_media_task_handle_inc_media(tBT_SBC_HDR * p_msg)1641 static void btif_media_task_handle_inc_media(tBT_SBC_HDR*p_msg)
1642 {
1643 UINT8 *sbc_start_frame = ((UINT8*)(p_msg + 1) + p_msg->offset + 1);
1644 int count;
1645 UINT32 pcmBytes, availPcmBytes;
1646 OI_INT16 *pcmDataPointer = pcmData; /*Will be overwritten on next packet receipt*/
1647 OI_STATUS status;
1648 int num_sbc_frames = p_msg->num_frames_to_be_processed;
1649 UINT32 sbc_frame_len = p_msg->len - 1;
1650 availPcmBytes = sizeof(pcmData);
1651
1652 if ((btif_media_cb.peer_sep == AVDT_TSEP_SNK) || (btif_media_cb.rx_flush))
1653 {
1654 APPL_TRACE_DEBUG(" State Changed happened in this tick ");
1655 return;
1656 }
1657 #ifndef USE_AUDIO_TRACK
1658 // ignore data if no one is listening
1659 if (!btif_media_cb.data_channel_open)
1660 {
1661 APPL_TRACE_ERROR("%s Channel not open, returning", __func__);
1662 return;
1663 }
1664 #endif
1665 APPL_TRACE_DEBUG("%s Number of sbc frames %d, frame_len %d",
1666 __func__, num_sbc_frames, sbc_frame_len);
1667
1668 for(count = 0; count < num_sbc_frames && sbc_frame_len != 0; count ++)
1669 {
1670 pcmBytes = availPcmBytes;
1671 status = OI_CODEC_SBC_DecodeFrame(&context, (const OI_BYTE**)&sbc_start_frame,
1672 (OI_UINT32 *)&sbc_frame_len,
1673 (OI_INT16 *)pcmDataPointer,
1674 (OI_UINT32 *)&pcmBytes);
1675 if (!OI_SUCCESS(status)) {
1676 APPL_TRACE_ERROR("Decoding failure: %d\n", status);
1677 break;
1678 }
1679 availPcmBytes -= pcmBytes;
1680 pcmDataPointer += pcmBytes/2;
1681 p_msg->offset += (p_msg->len - 1) - sbc_frame_len;
1682 p_msg->len = sbc_frame_len + 1;
1683 }
1684
1685 #ifdef USE_AUDIO_TRACK
1686 BtifAvrcpAudioTrackWriteData(
1687 btif_media_cb.audio_track, (void*)pcmData, (sizeof(pcmData) - availPcmBytes));
1688 #else
1689 UIPC_Send(UIPC_CH_ID_AV_AUDIO, 0, (UINT8 *)pcmData, (sizeof(pcmData) - availPcmBytes));
1690 #endif
1691 }
1692 #endif
1693
1694 #if (BTA_AV_INCLUDED == TRUE)
1695 /*******************************************************************************
1696 **
1697 ** Function btif_media_task_enc_init_req
1698 **
1699 ** Description
1700 **
1701 ** Returns TRUE is success
1702 **
1703 *******************************************************************************/
btif_media_task_enc_init_req(tBTIF_MEDIA_INIT_AUDIO * p_msg)1704 BOOLEAN btif_media_task_enc_init_req(tBTIF_MEDIA_INIT_AUDIO *p_msg)
1705 {
1706 tBTIF_MEDIA_INIT_AUDIO *p_buf = osi_malloc(sizeof(tBTIF_MEDIA_INIT_AUDIO));
1707
1708 memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_INIT_AUDIO));
1709 p_buf->hdr.event = BTIF_MEDIA_SBC_ENC_INIT;
1710 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1711
1712 return TRUE;
1713 }
1714
1715 /*******************************************************************************
1716 **
1717 ** Function btif_media_task_enc_update_req
1718 **
1719 ** Description
1720 **
1721 ** Returns TRUE is success
1722 **
1723 *******************************************************************************/
btif_media_task_enc_update_req(tBTIF_MEDIA_UPDATE_AUDIO * p_msg)1724 BOOLEAN btif_media_task_enc_update_req(tBTIF_MEDIA_UPDATE_AUDIO *p_msg)
1725 {
1726 tBTIF_MEDIA_UPDATE_AUDIO *p_buf =
1727 osi_malloc(sizeof(tBTIF_MEDIA_UPDATE_AUDIO));
1728
1729 memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_UPDATE_AUDIO));
1730 p_buf->hdr.event = BTIF_MEDIA_SBC_ENC_UPDATE;
1731 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1732
1733 return TRUE;
1734 }
1735
1736 /*******************************************************************************
1737 **
1738 ** Function btif_media_task_audio_feeding_init_req
1739 **
1740 ** Description
1741 **
1742 ** Returns TRUE is success
1743 **
1744 *******************************************************************************/
btif_media_task_audio_feeding_init_req(tBTIF_MEDIA_INIT_AUDIO_FEEDING * p_msg)1745 BOOLEAN btif_media_task_audio_feeding_init_req(tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_msg)
1746 {
1747 tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_buf =
1748 osi_malloc(sizeof(tBTIF_MEDIA_INIT_AUDIO_FEEDING));
1749
1750 memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_INIT_AUDIO_FEEDING));
1751 p_buf->hdr.event = BTIF_MEDIA_AUDIO_FEEDING_INIT;
1752 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1753
1754 return TRUE;
1755 }
1756
1757 /*******************************************************************************
1758 **
1759 ** Function btif_media_task_start_aa_req
1760 **
1761 ** Description
1762 **
1763 ** Returns TRUE is success
1764 **
1765 *******************************************************************************/
btif_media_task_start_aa_req(void)1766 BOOLEAN btif_media_task_start_aa_req(void)
1767 {
1768 BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
1769
1770 p_buf->event = BTIF_MEDIA_START_AA_TX;
1771 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1772
1773 memset(&btif_media_cb.stats, 0, sizeof(btif_media_stats_t));
1774 // Assign session_start_us to 1 when time_now_us() is 0 to indicate
1775 // btif_media_task_start_aa_req() has been called
1776 btif_media_cb.stats.session_start_us = time_now_us();
1777 if (btif_media_cb.stats.session_start_us == 0) {
1778 btif_media_cb.stats.session_start_us = 1;
1779 }
1780 btif_media_cb.stats.session_end_us = 0;
1781 return TRUE;
1782 }
1783
1784 /*******************************************************************************
1785 **
1786 ** Function btif_media_task_stop_aa_req
1787 **
1788 ** Description
1789 **
1790 ** Returns TRUE is success
1791 **
1792 *******************************************************************************/
btif_media_task_stop_aa_req(void)1793 BOOLEAN btif_media_task_stop_aa_req(void)
1794 {
1795 BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
1796
1797 p_buf->event = BTIF_MEDIA_STOP_AA_TX;
1798
1799 /*
1800 * Explicitly check whether the btif_media_cmd_msg_queue is not NULL to
1801 * avoid a race condition during shutdown of the Bluetooth stack.
1802 * This race condition is triggered when A2DP audio is streaming on
1803 * shutdown:
1804 * "btif_a2dp_on_stopped() -> btif_media_task_stop_aa_req()" is called
1805 * to stop the particular audio stream, and this happens right after
1806 * the "cleanup() -> btif_a2dp_stop_media_task()" processing during
1807 * the shutdown of the Bluetooth stack.
1808 */
1809 if (btif_media_cmd_msg_queue != NULL) {
1810 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1811 }
1812
1813 btif_media_cb.stats.session_end_us = time_now_us();
1814 btif_update_a2dp_metrics();
1815 btif_a2dp_source_accumulate_stats(&btif_media_cb.stats,
1816 &btif_media_cb.accumulated_stats);
1817
1818 return TRUE;
1819 }
1820 /*******************************************************************************
1821 **
1822 ** Function btif_media_task_aa_rx_flush_req
1823 **
1824 ** Description
1825 **
1826 ** Returns TRUE is success
1827 **
1828 *******************************************************************************/
btif_media_task_aa_rx_flush_req(void)1829 BOOLEAN btif_media_task_aa_rx_flush_req(void)
1830 {
1831 if (fixed_queue_is_empty(btif_media_cb.RxSbcQ)) /* Que is already empty */
1832 return TRUE;
1833
1834 BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
1835 p_buf->event = BTIF_MEDIA_FLUSH_AA_RX;
1836 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1837
1838 return TRUE;
1839 }
1840
1841 /*******************************************************************************
1842 **
1843 ** Function btif_media_task_aa_tx_flush_req
1844 **
1845 ** Description
1846 **
1847 ** Returns TRUE is success
1848 **
1849 *******************************************************************************/
btif_media_task_aa_tx_flush_req(void)1850 BOOLEAN btif_media_task_aa_tx_flush_req(void)
1851 {
1852 BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
1853
1854 p_buf->event = BTIF_MEDIA_FLUSH_AA_TX;
1855
1856 /*
1857 * Explicitly check whether the btif_media_cmd_msg_queue is not NULL to
1858 * avoid a race condition during shutdown of the Bluetooth stack.
1859 * This race condition is triggered when A2DP audio is streaming on
1860 * shutdown:
1861 * "btif_a2dp_on_stopped() -> btif_media_task_aa_tx_flush_req()" is called
1862 * to stop the particular audio stream, and this happens right after
1863 * the "cleanup() -> btif_a2dp_stop_media_task()" processing during
1864 * the shutdown of the Bluetooth stack.
1865 */
1866 if (btif_media_cmd_msg_queue != NULL)
1867 fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
1868
1869 return TRUE;
1870 }
1871 /*******************************************************************************
1872 **
1873 ** Function btif_media_task_aa_rx_flush
1874 **
1875 ** Description
1876 **
1877 ** Returns void
1878 **
1879 *******************************************************************************/
btif_media_task_aa_rx_flush(void)1880 static void btif_media_task_aa_rx_flush(void)
1881 {
1882 /* Flush all enqueued GKI SBC buffers (encoded) */
1883 APPL_TRACE_DEBUG("btif_media_task_aa_rx_flush");
1884
1885 btif_media_flush_q(btif_media_cb.RxSbcQ);
1886 }
1887
1888
1889 /*******************************************************************************
1890 **
1891 ** Function btif_media_task_aa_tx_flush
1892 **
1893 ** Description
1894 **
1895 ** Returns void
1896 **
1897 *******************************************************************************/
btif_media_task_aa_tx_flush(BT_HDR * p_msg)1898 static void btif_media_task_aa_tx_flush(BT_HDR *p_msg)
1899 {
1900 UNUSED(p_msg);
1901
1902 /* Flush all enqueued GKI music buffers (encoded) */
1903 APPL_TRACE_DEBUG("btif_media_task_aa_tx_flush");
1904
1905 btif_media_cb.media_feeding_state.pcm.counter = 0;
1906 btif_media_cb.media_feeding_state.pcm.aa_feed_residue = 0;
1907
1908 btif_media_cb.stats.tx_queue_total_flushed_messages +=
1909 fixed_queue_length(btif_media_cb.TxAaQ);
1910 btif_media_cb.stats.tx_queue_last_flushed_us = time_now_us();
1911 btif_media_flush_q(btif_media_cb.TxAaQ);
1912
1913 UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REQ_RX_FLUSH, NULL);
1914 }
1915
1916 /*******************************************************************************
1917 **
1918 ** Function btif_media_task_enc_init
1919 **
1920 ** Description Initialize encoding task
1921 **
1922 ** Returns void
1923 **
1924 *******************************************************************************/
btif_media_task_enc_init(BT_HDR * p_msg)1925 static void btif_media_task_enc_init(BT_HDR *p_msg)
1926 {
1927 tBTIF_MEDIA_INIT_AUDIO *pInitAudio = (tBTIF_MEDIA_INIT_AUDIO *) p_msg;
1928
1929 APPL_TRACE_DEBUG("btif_media_task_enc_init");
1930
1931 btif_media_cb.timestamp = 0;
1932
1933 /* SBC encoder config (enforced even if not used) */
1934 btif_media_cb.encoder.s16ChannelMode = pInitAudio->ChannelMode;
1935 btif_media_cb.encoder.s16NumOfSubBands = pInitAudio->NumOfSubBands;
1936 btif_media_cb.encoder.s16NumOfBlocks = pInitAudio->NumOfBlocks;
1937 btif_media_cb.encoder.s16AllocationMethod = pInitAudio->AllocationMethod;
1938 btif_media_cb.encoder.s16SamplingFreq = pInitAudio->SamplingFreq;
1939
1940 btif_media_cb.encoder.u16BitRate = btif_media_task_get_sbc_rate();
1941
1942 /* Default transcoding is PCM to SBC, modified by feeding configuration */
1943 btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_SBC;
1944 btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE-BTIF_MEDIA_AA_SBC_OFFSET-sizeof(BT_HDR))
1945 < pInitAudio->MtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET
1946 - sizeof(BT_HDR)) : pInitAudio->MtuSize;
1947
1948 APPL_TRACE_EVENT("btif_media_task_enc_init busy %d, mtu %d, peer mtu %d",
1949 btif_media_cb.busy_level, btif_media_cb.TxAaMtuSize, pInitAudio->MtuSize);
1950 APPL_TRACE_EVENT(" ch mode %d, subnd %d, nb blk %d, alloc %d, rate %d, freq %d",
1951 btif_media_cb.encoder.s16ChannelMode, btif_media_cb.encoder.s16NumOfSubBands,
1952 btif_media_cb.encoder.s16NumOfBlocks,
1953 btif_media_cb.encoder.s16AllocationMethod, btif_media_cb.encoder.u16BitRate,
1954 btif_media_cb.encoder.s16SamplingFreq);
1955
1956 /* Reset entirely the SBC encoder */
1957 SBC_Encoder_Init(&(btif_media_cb.encoder));
1958
1959 btif_media_cb.tx_sbc_frames = calculate_max_frames_per_packet();
1960
1961 APPL_TRACE_DEBUG("%s bit pool %d", __func__, btif_media_cb.encoder.s16BitPool);
1962 }
1963
1964 /*******************************************************************************
1965 **
1966 ** Function btif_media_task_enc_update
1967 **
1968 ** Description Update encoding task
1969 **
1970 ** Returns void
1971 **
1972 *******************************************************************************/
1973
btif_media_task_enc_update(BT_HDR * p_msg)1974 static void btif_media_task_enc_update(BT_HDR *p_msg)
1975 {
1976 tBTIF_MEDIA_UPDATE_AUDIO * pUpdateAudio = (tBTIF_MEDIA_UPDATE_AUDIO *) p_msg;
1977 SBC_ENC_PARAMS *pstrEncParams = &btif_media_cb.encoder;
1978 UINT16 s16SamplingFreq;
1979 SINT16 s16BitPool = 0;
1980 SINT16 s16BitRate;
1981 SINT16 s16FrameLen;
1982 UINT8 protect = 0;
1983
1984 APPL_TRACE_DEBUG("%s : minmtu %d, maxbp %d minbp %d", __func__,
1985 pUpdateAudio->MinMtuSize, pUpdateAudio->MaxBitPool,
1986 pUpdateAudio->MinBitPool);
1987
1988 if (!pstrEncParams->s16NumOfSubBands)
1989 {
1990 APPL_TRACE_WARNING("%s SubBands are set to 0, resetting to max (%d)",
1991 __func__, SBC_MAX_NUM_OF_SUBBANDS);
1992 pstrEncParams->s16NumOfSubBands = SBC_MAX_NUM_OF_SUBBANDS;
1993 }
1994
1995 if (!pstrEncParams->s16NumOfBlocks)
1996 {
1997 APPL_TRACE_WARNING("%s Blocks are set to 0, resetting to max (%d)",
1998 __func__, SBC_MAX_NUM_OF_BLOCKS);
1999 pstrEncParams->s16NumOfBlocks = SBC_MAX_NUM_OF_BLOCKS;
2000 }
2001
2002 if (!pstrEncParams->s16NumOfChannels)
2003 {
2004 APPL_TRACE_WARNING("%s Channels are set to 0, resetting to max (%d)",
2005 __func__, SBC_MAX_NUM_OF_CHANNELS);
2006 pstrEncParams->s16NumOfChannels = SBC_MAX_NUM_OF_CHANNELS;
2007 }
2008
2009 btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE -
2010 BTIF_MEDIA_AA_SBC_OFFSET - sizeof(BT_HDR))
2011 < pUpdateAudio->MinMtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET
2012 - sizeof(BT_HDR)) : pUpdateAudio->MinMtuSize;
2013
2014 /* Set the initial target bit rate */
2015 pstrEncParams->u16BitRate = btif_media_task_get_sbc_rate();
2016
2017 if (pstrEncParams->s16SamplingFreq == SBC_sf16000)
2018 s16SamplingFreq = 16000;
2019 else if (pstrEncParams->s16SamplingFreq == SBC_sf32000)
2020 s16SamplingFreq = 32000;
2021 else if (pstrEncParams->s16SamplingFreq == SBC_sf44100)
2022 s16SamplingFreq = 44100;
2023 else
2024 s16SamplingFreq = 48000;
2025
2026 do {
2027 if (pstrEncParams->s16NumOfBlocks == 0 ||
2028 pstrEncParams->s16NumOfSubBands == 0 ||
2029 pstrEncParams->s16NumOfChannels == 0) {
2030 APPL_TRACE_ERROR("%s - Avoiding division by zero...", __func__);
2031 APPL_TRACE_ERROR("%s - block=%d, subBands=%d, channels=%d",
2032 __func__,
2033 pstrEncParams->s16NumOfBlocks,
2034 pstrEncParams->s16NumOfSubBands,
2035 pstrEncParams->s16NumOfChannels);
2036 break;
2037 }
2038
2039 if ((pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) ||
2040 (pstrEncParams->s16ChannelMode == SBC_STEREO)) {
2041 s16BitPool = (SINT16)((pstrEncParams->u16BitRate *
2042 pstrEncParams->s16NumOfSubBands * 1000 / s16SamplingFreq)
2043 - ((32 + (4 * pstrEncParams->s16NumOfSubBands *
2044 pstrEncParams->s16NumOfChannels)
2045 + ((pstrEncParams->s16ChannelMode - 2) *
2046 pstrEncParams->s16NumOfSubBands))
2047 / pstrEncParams->s16NumOfBlocks));
2048
2049 s16FrameLen = 4 + (4*pstrEncParams->s16NumOfSubBands *
2050 pstrEncParams->s16NumOfChannels) / 8
2051 + (((pstrEncParams->s16ChannelMode - 2) *
2052 pstrEncParams->s16NumOfSubBands)
2053 + (pstrEncParams->s16NumOfBlocks * s16BitPool)) / 8;
2054
2055 s16BitRate = (8 * s16FrameLen * s16SamplingFreq)
2056 / (pstrEncParams->s16NumOfSubBands *
2057 pstrEncParams->s16NumOfBlocks * 1000);
2058
2059 if (s16BitRate > pstrEncParams->u16BitRate)
2060 s16BitPool--;
2061
2062 if (pstrEncParams->s16NumOfSubBands == 8)
2063 s16BitPool = (s16BitPool > 255) ? 255 : s16BitPool;
2064 else
2065 s16BitPool = (s16BitPool > 128) ? 128 : s16BitPool;
2066 } else {
2067 s16BitPool = (SINT16)(((pstrEncParams->s16NumOfSubBands *
2068 pstrEncParams->u16BitRate * 1000)
2069 / (s16SamplingFreq * pstrEncParams->s16NumOfChannels))
2070 - (((32 / pstrEncParams->s16NumOfChannels) +
2071 (4 * pstrEncParams->s16NumOfSubBands))
2072 / pstrEncParams->s16NumOfBlocks));
2073
2074 pstrEncParams->s16BitPool =
2075 (s16BitPool > (16 * pstrEncParams->s16NumOfSubBands)) ?
2076 (16 * pstrEncParams->s16NumOfSubBands) : s16BitPool;
2077 }
2078
2079 if (s16BitPool < 0)
2080 s16BitPool = 0;
2081
2082 APPL_TRACE_EVENT("%s bitpool candidate : %d (%d kbps)", __func__,
2083 s16BitPool, pstrEncParams->u16BitRate);
2084
2085 if (s16BitPool > pUpdateAudio->MaxBitPool) {
2086 APPL_TRACE_DEBUG("%s computed bitpool too large (%d)", __func__,
2087 s16BitPool);
2088 /* Decrease bitrate */
2089 btif_media_cb.encoder.u16BitRate -= BTIF_MEDIA_BITRATE_STEP;
2090 /* Record that we have decreased the bitrate */
2091 protect |= 1;
2092 } else if (s16BitPool < pUpdateAudio->MinBitPool) {
2093 APPL_TRACE_WARNING("%s computed bitpool too small (%d)", __func__,
2094 s16BitPool);
2095
2096 /* Increase bitrate */
2097 UINT16 previous_u16BitRate = btif_media_cb.encoder.u16BitRate;
2098 btif_media_cb.encoder.u16BitRate += BTIF_MEDIA_BITRATE_STEP;
2099 /* Record that we have increased the bitrate */
2100 protect |= 2;
2101 /* Check over-flow */
2102 if (btif_media_cb.encoder.u16BitRate < previous_u16BitRate)
2103 protect |= 3;
2104 } else {
2105 break;
2106 }
2107 /* In case we have already increased and decreased the bitrate, just stop */
2108 if (protect == 3) {
2109 APPL_TRACE_ERROR("%s could not find bitpool in range", __func__);
2110 break;
2111 }
2112 } while (1);
2113
2114 /* Finally update the bitpool in the encoder structure */
2115 pstrEncParams->s16BitPool = s16BitPool;
2116
2117 APPL_TRACE_DEBUG("%s final bit rate %d, final bit pool %d", __func__,
2118 btif_media_cb.encoder.u16BitRate,
2119 btif_media_cb.encoder.s16BitPool);
2120
2121 /* make sure we reinitialize encoder with new settings */
2122 SBC_Encoder_Init(&(btif_media_cb.encoder));
2123
2124 btif_media_cb.tx_sbc_frames = calculate_max_frames_per_packet();
2125 }
2126
2127 /*******************************************************************************
2128 **
2129 ** Function btif_media_task_pcm2sbc_init
2130 **
2131 ** Description Init encoding task for PCM to SBC according to feeding
2132 **
2133 ** Returns void
2134 **
2135 *******************************************************************************/
btif_media_task_pcm2sbc_init(tBTIF_MEDIA_INIT_AUDIO_FEEDING * p_feeding)2136 static void btif_media_task_pcm2sbc_init(tBTIF_MEDIA_INIT_AUDIO_FEEDING * p_feeding)
2137 {
2138 BOOLEAN reconfig_needed = FALSE;
2139
2140 APPL_TRACE_DEBUG("PCM feeding:");
2141 APPL_TRACE_DEBUG("sampling_freq:%d", p_feeding->feeding.cfg.pcm.sampling_freq);
2142 APPL_TRACE_DEBUG("num_channel:%d", p_feeding->feeding.cfg.pcm.num_channel);
2143 APPL_TRACE_DEBUG("bit_per_sample:%d", p_feeding->feeding.cfg.pcm.bit_per_sample);
2144
2145 /* Check the PCM feeding sampling_freq */
2146 switch (p_feeding->feeding.cfg.pcm.sampling_freq)
2147 {
2148 case 8000:
2149 case 12000:
2150 case 16000:
2151 case 24000:
2152 case 32000:
2153 case 48000:
2154 /* For these sampling_freq the AV connection must be 48000 */
2155 if (btif_media_cb.encoder.s16SamplingFreq != SBC_sf48000)
2156 {
2157 /* Reconfiguration needed at 48000 */
2158 APPL_TRACE_DEBUG("SBC Reconfiguration needed at 48000");
2159 btif_media_cb.encoder.s16SamplingFreq = SBC_sf48000;
2160 reconfig_needed = TRUE;
2161 }
2162 break;
2163
2164 case 11025:
2165 case 22050:
2166 case 44100:
2167 /* For these sampling_freq the AV connection must be 44100 */
2168 if (btif_media_cb.encoder.s16SamplingFreq != SBC_sf44100)
2169 {
2170 /* Reconfiguration needed at 44100 */
2171 APPL_TRACE_DEBUG("SBC Reconfiguration needed at 44100");
2172 btif_media_cb.encoder.s16SamplingFreq = SBC_sf44100;
2173 reconfig_needed = TRUE;
2174 }
2175 break;
2176 default:
2177 APPL_TRACE_DEBUG("Feeding PCM sampling_freq unsupported");
2178 break;
2179 }
2180
2181 /* Some AV Headsets do not support Mono => always ask for Stereo */
2182 if (btif_media_cb.encoder.s16ChannelMode == SBC_MONO)
2183 {
2184 APPL_TRACE_DEBUG("SBC Reconfiguration needed in Stereo");
2185 btif_media_cb.encoder.s16ChannelMode = SBC_JOINT_STEREO;
2186 reconfig_needed = TRUE;
2187 }
2188
2189 if (reconfig_needed != FALSE)
2190 {
2191 APPL_TRACE_DEBUG("btif_media_task_pcm2sbc_init :: mtu %d", btif_media_cb.TxAaMtuSize);
2192 APPL_TRACE_DEBUG("ch mode %d, nbsubd %d, nb %d, alloc %d, rate %d, freq %d",
2193 btif_media_cb.encoder.s16ChannelMode,
2194 btif_media_cb.encoder.s16NumOfSubBands, btif_media_cb.encoder.s16NumOfBlocks,
2195 btif_media_cb.encoder.s16AllocationMethod, btif_media_cb.encoder.u16BitRate,
2196 btif_media_cb.encoder.s16SamplingFreq);
2197
2198 SBC_Encoder_Init(&(btif_media_cb.encoder));
2199 }
2200 else
2201 {
2202 APPL_TRACE_DEBUG("btif_media_task_pcm2sbc_init no SBC reconfig needed");
2203 }
2204 }
2205
2206
2207 /*******************************************************************************
2208 **
2209 ** Function btif_media_task_audio_feeding_init
2210 **
2211 ** Description Initialize the audio path according to the feeding format
2212 **
2213 ** Returns void
2214 **
2215 *******************************************************************************/
btif_media_task_audio_feeding_init(BT_HDR * p_msg)2216 static void btif_media_task_audio_feeding_init(BT_HDR *p_msg)
2217 {
2218 tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_feeding = (tBTIF_MEDIA_INIT_AUDIO_FEEDING *) p_msg;
2219
2220 APPL_TRACE_DEBUG("btif_media_task_audio_feeding_init format:%d", p_feeding->feeding.format);
2221
2222 /* Save Media Feeding information */
2223 btif_media_cb.feeding_mode = p_feeding->feeding_mode;
2224 btif_media_cb.media_feeding = p_feeding->feeding;
2225
2226 /* Handle different feeding formats */
2227 switch (p_feeding->feeding.format)
2228 {
2229 case BTIF_AV_CODEC_PCM:
2230 btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_SBC;
2231 btif_media_task_pcm2sbc_init(p_feeding);
2232 break;
2233
2234 default :
2235 APPL_TRACE_ERROR("unknown feeding format %d", p_feeding->feeding.format);
2236 break;
2237 }
2238 }
2239
btif_a2dp_get_track_frequency(UINT8 frequency)2240 int btif_a2dp_get_track_frequency(UINT8 frequency) {
2241 int freq = 48000;
2242 switch (frequency) {
2243 case A2D_SBC_IE_SAMP_FREQ_16:
2244 freq = 16000;
2245 break;
2246 case A2D_SBC_IE_SAMP_FREQ_32:
2247 freq = 32000;
2248 break;
2249 case A2D_SBC_IE_SAMP_FREQ_44:
2250 freq = 44100;
2251 break;
2252 case A2D_SBC_IE_SAMP_FREQ_48:
2253 freq = 48000;
2254 break;
2255 }
2256 return freq;
2257 }
2258
btif_a2dp_get_track_channel_count(UINT8 channeltype)2259 int btif_a2dp_get_track_channel_count(UINT8 channeltype) {
2260 int count = 1;
2261 switch (channeltype) {
2262 case A2D_SBC_IE_CH_MD_MONO:
2263 count = 1;
2264 break;
2265 case A2D_SBC_IE_CH_MD_DUAL:
2266 case A2D_SBC_IE_CH_MD_STEREO:
2267 case A2D_SBC_IE_CH_MD_JOINT:
2268 count = 2;
2269 break;
2270 }
2271 return count;
2272 }
2273
2274 #ifdef USE_AUDIO_TRACK
a2dp_get_track_channel_type(UINT8 channeltype)2275 int a2dp_get_track_channel_type(UINT8 channeltype) {
2276 int count = 1;
2277 switch (channeltype) {
2278 case A2D_SBC_IE_CH_MD_MONO:
2279 count = 1;
2280 break;
2281 case A2D_SBC_IE_CH_MD_DUAL:
2282 case A2D_SBC_IE_CH_MD_STEREO:
2283 case A2D_SBC_IE_CH_MD_JOINT:
2284 count = 3;
2285 break;
2286 }
2287 return count;
2288 }
2289 #endif
2290
btif_a2dp_set_peer_sep(UINT8 sep)2291 void btif_a2dp_set_peer_sep(UINT8 sep) {
2292 btif_media_cb.peer_sep = sep;
2293 }
2294
btif_decode_alarm_cb(UNUSED_ATTR void * context)2295 static void btif_decode_alarm_cb(UNUSED_ATTR void *context) {
2296 if(worker_thread != NULL)
2297 thread_post(worker_thread, btif_media_task_avk_handle_timer, NULL);
2298 }
2299
btif_media_task_aa_handle_stop_decoding(void)2300 static void btif_media_task_aa_handle_stop_decoding(void) {
2301 alarm_free(btif_media_cb.decode_alarm);
2302 btif_media_cb.decode_alarm = NULL;
2303 #ifdef USE_AUDIO_TRACK
2304 BtifAvrcpAudioTrackPause(btif_media_cb.audio_track);
2305 #endif
2306 }
2307
btif_media_task_aa_handle_start_decoding(void)2308 static void btif_media_task_aa_handle_start_decoding(void) {
2309 if (btif_media_cb.decode_alarm)
2310 return;
2311 #ifdef USE_AUDIO_TRACK
2312 BtifAvrcpAudioTrackStart(btif_media_cb.audio_track);
2313 #endif
2314 btif_media_cb.decode_alarm = alarm_new_periodic("btif.media_decode");
2315 if (!btif_media_cb.decode_alarm) {
2316 LOG_ERROR(LOG_TAG, "%s unable to allocate decode alarm.", __func__);
2317 return;
2318 }
2319
2320 alarm_set(btif_media_cb.decode_alarm, BTIF_SINK_MEDIA_TIME_TICK_MS,
2321 btif_decode_alarm_cb, NULL);
2322 }
2323
2324 #if (BTA_AV_SINK_INCLUDED == TRUE)
2325
btif_media_task_aa_handle_clear_track(void)2326 static void btif_media_task_aa_handle_clear_track (void)
2327 {
2328 APPL_TRACE_DEBUG("btif_media_task_aa_handle_clear_track");
2329 #ifdef USE_AUDIO_TRACK
2330 BtifAvrcpAudioTrackStop(btif_media_cb.audio_track);
2331 BtifAvrcpAudioTrackDelete(btif_media_cb.audio_track);
2332 btif_media_cb.audio_track = NULL;
2333 #endif
2334 }
2335
2336 /*******************************************************************************
2337 **
2338 ** Function btif_media_task_aa_handle_decoder_reset
2339 **
2340 ** Description
2341 **
2342 ** Returns void
2343 **
2344 *******************************************************************************/
btif_media_task_aa_handle_decoder_reset(BT_HDR * p_msg)2345 static void btif_media_task_aa_handle_decoder_reset(BT_HDR *p_msg)
2346 {
2347 tBTIF_MEDIA_SINK_CFG_UPDATE *p_buf = (tBTIF_MEDIA_SINK_CFG_UPDATE*) p_msg;
2348 tA2D_STATUS a2d_status;
2349 tA2D_SBC_CIE sbc_cie;
2350 OI_STATUS status;
2351 UINT32 freq_multiple = 48*20; /* frequency multiple for 20ms of data , initialize with 48K*/
2352 UINT32 num_blocks = 16;
2353 UINT32 num_subbands = 8;
2354
2355 APPL_TRACE_DEBUG("btif_media_task_aa_handle_decoder_reset p_codec_info[%x:%x:%x:%x:%x:%x]",
2356 p_buf->codec_info[1], p_buf->codec_info[2], p_buf->codec_info[3],
2357 p_buf->codec_info[4], p_buf->codec_info[5], p_buf->codec_info[6]);
2358
2359 a2d_status = A2D_ParsSbcInfo(&sbc_cie, p_buf->codec_info, FALSE);
2360 if (a2d_status != A2D_SUCCESS)
2361 {
2362 APPL_TRACE_ERROR("ERROR dump_codec_info A2D_ParsSbcInfo fail:%d", a2d_status);
2363 return;
2364 }
2365
2366 btif_media_cb.sample_rate = btif_a2dp_get_track_frequency(sbc_cie.samp_freq);
2367 btif_media_cb.channel_count = btif_a2dp_get_track_channel_count(sbc_cie.ch_mode);
2368
2369 btif_media_cb.rx_flush = FALSE;
2370 APPL_TRACE_DEBUG("Reset to sink role");
2371 status = OI_CODEC_SBC_DecoderReset(&context, contextData, sizeof(contextData), 2, 2, FALSE);
2372 if (!OI_SUCCESS(status)) {
2373 APPL_TRACE_ERROR("OI_CODEC_SBC_DecoderReset failed with error code %d\n", status);
2374 }
2375
2376 #ifdef USE_AUDIO_TRACK
2377 APPL_TRACE_DEBUG("%s A2dpSink: sbc Create Track", __func__);
2378 btif_media_cb.audio_track =
2379 BtifAvrcpAudioTrackCreate(btif_a2dp_get_track_frequency(sbc_cie.samp_freq),
2380 a2dp_get_track_channel_type(sbc_cie.ch_mode));
2381 if (btif_media_cb.audio_track == NULL) {
2382 APPL_TRACE_ERROR("%s A2dpSink: Track creation fails!!!", __func__);
2383 return;
2384 }
2385 #else
2386 UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);
2387 #endif
2388
2389 switch (sbc_cie.samp_freq)
2390 {
2391 case A2D_SBC_IE_SAMP_FREQ_16:
2392 APPL_TRACE_DEBUG("\tsamp_freq:%d (16000)", sbc_cie.samp_freq);
2393 freq_multiple = 16*20;
2394 break;
2395 case A2D_SBC_IE_SAMP_FREQ_32:
2396 APPL_TRACE_DEBUG("\tsamp_freq:%d (32000)", sbc_cie.samp_freq);
2397 freq_multiple = 32*20;
2398 break;
2399 case A2D_SBC_IE_SAMP_FREQ_44:
2400 APPL_TRACE_DEBUG("\tsamp_freq:%d (44100)", sbc_cie.samp_freq);
2401 freq_multiple = 441*2;
2402 break;
2403 case A2D_SBC_IE_SAMP_FREQ_48:
2404 APPL_TRACE_DEBUG("\tsamp_freq:%d (48000)", sbc_cie.samp_freq);
2405 freq_multiple = 48*20;
2406 break;
2407 default:
2408 APPL_TRACE_DEBUG(" Unknown Frequency ");
2409 break;
2410 }
2411
2412 switch (sbc_cie.ch_mode)
2413 {
2414 case A2D_SBC_IE_CH_MD_MONO:
2415 APPL_TRACE_DEBUG("\tch_mode:%d (Mono)", sbc_cie.ch_mode);
2416 break;
2417 case A2D_SBC_IE_CH_MD_DUAL:
2418 APPL_TRACE_DEBUG("\tch_mode:%d (DUAL)", sbc_cie.ch_mode);
2419 break;
2420 case A2D_SBC_IE_CH_MD_STEREO:
2421 APPL_TRACE_DEBUG("\tch_mode:%d (STEREO)", sbc_cie.ch_mode);
2422 break;
2423 case A2D_SBC_IE_CH_MD_JOINT:
2424 APPL_TRACE_DEBUG("\tch_mode:%d (JOINT)", sbc_cie.ch_mode);
2425 break;
2426 default:
2427 APPL_TRACE_DEBUG(" Unknown Mode ");
2428 break;
2429 }
2430
2431 switch (sbc_cie.block_len)
2432 {
2433 case A2D_SBC_IE_BLOCKS_4:
2434 APPL_TRACE_DEBUG("\tblock_len:%d (4)", sbc_cie.block_len);
2435 num_blocks = 4;
2436 break;
2437 case A2D_SBC_IE_BLOCKS_8:
2438 APPL_TRACE_DEBUG("\tblock_len:%d (8)", sbc_cie.block_len);
2439 num_blocks = 8;
2440 break;
2441 case A2D_SBC_IE_BLOCKS_12:
2442 APPL_TRACE_DEBUG("\tblock_len:%d (12)", sbc_cie.block_len);
2443 num_blocks = 12;
2444 break;
2445 case A2D_SBC_IE_BLOCKS_16:
2446 APPL_TRACE_DEBUG("\tblock_len:%d (16)", sbc_cie.block_len);
2447 num_blocks = 16;
2448 break;
2449 default:
2450 APPL_TRACE_DEBUG(" Unknown BlockLen ");
2451 break;
2452 }
2453
2454 switch (sbc_cie.num_subbands)
2455 {
2456 case A2D_SBC_IE_SUBBAND_4:
2457 APPL_TRACE_DEBUG("\tnum_subbands:%d (4)", sbc_cie.num_subbands);
2458 num_subbands = 4;
2459 break;
2460 case A2D_SBC_IE_SUBBAND_8:
2461 APPL_TRACE_DEBUG("\tnum_subbands:%d (8)", sbc_cie.num_subbands);
2462 num_subbands = 8;
2463 break;
2464 default:
2465 APPL_TRACE_DEBUG(" Unknown SubBands ");
2466 break;
2467 }
2468
2469 switch (sbc_cie.alloc_mthd)
2470 {
2471 case A2D_SBC_IE_ALLOC_MD_S:
2472 APPL_TRACE_DEBUG("\talloc_mthd:%d (SNR)", sbc_cie.alloc_mthd);
2473 break;
2474 case A2D_SBC_IE_ALLOC_MD_L:
2475 APPL_TRACE_DEBUG("\talloc_mthd:%d (Loudness)", sbc_cie.alloc_mthd);
2476 break;
2477 default:
2478 APPL_TRACE_DEBUG(" Unknown Allocation Method");
2479 break;
2480 }
2481
2482 APPL_TRACE_DEBUG("\tBit pool Min:%d Max:%d", sbc_cie.min_bitpool, sbc_cie.max_bitpool);
2483
2484 btif_media_cb.frames_to_process = ((freq_multiple)/(num_blocks*num_subbands)) + 1;
2485 APPL_TRACE_DEBUG(" Frames to be processed in 20 ms %d",btif_media_cb.frames_to_process);
2486 }
2487 #endif
2488
2489 /*******************************************************************************
2490 **
2491 ** Function btif_media_task_feeding_state_reset
2492 **
2493 ** Description Reset the media feeding state
2494 **
2495 ** Returns void
2496 **
2497 *******************************************************************************/
btif_media_task_feeding_state_reset(void)2498 static void btif_media_task_feeding_state_reset(void)
2499 {
2500 /* By default, just clear the entire state */
2501 memset(&btif_media_cb.media_feeding_state, 0, sizeof(btif_media_cb.media_feeding_state));
2502
2503 if (btif_media_cb.TxTranscoding == BTIF_MEDIA_TRSCD_PCM_2_SBC)
2504 {
2505 btif_media_cb.media_feeding_state.pcm.bytes_per_tick =
2506 (btif_media_cb.media_feeding.cfg.pcm.sampling_freq *
2507 btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8 *
2508 btif_media_cb.media_feeding.cfg.pcm.num_channel *
2509 BTIF_MEDIA_TIME_TICK)/1000;
2510
2511 APPL_TRACE_WARNING("pcm bytes per tick %d",
2512 (int)btif_media_cb.media_feeding_state.pcm.bytes_per_tick);
2513 }
2514 }
2515
btif_media_task_alarm_cb(UNUSED_ATTR void * context)2516 static void btif_media_task_alarm_cb(UNUSED_ATTR void *context) {
2517 thread_post(worker_thread, btif_media_task_aa_handle_timer, NULL);
2518 }
2519
2520 /*******************************************************************************
2521 **
2522 ** Function btif_media_task_aa_start_tx
2523 **
2524 ** Description Start media task encoding
2525 **
2526 ** Returns void
2527 **
2528 *******************************************************************************/
btif_media_task_aa_start_tx(void)2529 static void btif_media_task_aa_start_tx(void)
2530 {
2531 APPL_TRACE_DEBUG("%s media_alarm %srunning, feeding mode %d", __func__,
2532 alarm_is_scheduled(btif_media_cb.media_alarm)? "" : "not ",
2533 btif_media_cb.feeding_mode);
2534
2535 last_frame_us = 0;
2536
2537 /* Reset the media feeding state */
2538 btif_media_task_feeding_state_reset();
2539
2540 APPL_TRACE_EVENT("starting timer %dms", BTIF_MEDIA_TIME_TICK);
2541
2542 alarm_free(btif_media_cb.media_alarm);
2543 btif_media_cb.media_alarm = alarm_new_periodic("btif.media_task");
2544 if (!btif_media_cb.media_alarm) {
2545 LOG_ERROR(LOG_TAG, "%s unable to allocate media alarm.", __func__);
2546 return;
2547 }
2548
2549 alarm_set(btif_media_cb.media_alarm, BTIF_MEDIA_TIME_TICK,
2550 btif_media_task_alarm_cb, NULL);
2551 }
2552
2553 /*******************************************************************************
2554 **
2555 ** Function btif_media_task_aa_stop_tx
2556 **
2557 ** Description Stop media task encoding
2558 **
2559 ** Returns void
2560 **
2561 *******************************************************************************/
btif_media_task_aa_stop_tx(void)2562 static void btif_media_task_aa_stop_tx(void)
2563 {
2564 APPL_TRACE_DEBUG("%s media_alarm is %srunning", __func__,
2565 alarm_is_scheduled(btif_media_cb.media_alarm)? "" : "not ");
2566
2567 const bool send_ack = alarm_is_scheduled(btif_media_cb.media_alarm);
2568
2569 /* Stop the timer first */
2570 alarm_free(btif_media_cb.media_alarm);
2571 btif_media_cb.media_alarm = NULL;
2572
2573 UIPC_Close(UIPC_CH_ID_AV_AUDIO);
2574
2575 /* Try to send acknowldegment once the media stream is
2576 stopped. This will make sure that the A2DP HAL layer is
2577 un-blocked on wait for acknowledgment for the sent command.
2578 This resolves a corner cases AVDTP SUSPEND collision
2579 when the DUT and the remote device issue SUSPEND simultaneously
2580 and due to the processing of the SUSPEND request from the remote,
2581 the media path is torn down. If the A2DP HAL happens to wait
2582 for ACK for the initiated SUSPEND, it would never receive it casuing
2583 a block/wait. Due to this acknowledgement, the A2DP HAL is guranteed
2584 to get the ACK for any pending command in such cases. */
2585
2586 if (send_ack)
2587 a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
2588
2589 /* audio engine stopped, reset tx suspended flag */
2590 btif_media_cb.tx_flush = 0;
2591 last_frame_us = 0;
2592
2593 /* Reset the media feeding state */
2594 btif_media_task_feeding_state_reset();
2595 }
2596
get_frame_length()2597 static UINT32 get_frame_length()
2598 {
2599 UINT32 frame_len = 0;
2600 APPL_TRACE_DEBUG("%s channel mode: %d, sub-band: %d, number of block: %d, \
2601 bitpool: %d, sampling frequency: %d, num channels: %d",
2602 __func__,
2603 btif_media_cb.encoder.s16ChannelMode,
2604 btif_media_cb.encoder.s16NumOfSubBands,
2605 btif_media_cb.encoder.s16NumOfBlocks,
2606 btif_media_cb.encoder.s16BitPool,
2607 btif_media_cb.encoder.s16SamplingFreq,
2608 btif_media_cb.encoder.s16NumOfChannels);
2609
2610 switch (btif_media_cb.encoder.s16ChannelMode) {
2611 case SBC_MONO:
2612 /* FALLTHROUGH */
2613 case SBC_DUAL:
2614 frame_len = SBC_FRAME_HEADER_SIZE_BYTES +
2615 ((UINT32)(SBC_SCALE_FACTOR_BITS * btif_media_cb.encoder.s16NumOfSubBands *
2616 btif_media_cb.encoder.s16NumOfChannels) / CHAR_BIT) +
2617 ((UINT32)(btif_media_cb.encoder.s16NumOfBlocks *
2618 btif_media_cb.encoder.s16NumOfChannels *
2619 btif_media_cb.encoder.s16BitPool) / CHAR_BIT);
2620 break;
2621 case SBC_STEREO:
2622 frame_len = SBC_FRAME_HEADER_SIZE_BYTES +
2623 ((UINT32)(SBC_SCALE_FACTOR_BITS * btif_media_cb.encoder.s16NumOfSubBands *
2624 btif_media_cb.encoder.s16NumOfChannels) / CHAR_BIT) +
2625 ((UINT32)(btif_media_cb.encoder.s16NumOfBlocks *
2626 btif_media_cb.encoder.s16BitPool) / CHAR_BIT);
2627 break;
2628 case SBC_JOINT_STEREO:
2629 frame_len = SBC_FRAME_HEADER_SIZE_BYTES +
2630 ((UINT32)(SBC_SCALE_FACTOR_BITS * btif_media_cb.encoder.s16NumOfSubBands *
2631 btif_media_cb.encoder.s16NumOfChannels) / CHAR_BIT) +
2632 ((UINT32)(btif_media_cb.encoder.s16NumOfSubBands +
2633 (btif_media_cb.encoder.s16NumOfBlocks *
2634 btif_media_cb.encoder.s16BitPool)) / CHAR_BIT);
2635 break;
2636 default:
2637 APPL_TRACE_DEBUG("%s Invalid channel number: %d",
2638 __func__, btif_media_cb.encoder.s16ChannelMode);
2639 break;
2640 }
2641 APPL_TRACE_DEBUG("%s calculated frame length: %d", __func__, frame_len);
2642 return frame_len;
2643 }
2644
calculate_max_frames_per_packet()2645 static UINT8 calculate_max_frames_per_packet()
2646 {
2647 UINT16 result = 0;
2648 UINT16 effective_mtu_size = btif_media_cb.TxAaMtuSize;
2649 UINT32 frame_len;
2650
2651 APPL_TRACE_DEBUG("%s original AVDTP MTU size: %d", __func__, btif_media_cb.TxAaMtuSize);
2652 if (btif_av_is_peer_edr() && (btif_av_peer_supports_3mbps() == FALSE)) {
2653 // This condition would be satisfied only if the remote device is
2654 // EDR and supports only 2 Mbps, but the effective AVDTP MTU size
2655 // exceeds the 2DH5 packet size.
2656 APPL_TRACE_DEBUG("%s The remote devce is EDR but does not support 3 Mbps", __func__);
2657
2658 if (effective_mtu_size > MAX_2MBPS_AVDTP_MTU) {
2659 APPL_TRACE_WARNING("%s Restricting AVDTP MTU size to %d",
2660 __func__, MAX_2MBPS_AVDTP_MTU);
2661 effective_mtu_size = MAX_2MBPS_AVDTP_MTU;
2662 btif_media_cb.TxAaMtuSize = effective_mtu_size;
2663 }
2664 }
2665
2666 if (!btif_media_cb.encoder.s16NumOfSubBands) {
2667 APPL_TRACE_ERROR("%s SubBands are set to 0, resetting to %d",
2668 __func__, SBC_MAX_NUM_OF_SUBBANDS);
2669 btif_media_cb.encoder.s16NumOfSubBands = SBC_MAX_NUM_OF_SUBBANDS;
2670 }
2671 if (!btif_media_cb.encoder.s16NumOfBlocks) {
2672 APPL_TRACE_ERROR("%s Blocks are set to 0, resetting to %d",
2673 __func__, SBC_MAX_NUM_OF_BLOCKS);
2674 btif_media_cb.encoder.s16NumOfBlocks = SBC_MAX_NUM_OF_BLOCKS;
2675 }
2676 if (!btif_media_cb.encoder.s16NumOfChannels) {
2677 APPL_TRACE_ERROR("%s Channels are set to 0, resetting to %d",
2678 __func__, SBC_MAX_NUM_OF_CHANNELS);
2679 btif_media_cb.encoder.s16NumOfChannels = SBC_MAX_NUM_OF_CHANNELS;
2680 }
2681
2682 frame_len = get_frame_length();
2683
2684 APPL_TRACE_DEBUG("%s Effective Tx MTU to be considered: %d",
2685 __func__, effective_mtu_size);
2686
2687 switch (btif_media_cb.encoder.s16SamplingFreq) {
2688 case SBC_sf44100:
2689 if (frame_len == 0) {
2690 APPL_TRACE_ERROR("%s Calculating frame length, \
2691 resetting it to default 119", __func__);
2692 frame_len = MAX_SBC_HQ_FRAME_SIZE_44_1;
2693 }
2694 result = (effective_mtu_size - A2DP_HDR_SIZE) / frame_len;
2695 APPL_TRACE_DEBUG("%s Max number of SBC frames: %d", __func__, result);
2696 break;
2697
2698 case SBC_sf48000:
2699 if (frame_len == 0) {
2700 APPL_TRACE_ERROR("%s Calculating frame length, \
2701 resetting it to default 115", __func__);
2702 frame_len = MAX_SBC_HQ_FRAME_SIZE_48;
2703 }
2704 result = (effective_mtu_size - A2DP_HDR_SIZE) / frame_len;
2705 APPL_TRACE_DEBUG("%s Max number of SBC frames: %d", __func__, result);
2706 break;
2707
2708 default:
2709 APPL_TRACE_ERROR("%s Max number of SBC frames: %d", __func__, result);
2710 break;
2711
2712 }
2713 return result;
2714 }
2715
2716 /*******************************************************************************
2717 **
2718 ** Function btif_get_num_aa_frame_iteration
2719 **
2720 ** Description returns number of frames to send and number of iterations
2721 ** to be used. num_of_ietrations and num_of_frames parameters
2722 ** are used as output param for returning the respective values
2723 **
2724 ** Returns void
2725 **
2726 *******************************************************************************/
btif_get_num_aa_frame_iteration(UINT8 * num_of_iterations,UINT8 * num_of_frames)2727 static void btif_get_num_aa_frame_iteration(UINT8 *num_of_iterations, UINT8 *num_of_frames)
2728 {
2729 UINT8 nof = 0;
2730 UINT8 noi = 1;
2731
2732 switch (btif_media_cb.TxTranscoding)
2733 {
2734 case BTIF_MEDIA_TRSCD_PCM_2_SBC:
2735 {
2736 UINT32 projected_nof = 0;
2737 UINT32 pcm_bytes_per_frame = btif_media_cb.encoder.s16NumOfSubBands *
2738 btif_media_cb.encoder.s16NumOfBlocks *
2739 btif_media_cb.media_feeding.cfg.pcm.num_channel *
2740 btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8;
2741 APPL_TRACE_DEBUG("%s pcm_bytes_per_frame %u", __func__, pcm_bytes_per_frame);
2742
2743 UINT32 us_this_tick = BTIF_MEDIA_TIME_TICK * 1000;
2744 UINT64 now_us = time_now_us();
2745 if (last_frame_us != 0)
2746 us_this_tick = (now_us - last_frame_us);
2747 last_frame_us = now_us;
2748
2749 btif_media_cb.media_feeding_state.pcm.counter +=
2750 btif_media_cb.media_feeding_state.pcm.bytes_per_tick *
2751 us_this_tick / (BTIF_MEDIA_TIME_TICK * 1000);
2752
2753 /* calculate nbr of frames pending for this media tick */
2754 projected_nof = btif_media_cb.media_feeding_state.pcm.counter / pcm_bytes_per_frame;
2755 if (projected_nof > btif_media_cb.stats.media_read_max_expected_frames)
2756 btif_media_cb.stats.media_read_max_expected_frames = projected_nof;
2757 btif_media_cb.stats.media_read_total_expected_frames += projected_nof;
2758 btif_media_cb.stats.media_read_expected_count++;
2759 if (projected_nof > MAX_PCM_FRAME_NUM_PER_TICK)
2760 {
2761 APPL_TRACE_WARNING("%s() - Limiting frames to be sent from %d to %d"
2762 , __FUNCTION__, projected_nof, MAX_PCM_FRAME_NUM_PER_TICK);
2763 size_t delta = projected_nof - MAX_PCM_FRAME_NUM_PER_TICK;
2764 btif_media_cb.stats.media_read_limited_count++;
2765 btif_media_cb.stats.media_read_total_limited_frames += delta;
2766 if (delta > btif_media_cb.stats.media_read_max_limited_frames)
2767 btif_media_cb.stats.media_read_max_limited_frames = delta;
2768 projected_nof = MAX_PCM_FRAME_NUM_PER_TICK;
2769 }
2770
2771 APPL_TRACE_DEBUG("%s frames for available PCM data %u", __func__, projected_nof);
2772
2773 if (btif_av_is_peer_edr())
2774 {
2775 if (!btif_media_cb.tx_sbc_frames)
2776 {
2777 APPL_TRACE_ERROR("%s tx_sbc_frames not updated, update from here", __func__);
2778 btif_media_cb.tx_sbc_frames = calculate_max_frames_per_packet();
2779 }
2780
2781 nof = btif_media_cb.tx_sbc_frames;
2782 if (!nof) {
2783 APPL_TRACE_ERROR("%s Number of frames not updated, set calculated values",
2784 __func__);
2785 nof = projected_nof;
2786 noi = 1;
2787 } else {
2788 if (nof < projected_nof)
2789 {
2790 noi = projected_nof / nof; // number of iterations would vary
2791 if (noi > MAX_PCM_ITER_NUM_PER_TICK)
2792 {
2793 APPL_TRACE_ERROR("%s ## Audio Congestion (iterations:%d > max (%d))",
2794 __func__, noi, MAX_PCM_ITER_NUM_PER_TICK);
2795 noi = MAX_PCM_ITER_NUM_PER_TICK;
2796 btif_media_cb.media_feeding_state.pcm.counter
2797 = noi * nof * pcm_bytes_per_frame;
2798 }
2799 projected_nof = nof;
2800 } else {
2801 noi = 1; // number of iterations is 1
2802 APPL_TRACE_DEBUG("%s reducing frames for available PCM data", __func__);
2803 nof = projected_nof;
2804 }
2805 }
2806 } else {
2807 // For BR cases nof will be same as the value retrieved at projected_nof
2808 APPL_TRACE_DEBUG("%s headset BR, number of frames %u", __func__, nof);
2809 if (projected_nof > MAX_PCM_FRAME_NUM_PER_TICK)
2810 {
2811 APPL_TRACE_ERROR("%s ## Audio Congestion (frames: %d > max (%d))",
2812 __func__, projected_nof, MAX_PCM_FRAME_NUM_PER_TICK);
2813 projected_nof = MAX_PCM_FRAME_NUM_PER_TICK;
2814 btif_media_cb.media_feeding_state.pcm.counter =
2815 noi * projected_nof * pcm_bytes_per_frame;
2816 }
2817 nof = projected_nof;
2818 }
2819 btif_media_cb.media_feeding_state.pcm.counter -= noi * nof * pcm_bytes_per_frame;
2820 APPL_TRACE_DEBUG("%s effective num of frames %u, iterations %u", __func__, nof, noi);
2821 }
2822 break;
2823
2824 default:
2825 APPL_TRACE_ERROR("%s Unsupported transcoding format 0x%x",
2826 __func__, btif_media_cb.TxTranscoding);
2827 nof = 0;
2828 noi = 0;
2829 break;
2830 }
2831 *num_of_frames = nof;
2832 *num_of_iterations = noi;
2833 }
2834
2835 /*******************************************************************************
2836 **
2837 ** Function btif_media_sink_enque_buf
2838 **
2839 ** Description This function is called by the av_co to fill A2DP Sink Queue
2840 **
2841 **
2842 ** Returns size of the queue
2843 *******************************************************************************/
btif_media_sink_enque_buf(BT_HDR * p_pkt)2844 UINT8 btif_media_sink_enque_buf(BT_HDR *p_pkt)
2845 {
2846 if (btif_media_cb.rx_flush == TRUE) /* Flush enabled, do not enque */
2847 return fixed_queue_length(btif_media_cb.RxSbcQ);
2848 if (fixed_queue_length(btif_media_cb.RxSbcQ) == MAX_OUTPUT_A2DP_FRAME_QUEUE_SZ)
2849 {
2850 UINT8 ret = fixed_queue_length(btif_media_cb.RxSbcQ);
2851 osi_free(fixed_queue_try_dequeue(btif_media_cb.RxSbcQ));
2852 return ret;
2853 }
2854
2855 BTIF_TRACE_VERBOSE("%s +", __func__);
2856 /* allocate and Queue this buffer */
2857 tBT_SBC_HDR *p_msg =
2858 (tBT_SBC_HDR *)osi_malloc(sizeof(tBT_SBC_HDR) + p_pkt->offset +
2859 p_pkt->len);
2860 memcpy((UINT8 *)(p_msg + 1), (UINT8 *)(p_pkt + 1) + p_pkt->offset,
2861 p_pkt->len);
2862 p_msg->num_frames_to_be_processed = (*((UINT8 *)(p_pkt + 1) + p_pkt->offset))& 0x0f;
2863 p_msg->len = p_pkt->len;
2864 p_msg->offset = 0;
2865 p_msg->layer_specific = p_pkt->layer_specific;
2866 BTIF_TRACE_VERBOSE("%s frames to process %d, len %d ",
2867 __func__, p_msg->num_frames_to_be_processed,p_msg->len);
2868 fixed_queue_enqueue(btif_media_cb.RxSbcQ, p_msg);
2869 if (fixed_queue_length(btif_media_cb.RxSbcQ) == MAX_A2DP_DELAYED_START_FRAME_COUNT) {
2870 BTIF_TRACE_DEBUG(" Initiate Decoding ");
2871 btif_media_task_aa_handle_start_decoding();
2872 }
2873
2874 return fixed_queue_length(btif_media_cb.RxSbcQ);
2875 }
2876
2877 /*******************************************************************************
2878 **
2879 ** Function btif_media_aa_readbuf
2880 **
2881 ** Description This function is called by the av_co to get the next buffer to send
2882 **
2883 **
2884 ** Returns void
2885 *******************************************************************************/
btif_media_aa_readbuf(void)2886 BT_HDR *btif_media_aa_readbuf(void)
2887 {
2888 uint64_t now_us = time_now_us();
2889 BT_HDR *p_buf = fixed_queue_try_dequeue(btif_media_cb.TxAaQ);
2890
2891 btif_media_cb.stats.tx_queue_total_readbuf_calls++;
2892 btif_media_cb.stats.tx_queue_last_readbuf_us = now_us;
2893 if (p_buf != NULL) {
2894 // Update the statistics
2895 update_scheduling_stats(&btif_media_cb.stats.tx_queue_dequeue_stats,
2896 now_us, BTIF_SINK_MEDIA_TIME_TICK_MS * 1000);
2897 }
2898
2899 return p_buf;
2900 }
2901
2902 /*******************************************************************************
2903 **
2904 ** Function btif_media_aa_read_feeding
2905 **
2906 ** Description
2907 **
2908 ** Returns void
2909 **
2910 *******************************************************************************/
2911
btif_media_aa_read_feeding(tUIPC_CH_ID channel_id)2912 BOOLEAN btif_media_aa_read_feeding(tUIPC_CH_ID channel_id)
2913 {
2914 UINT16 event;
2915 UINT16 blocm_x_subband = btif_media_cb.encoder.s16NumOfSubBands * \
2916 btif_media_cb.encoder.s16NumOfBlocks;
2917 UINT32 read_size;
2918 UINT16 sbc_sampling = 48000;
2919 UINT32 src_samples;
2920 UINT16 bytes_needed = blocm_x_subband * btif_media_cb.encoder.s16NumOfChannels * \
2921 btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8;
2922 static UINT16 up_sampled_buffer[SBC_MAX_NUM_FRAME * SBC_MAX_NUM_OF_BLOCKS
2923 * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS * 2];
2924 static UINT16 read_buffer[SBC_MAX_NUM_FRAME * SBC_MAX_NUM_OF_BLOCKS
2925 * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS];
2926 UINT32 src_size_used;
2927 UINT32 dst_size_used;
2928 BOOLEAN fract_needed;
2929 INT32 fract_max;
2930 INT32 fract_threshold;
2931 UINT32 nb_byte_read;
2932
2933 /* Get the SBC sampling rate */
2934 switch (btif_media_cb.encoder.s16SamplingFreq)
2935 {
2936 case SBC_sf48000:
2937 sbc_sampling = 48000;
2938 break;
2939 case SBC_sf44100:
2940 sbc_sampling = 44100;
2941 break;
2942 case SBC_sf32000:
2943 sbc_sampling = 32000;
2944 break;
2945 case SBC_sf16000:
2946 sbc_sampling = 16000;
2947 break;
2948 }
2949
2950 if (sbc_sampling == btif_media_cb.media_feeding.cfg.pcm.sampling_freq) {
2951 read_size = bytes_needed - btif_media_cb.media_feeding_state.pcm.aa_feed_residue;
2952 nb_byte_read = UIPC_Read(channel_id, &event,
2953 ((UINT8 *)btif_media_cb.encoder.as16PcmBuffer) +
2954 btif_media_cb.media_feeding_state.pcm.aa_feed_residue,
2955 read_size);
2956 if (nb_byte_read == read_size) {
2957 btif_media_cb.media_feeding_state.pcm.aa_feed_residue = 0;
2958 return TRUE;
2959 } else {
2960 APPL_TRACE_WARNING("### UNDERFLOW :: ONLY READ %d BYTES OUT OF %d ###",
2961 nb_byte_read, read_size);
2962 btif_media_cb.media_feeding_state.pcm.aa_feed_residue += nb_byte_read;
2963 btif_media_cb.stats.media_read_total_underflow_bytes += (read_size - nb_byte_read);
2964 btif_media_cb.stats.media_read_total_underflow_count++;
2965 btif_media_cb.stats.media_read_last_underflow_us = time_now_us();
2966 return FALSE;
2967 }
2968 }
2969
2970 /* Some Feeding PCM frequencies require to split the number of sample */
2971 /* to read. */
2972 /* E.g 128/6=21.3333 => read 22 and 21 and 21 => max = 2; threshold = 0*/
2973 fract_needed = FALSE; /* Default */
2974 switch (btif_media_cb.media_feeding.cfg.pcm.sampling_freq)
2975 {
2976 case 32000:
2977 case 8000:
2978 fract_needed = TRUE;
2979 fract_max = 2; /* 0, 1 and 2 */
2980 fract_threshold = 0; /* Add one for the first */
2981 break;
2982 case 16000:
2983 fract_needed = TRUE;
2984 fract_max = 2; /* 0, 1 and 2 */
2985 fract_threshold = 1; /* Add one for the first two frames*/
2986 break;
2987 }
2988
2989 /* Compute number of sample to read from source */
2990 src_samples = blocm_x_subband;
2991 src_samples *= btif_media_cb.media_feeding.cfg.pcm.sampling_freq;
2992 src_samples /= sbc_sampling;
2993
2994 /* The previous division may have a remainder not null */
2995 if (fract_needed)
2996 {
2997 if (btif_media_cb.media_feeding_state.pcm.aa_feed_counter <= fract_threshold)
2998 {
2999 src_samples++; /* for every read before threshold add one sample */
3000 }
3001
3002 /* do nothing if counter >= threshold */
3003 btif_media_cb.media_feeding_state.pcm.aa_feed_counter++; /* one more read */
3004 if (btif_media_cb.media_feeding_state.pcm.aa_feed_counter > fract_max)
3005 {
3006 btif_media_cb.media_feeding_state.pcm.aa_feed_counter = 0;
3007 }
3008 }
3009
3010 /* Compute number of bytes to read from source */
3011 read_size = src_samples;
3012 read_size *= btif_media_cb.media_feeding.cfg.pcm.num_channel;
3013 read_size *= (btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8);
3014
3015 /* Read Data from UIPC channel */
3016 nb_byte_read = UIPC_Read(channel_id, &event, (UINT8 *)read_buffer, read_size);
3017
3018 //tput_mon(TRUE, nb_byte_read, FALSE);
3019
3020 if (nb_byte_read < read_size)
3021 {
3022 APPL_TRACE_WARNING("### UNDERRUN :: ONLY READ %d BYTES OUT OF %d ###",
3023 nb_byte_read, read_size);
3024 btif_media_cb.stats.media_read_total_underrun_bytes += (read_size - nb_byte_read);
3025 btif_media_cb.stats.media_read_total_underrun_count++;
3026 btif_media_cb.stats.media_read_last_underrun_us = time_now_us();
3027
3028 if (nb_byte_read == 0)
3029 return FALSE;
3030
3031 if(btif_media_cb.feeding_mode == BTIF_AV_FEEDING_ASYNCHRONOUS)
3032 {
3033 /* Fill the unfilled part of the read buffer with silence (0) */
3034 memset(((UINT8 *)read_buffer) + nb_byte_read, 0, read_size - nb_byte_read);
3035 nb_byte_read = read_size;
3036 }
3037 }
3038
3039 /* Initialize PCM up-sampling engine */
3040 bta_av_sbc_init_up_sample(btif_media_cb.media_feeding.cfg.pcm.sampling_freq,
3041 sbc_sampling, btif_media_cb.media_feeding.cfg.pcm.bit_per_sample,
3042 btif_media_cb.media_feeding.cfg.pcm.num_channel);
3043
3044 /* re-sample read buffer */
3045 /* The output PCM buffer will be stereo, 16 bit per sample */
3046 dst_size_used = bta_av_sbc_up_sample((UINT8 *)read_buffer,
3047 (UINT8 *)up_sampled_buffer + btif_media_cb.media_feeding_state.pcm.aa_feed_residue,
3048 nb_byte_read,
3049 sizeof(up_sampled_buffer) - btif_media_cb.media_feeding_state.pcm.aa_feed_residue,
3050 &src_size_used);
3051
3052 /* update the residue */
3053 btif_media_cb.media_feeding_state.pcm.aa_feed_residue += dst_size_used;
3054
3055 /* only copy the pcm sample when we have up-sampled enough PCM */
3056 if(btif_media_cb.media_feeding_state.pcm.aa_feed_residue >= bytes_needed)
3057 {
3058 /* Copy the output pcm samples in SBC encoding buffer */
3059 memcpy((UINT8 *)btif_media_cb.encoder.as16PcmBuffer,
3060 (UINT8 *)up_sampled_buffer,
3061 bytes_needed);
3062 /* update the residue */
3063 btif_media_cb.media_feeding_state.pcm.aa_feed_residue -= bytes_needed;
3064
3065 if (btif_media_cb.media_feeding_state.pcm.aa_feed_residue != 0)
3066 {
3067 memcpy((UINT8 *)up_sampled_buffer,
3068 (UINT8 *)up_sampled_buffer + bytes_needed,
3069 btif_media_cb.media_feeding_state.pcm.aa_feed_residue);
3070 }
3071 return TRUE;
3072 }
3073
3074 return FALSE;
3075 }
3076
3077 /*******************************************************************************
3078 **
3079 ** Function btif_media_aa_prep_sbc_2_send
3080 **
3081 ** Description
3082 **
3083 ** Returns void
3084 **
3085 *******************************************************************************/
btif_media_aa_prep_sbc_2_send(UINT8 nb_frame,uint64_t timestamp_us)3086 static void btif_media_aa_prep_sbc_2_send(UINT8 nb_frame,
3087 uint64_t timestamp_us)
3088 {
3089 uint8_t remain_nb_frame = nb_frame;
3090 UINT16 blocm_x_subband = btif_media_cb.encoder.s16NumOfSubBands *
3091 btif_media_cb.encoder.s16NumOfBlocks;
3092
3093 while (nb_frame) {
3094 BT_HDR *p_buf = osi_malloc(BTIF_MEDIA_AA_BUF_SIZE);
3095
3096 /* Init buffer */
3097 p_buf->offset = BTIF_MEDIA_AA_SBC_OFFSET;
3098 p_buf->len = 0;
3099 p_buf->layer_specific = 0;
3100
3101 do
3102 {
3103 /* Write @ of allocated buffer in encoder.pu8Packet */
3104 btif_media_cb.encoder.pu8Packet = (UINT8 *) (p_buf + 1) + p_buf->offset + p_buf->len;
3105 /* Fill allocated buffer with 0 */
3106 memset(btif_media_cb.encoder.as16PcmBuffer, 0, blocm_x_subband
3107 * btif_media_cb.encoder.s16NumOfChannels);
3108
3109 /* Read PCM data and upsample them if needed */
3110 if (btif_media_aa_read_feeding(UIPC_CH_ID_AV_AUDIO))
3111 {
3112 SBC_Encoder(&(btif_media_cb.encoder));
3113
3114 /* Update SBC frame length */
3115 p_buf->len += btif_media_cb.encoder.u16PacketLength;
3116 nb_frame--;
3117 p_buf->layer_specific++;
3118 }
3119 else
3120 {
3121 APPL_TRACE_WARNING("btif_media_aa_prep_sbc_2_send underflow %d, %d",
3122 nb_frame, btif_media_cb.media_feeding_state.pcm.aa_feed_residue);
3123 btif_media_cb.media_feeding_state.pcm.counter += nb_frame *
3124 btif_media_cb.encoder.s16NumOfSubBands *
3125 btif_media_cb.encoder.s16NumOfBlocks *
3126 btif_media_cb.media_feeding.cfg.pcm.num_channel *
3127 btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8;
3128 /* no more pcm to read */
3129 nb_frame = 0;
3130
3131 /* break read loop if timer was stopped (media task stopped) */
3132 if (! alarm_is_scheduled(btif_media_cb.media_alarm))
3133 {
3134 osi_free(p_buf);
3135 return;
3136 }
3137 }
3138
3139 } while (((p_buf->len + btif_media_cb.encoder.u16PacketLength) < btif_media_cb.TxAaMtuSize)
3140 && (p_buf->layer_specific < 0x0F) && nb_frame);
3141
3142 if(p_buf->len)
3143 {
3144 /* timestamp of the media packet header represent the TS of the first SBC frame
3145 i.e the timestamp before including this frame */
3146 *((UINT32 *) (p_buf + 1)) = btif_media_cb.timestamp;
3147
3148 btif_media_cb.timestamp += p_buf->layer_specific * blocm_x_subband;
3149
3150 if (btif_media_cb.tx_flush)
3151 {
3152 APPL_TRACE_DEBUG("### tx suspended, discarded frame ###");
3153
3154 btif_media_cb.stats.tx_queue_total_flushed_messages +=
3155 fixed_queue_length(btif_media_cb.TxAaQ);
3156 btif_media_cb.stats.tx_queue_last_flushed_us =
3157 timestamp_us;
3158 btif_media_flush_q(btif_media_cb.TxAaQ);
3159
3160 osi_free(p_buf);
3161 return;
3162 }
3163
3164 /* Enqueue the encoded SBC frame in AA Tx Queue */
3165 uint8_t done_nb_frame = remain_nb_frame - nb_frame;
3166 remain_nb_frame = nb_frame;
3167 btif_media_cb.stats.tx_queue_total_frames += done_nb_frame;
3168 if (done_nb_frame > btif_media_cb.stats.tx_queue_max_frames_per_packet)
3169 btif_media_cb.stats.tx_queue_max_frames_per_packet = done_nb_frame;
3170 fixed_queue_enqueue(btif_media_cb.TxAaQ, p_buf);
3171 }
3172 else
3173 {
3174 osi_free(p_buf);
3175 }
3176 }
3177 }
3178
3179
3180 /*******************************************************************************
3181 **
3182 ** Function btif_media_aa_prep_2_send
3183 **
3184 ** Description
3185 **
3186 ** Returns void
3187 **
3188 *******************************************************************************/
3189
btif_media_aa_prep_2_send(UINT8 nb_frame,uint64_t timestamp_us)3190 static void btif_media_aa_prep_2_send(UINT8 nb_frame, uint64_t timestamp_us)
3191 {
3192 // Check for TX queue overflow
3193
3194 if (nb_frame > MAX_OUTPUT_A2DP_FRAME_QUEUE_SZ)
3195 nb_frame = MAX_OUTPUT_A2DP_FRAME_QUEUE_SZ;
3196
3197 if (fixed_queue_length(btif_media_cb.TxAaQ) > (MAX_OUTPUT_A2DP_FRAME_QUEUE_SZ - nb_frame))
3198 {
3199 APPL_TRACE_WARNING("%s() - TX queue buffer count %d/%d", __func__,
3200 fixed_queue_length(btif_media_cb.TxAaQ),
3201 MAX_OUTPUT_A2DP_FRAME_QUEUE_SZ - nb_frame);
3202 // Keep track of drop-outs
3203 btif_media_cb.stats.tx_queue_dropouts++;
3204 btif_media_cb.stats.tx_queue_last_dropouts_us = timestamp_us;
3205
3206 // Flush all queued buffers...
3207 size_t drop_n = fixed_queue_length(btif_media_cb.TxAaQ);
3208 if (drop_n > btif_media_cb.stats.tx_queue_max_dropped_messages) {
3209 btif_media_cb.stats.tx_queue_max_dropped_messages = drop_n;
3210 }
3211 while (fixed_queue_length(btif_media_cb.TxAaQ)) {
3212 btif_media_cb.stats.tx_queue_total_dropped_messages++;
3213 osi_free(fixed_queue_try_dequeue(btif_media_cb.TxAaQ));
3214 }
3215
3216 // Request RSSI for log purposes if we had to flush buffers
3217 bt_bdaddr_t peer_bda = btif_av_get_addr();
3218 BTM_ReadRSSI(peer_bda.address, btm_read_rssi_cb);
3219 }
3220
3221 // Transcode frame
3222
3223 switch (btif_media_cb.TxTranscoding)
3224 {
3225 case BTIF_MEDIA_TRSCD_PCM_2_SBC:
3226 btif_media_aa_prep_sbc_2_send(nb_frame, timestamp_us);
3227 break;
3228
3229 default:
3230 APPL_TRACE_ERROR("%s unsupported transcoding format 0x%x", __func__, btif_media_cb.TxTranscoding);
3231 break;
3232 }
3233 }
3234
3235 /*******************************************************************************
3236 **
3237 ** Function btif_media_send_aa_frame
3238 **
3239 ** Description
3240 **
3241 ** Returns void
3242 **
3243 *******************************************************************************/
btif_media_send_aa_frame(uint64_t timestamp_us)3244 static void btif_media_send_aa_frame(uint64_t timestamp_us)
3245 {
3246 UINT8 nb_frame_2_send = 0;
3247 UINT8 nb_iterations = 0;
3248
3249 btif_get_num_aa_frame_iteration(&nb_iterations, &nb_frame_2_send);
3250
3251 if (nb_frame_2_send != 0) {
3252 for (UINT8 counter = 0; counter < nb_iterations; counter++)
3253 {
3254 /* format and queue buffer to send */
3255 btif_media_aa_prep_2_send(nb_frame_2_send, timestamp_us);
3256 }
3257 }
3258
3259 LOG_VERBOSE(LOG_TAG, "%s Sent %d frames per iteration, %d iterations",
3260 __func__, nb_frame_2_send, nb_iterations);
3261 bta_av_ci_src_data_ready(BTA_AV_CHNL_AUDIO);
3262 }
3263
3264 #endif /* BTA_AV_INCLUDED == TRUE */
3265
3266 /*******************************************************************************
3267 **
3268 ** Function dump_codec_info
3269 **
3270 ** Description Decode and display codec_info (for debug)
3271 **
3272 ** Returns void
3273 **
3274 *******************************************************************************/
dump_codec_info(unsigned char * p_codec)3275 void dump_codec_info(unsigned char *p_codec)
3276 {
3277 tA2D_STATUS a2d_status;
3278 tA2D_SBC_CIE sbc_cie;
3279
3280 a2d_status = A2D_ParsSbcInfo(&sbc_cie, p_codec, FALSE);
3281 if (a2d_status != A2D_SUCCESS)
3282 {
3283 APPL_TRACE_ERROR("ERROR dump_codec_info A2D_ParsSbcInfo fail:%d", a2d_status);
3284 return;
3285 }
3286
3287 APPL_TRACE_DEBUG("dump_codec_info");
3288
3289 if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_16)
3290 { APPL_TRACE_DEBUG("\tsamp_freq:%d (16000)", sbc_cie.samp_freq);}
3291 else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_32)
3292 { APPL_TRACE_DEBUG("\tsamp_freq:%d (32000)", sbc_cie.samp_freq);}
3293 else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_44)
3294 { APPL_TRACE_DEBUG("\tsamp_freq:%d (44.100)", sbc_cie.samp_freq);}
3295 else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_48)
3296 { APPL_TRACE_DEBUG("\tsamp_freq:%d (48000)", sbc_cie.samp_freq);}
3297 else
3298 { APPL_TRACE_DEBUG("\tBAD samp_freq:%d", sbc_cie.samp_freq);}
3299
3300 if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_MONO)
3301 { APPL_TRACE_DEBUG("\tch_mode:%d (Mono)", sbc_cie.ch_mode);}
3302 else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_DUAL)
3303 { APPL_TRACE_DEBUG("\tch_mode:%d (Dual)", sbc_cie.ch_mode);}
3304 else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_STEREO)
3305 { APPL_TRACE_DEBUG("\tch_mode:%d (Stereo)", sbc_cie.ch_mode);}
3306 else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_JOINT)
3307 { APPL_TRACE_DEBUG("\tch_mode:%d (Joint)", sbc_cie.ch_mode);}
3308 else
3309 { APPL_TRACE_DEBUG("\tBAD ch_mode:%d", sbc_cie.ch_mode);}
3310
3311 if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_4)
3312 { APPL_TRACE_DEBUG("\tblock_len:%d (4)", sbc_cie.block_len);}
3313 else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_8)
3314 { APPL_TRACE_DEBUG("\tblock_len:%d (8)", sbc_cie.block_len);}
3315 else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_12)
3316 { APPL_TRACE_DEBUG("\tblock_len:%d (12)", sbc_cie.block_len);}
3317 else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_16)
3318 { APPL_TRACE_DEBUG("\tblock_len:%d (16)", sbc_cie.block_len);}
3319 else
3320 { APPL_TRACE_DEBUG("\tBAD block_len:%d", sbc_cie.block_len);}
3321
3322 if (sbc_cie.num_subbands == A2D_SBC_IE_SUBBAND_4)
3323 { APPL_TRACE_DEBUG("\tnum_subbands:%d (4)", sbc_cie.num_subbands);}
3324 else if (sbc_cie.num_subbands == A2D_SBC_IE_SUBBAND_8)
3325 { APPL_TRACE_DEBUG("\tnum_subbands:%d (8)", sbc_cie.num_subbands);}
3326 else
3327 { APPL_TRACE_DEBUG("\tBAD num_subbands:%d", sbc_cie.num_subbands);}
3328
3329 if (sbc_cie.alloc_mthd == A2D_SBC_IE_ALLOC_MD_S)
3330 { APPL_TRACE_DEBUG("\talloc_mthd:%d (SNR)", sbc_cie.alloc_mthd);}
3331 else if (sbc_cie.alloc_mthd == A2D_SBC_IE_ALLOC_MD_L)
3332 { APPL_TRACE_DEBUG("\talloc_mthd:%d (Loundess)", sbc_cie.alloc_mthd);}
3333 else
3334 { APPL_TRACE_DEBUG("\tBAD alloc_mthd:%d", sbc_cie.alloc_mthd);}
3335
3336 APPL_TRACE_DEBUG("\tBit pool Min:%d Max:%d", sbc_cie.min_bitpool, sbc_cie.max_bitpool);
3337
3338 }
3339
btif_debug_a2dp_dump(int fd)3340 void btif_debug_a2dp_dump(int fd)
3341 {
3342 btif_a2dp_source_accumulate_stats(&btif_media_cb.stats,
3343 &btif_media_cb.accumulated_stats);
3344 uint64_t now_us = time_now_us();
3345 btif_media_stats_t *stats = &btif_media_cb.accumulated_stats;
3346 scheduling_stats_t *enqueue_stats = &stats->tx_queue_enqueue_stats;
3347 scheduling_stats_t *dequeue_stats = &stats->tx_queue_dequeue_stats;
3348 size_t ave_size;
3349 uint64_t ave_time_us;
3350
3351 dprintf(fd, "\nA2DP State:\n");
3352 dprintf(fd, " TxQueue:\n");
3353
3354 dprintf(fd, " Counts (enqueue/dequeue/readbuf) : %zu / %zu / %zu\n",
3355 enqueue_stats->total_updates,
3356 dequeue_stats->total_updates,
3357 stats->tx_queue_total_readbuf_calls);
3358
3359 dprintf(fd, " Last update time ago in ms (enqueue/dequeue/readbuf) : %llu / %llu / %llu\n",
3360 (enqueue_stats->last_update_us > 0) ?
3361 (unsigned long long)(now_us - enqueue_stats->last_update_us) / 1000 : 0,
3362 (dequeue_stats->last_update_us > 0) ?
3363 (unsigned long long)(now_us - dequeue_stats->last_update_us) / 1000 : 0,
3364 (stats->tx_queue_last_readbuf_us > 0)?
3365 (unsigned long long)(now_us - stats->tx_queue_last_readbuf_us) / 1000 : 0);
3366
3367 ave_size = 0;
3368 if (stats->media_read_expected_count != 0)
3369 ave_size = stats->media_read_total_expected_frames / stats->media_read_expected_count;
3370 dprintf(fd, " Frames expected (total/max/ave) : %zu / %zu / %zu\n",
3371 stats->media_read_total_expected_frames,
3372 stats->media_read_max_expected_frames,
3373 ave_size);
3374
3375 ave_size = 0;
3376 if (stats->media_read_limited_count != 0)
3377 ave_size = stats->media_read_total_limited_frames / stats->media_read_limited_count;
3378 dprintf(fd, " Frames limited (total/max/ave) : %zu / %zu / %zu\n",
3379 stats->media_read_total_limited_frames,
3380 stats->media_read_max_limited_frames,
3381 ave_size);
3382
3383 dprintf(fd, " Counts (expected/limited) : %zu / %zu\n",
3384 stats->media_read_expected_count,
3385 stats->media_read_limited_count);
3386
3387 ave_size = 0;
3388 if (enqueue_stats->total_updates != 0)
3389 ave_size = stats->tx_queue_total_frames / enqueue_stats->total_updates;
3390 dprintf(fd, " Frames per packet (total/max/ave) : %zu / %zu / %zu\n",
3391 stats->tx_queue_total_frames,
3392 stats->tx_queue_max_frames_per_packet,
3393 ave_size);
3394
3395 dprintf(fd, " Counts (flushed/dropped/dropouts) : %zu / %zu / %zu\n",
3396 stats->tx_queue_total_flushed_messages,
3397 stats->tx_queue_total_dropped_messages,
3398 stats->tx_queue_dropouts);
3399
3400 dprintf(fd, " Last update time ago in ms (flushed/dropped) : %llu / %llu\n",
3401 (stats->tx_queue_last_flushed_us > 0) ?
3402 (unsigned long long)(now_us - stats->tx_queue_last_flushed_us) / 1000 : 0,
3403 (stats->tx_queue_last_dropouts_us > 0)?
3404 (unsigned long long)(now_us - stats->tx_queue_last_dropouts_us)/ 1000 : 0);
3405
3406 dprintf(fd, " Counts (underflow/underrun) : %zu / %zu\n",
3407 stats->media_read_total_underflow_count,
3408 stats->media_read_total_underrun_count);
3409
3410 dprintf(fd, " Bytes (underflow/underrun) : %zu / %zu\n",
3411 stats->media_read_total_underflow_bytes,
3412 stats->media_read_total_underrun_bytes);
3413
3414 dprintf(fd, " Last update time ago in ms (underflow/underrun) : %llu / %llu\n",
3415 (stats->media_read_last_underflow_us > 0) ?
3416 (unsigned long long)(now_us - stats->media_read_last_underflow_us) / 1000 : 0,
3417 (stats->media_read_last_underrun_us > 0)?
3418 (unsigned long long)(now_us - stats->media_read_last_underrun_us) / 1000 : 0);
3419
3420 //
3421 // TxQueue enqueue stats
3422 //
3423 dprintf(fd, " Enqueue deviation counts (overdue/premature) : %zu / %zu\n",
3424 enqueue_stats->overdue_scheduling_count,
3425 enqueue_stats->premature_scheduling_count);
3426
3427 ave_time_us = 0;
3428 if (enqueue_stats->overdue_scheduling_count != 0) {
3429 ave_time_us = enqueue_stats->total_overdue_scheduling_delta_us /
3430 enqueue_stats->overdue_scheduling_count;
3431 }
3432 dprintf(fd, " Enqueue overdue scheduling time in ms (total/max/ave) : %llu / %llu / %llu\n",
3433 (unsigned long long)enqueue_stats->total_overdue_scheduling_delta_us / 1000,
3434 (unsigned long long)enqueue_stats->max_overdue_scheduling_delta_us / 1000,
3435 (unsigned long long)ave_time_us / 1000);
3436
3437 ave_time_us = 0;
3438 if (enqueue_stats->premature_scheduling_count != 0) {
3439 ave_time_us = enqueue_stats->total_premature_scheduling_delta_us /
3440 enqueue_stats->premature_scheduling_count;
3441 }
3442 dprintf(fd, " Enqueue premature scheduling time in ms (total/max/ave) : %llu / %llu / %llu\n",
3443 (unsigned long long)enqueue_stats->total_premature_scheduling_delta_us / 1000,
3444 (unsigned long long)enqueue_stats->max_premature_scheduling_delta_us / 1000,
3445 (unsigned long long)ave_time_us / 1000);
3446
3447
3448 //
3449 // TxQueue dequeue stats
3450 //
3451 dprintf(fd, " Dequeue deviation counts (overdue/premature) : %zu / %zu\n",
3452 dequeue_stats->overdue_scheduling_count,
3453 dequeue_stats->premature_scheduling_count);
3454
3455 ave_time_us = 0;
3456 if (dequeue_stats->overdue_scheduling_count != 0) {
3457 ave_time_us = dequeue_stats->total_overdue_scheduling_delta_us /
3458 dequeue_stats->overdue_scheduling_count;
3459 }
3460 dprintf(fd, " Dequeue overdue scheduling time in ms (total/max/ave) : %llu / %llu / %llu\n",
3461 (unsigned long long)dequeue_stats->total_overdue_scheduling_delta_us / 1000,
3462 (unsigned long long)dequeue_stats->max_overdue_scheduling_delta_us / 1000,
3463 (unsigned long long)ave_time_us / 1000);
3464
3465 ave_time_us = 0;
3466 if (dequeue_stats->premature_scheduling_count != 0) {
3467 ave_time_us = dequeue_stats->total_premature_scheduling_delta_us /
3468 dequeue_stats->premature_scheduling_count;
3469 }
3470 dprintf(fd, " Dequeue premature scheduling time in ms (total/max/ave) : %llu / %llu / %llu\n",
3471 (unsigned long long)dequeue_stats->total_premature_scheduling_delta_us / 1000,
3472 (unsigned long long)dequeue_stats->max_premature_scheduling_delta_us / 1000,
3473 (unsigned long long)ave_time_us / 1000);
3474
3475 }
3476
btif_update_a2dp_metrics(void)3477 void btif_update_a2dp_metrics(void)
3478 {
3479 btif_media_stats_t* stats = &btif_media_cb.stats;
3480 scheduling_stats_t* enqueue_stats = &stats->tx_queue_enqueue_stats;
3481 A2dpSessionMetrics_t metrics;
3482 metrics.media_timer_min_ms = -1;
3483 metrics.media_timer_max_ms = -1;
3484 metrics.media_timer_avg_ms = -1;
3485 metrics.total_scheduling_count = -1;
3486 metrics.buffer_overruns_max_count = -1;
3487 metrics.buffer_overruns_total = -1;
3488 metrics.buffer_underruns_average = -1.0;
3489 metrics.buffer_underruns_count = -1;
3490 metrics.audio_duration_ms = -1;
3491 // session_start_us is 0 when btif_media_task_start_aa_req() is not called
3492 // mark the metric duration as invalid (-1) in this case
3493 if (stats->session_start_us != 0) {
3494 int64_t session_end_us = stats->session_end_us == 0
3495 ? time_now_us()
3496 : stats->session_end_us;
3497 metrics.audio_duration_ms = (session_end_us - stats->session_start_us) / 1000;
3498 }
3499 if (enqueue_stats->total_updates > 1) {
3500 metrics.media_timer_min_ms = BTIF_SINK_MEDIA_TIME_TICK_MS -
3501 (enqueue_stats->max_premature_scheduling_delta_us / 1000);
3502 metrics.media_timer_max_ms = BTIF_SINK_MEDIA_TIME_TICK_MS +
3503 (enqueue_stats->max_overdue_scheduling_delta_us / 1000);
3504 metrics.total_scheduling_count
3505 = enqueue_stats->overdue_scheduling_count +
3506 enqueue_stats->premature_scheduling_count +
3507 enqueue_stats->exact_scheduling_count;
3508 if (metrics.total_scheduling_count > 0) {
3509 metrics.media_timer_avg_ms = enqueue_stats->total_scheduling_time_us /
3510 (1000 * metrics.total_scheduling_count);
3511 }
3512 metrics.buffer_overruns_max_count = stats->tx_queue_max_dropped_messages;
3513 metrics.buffer_overruns_total = stats->tx_queue_total_dropped_messages;
3514 metrics.buffer_underruns_count =
3515 stats->media_read_total_underflow_count +
3516 stats->media_read_total_underrun_count;
3517 metrics.buffer_underruns_average = 0;
3518 if (metrics.buffer_underruns_count > 0) {
3519 metrics.buffer_underruns_average =
3520 (stats->media_read_total_underflow_bytes +
3521 stats->media_read_total_underrun_bytes) /
3522 metrics.buffer_underruns_count;
3523 }
3524 }
3525 metrics_log_a2dp_session(&metrics);
3526 }
3527