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