btif/src/btif_media_task.c

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