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