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