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