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