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 2745