/****************************************************************************** * * Copyright (C) 2009-2012 Broadcom Corporation * * This program is the proprietary software of Broadcom Corporation and/or its * licensors, and may only be used, duplicated, modified or distributed * pursuant to the terms and conditions of a separate, written license * agreement executed between you and Broadcom (an "Authorized License"). * Except as set forth in an Authorized License, Broadcom grants no license * (express or implied), right to use, or waiver of any kind with respect to * the Software, and Broadcom expressly reserves all rights in and to the * Software and all intellectual property rights therein. * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE * ALL USE OF THE SOFTWARE. * * Except as expressly set forth in the Authorized License, * * 1. This program, including its structure, sequence and organization, * constitutes the valuable trade secrets of Broadcom, and you shall * use all reasonable efforts to protect the confidentiality thereof, * and to use this information only in connection with your use of * Broadcom integrated circuit products. * * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. * * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM * OR ITS LICENSORS BE LIABLE FOR * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. * *****************************************************************************/ /****************************************************************************** ** ** Name: btif_media_task.c ** ** Description: This is the multimedia module for the BTIF system. It ** contains task implementations AV, HS and HF profiles ** audio & video processing ** ******************************************************************************/ #include #include #include #include #include #include #include #include #include #include "bt_target.h" #include "gki.h" #include "bta_api.h" #include "btu.h" #include "bta_sys.h" #include "bta_sys_int.h" #include "bta_av_api.h" #include "a2d_api.h" #include "a2d_sbc.h" #include "a2d_int.h" #include "bta_av_sbc.h" #include "bta_av_ci.h" #include "l2c_api.h" #include "btif_av_co.h" #include "btif_media.h" #if (BTA_AV_INCLUDED == TRUE) #include "sbc_encoder.h" #endif #define LOG_TAG "BTIF-MEDIA" #include #include "audio_a2dp_hw.h" #include "btif_av.h" #include "btif_sm.h" #include "btif_util.h" /***************************************************************************** ** Constants *****************************************************************************/ //#define DEBUG_MEDIA_AV_FLOW TRUE /* BTIF media task gki event definition */ #define BTIF_MEDIA_TASK_CMD TASK_MBOX_0_EVT_MASK #define BTIF_MEDIA_TASK_DATA TASK_MBOX_1_EVT_MASK #define BTIF_MEDIA_TASK_KILL TASK_MBOX_3_EVT_MASK #define BTIF_MEDIA_AA_TASK_TIMER_ID TIMER_0 #define BTIF_MEDIA_AV_TASK_TIMER_ID TIMER_1 #define BTIF_MEDIA_AA_TASK_TIMER TIMER_0_EVT_MASK #define BTIF_MEDIA_AV_TASK_TIMER TIMER_1_EVT_MASK #define BTIF_MEDIA_TASK_CMD_MBOX TASK_MBOX_0 /* cmd mailbox */ #define BTIF_MEDIA_TASK_DATA_MBOX TASK_MBOX_1 /* data mailbox */ /* BTIF media cmd event definition : BTIF_MEDIA_TASK_CMD */ enum { BTIF_MEDIA_START_AA_TX = 1, BTIF_MEDIA_STOP_AA_TX, BTIF_MEDIA_AA_RX_RDY, BTIF_MEDIA_UIPC_RX_RDY, BTIF_MEDIA_SBC_ENC_INIT, BTIF_MEDIA_SBC_ENC_UPDATE, BTIF_MEDIA_SBC_DEC_INIT, BTIF_MEDIA_VIDEO_DEC_INIT, BTIF_MEDIA_FLUSH_AA_TX, BTIF_MEDIA_FLUSH_AA_RX, BTIF_MEDIA_AUDIO_FEEDING_INIT, BTIF_MEDIA_AUDIO_RECEIVING_INIT }; /* Macro to multiply the media task tick */ #ifndef BTIF_MEDIA_NUM_TICK #define BTIF_MEDIA_NUM_TICK 1 #endif /* Media task tick in milliseconds */ #define BTIF_MEDIA_TIME_TICK (40 * BTIF_MEDIA_NUM_TICK) /* Number of frames per media task tick */ #define BTIF_MEDIA_FR_PER_TICKS_48 (15 * BTIF_MEDIA_NUM_TICK) #define BTIF_MEDIA_FR_PER_TICKS_44_1_H (14 * BTIF_MEDIA_NUM_TICK) #define BTIF_MEDIA_FR_PER_TICKS_44_1_L (13 * BTIF_MEDIA_NUM_TICK) #define BTIF_MEDIA_FR_PER_TICKS_32 (10 * BTIF_MEDIA_NUM_TICK) #define BTIF_MEDIA_FR_PER_TICKS_16 ( 5 * BTIF_MEDIA_NUM_TICK) /* buffer pool */ #define BTIF_MEDIA_AA_POOL_ID GKI_POOL_ID_3 #define BTIF_MEDIA_AA_BUF_SIZE GKI_BUF3_SIZE /* offset */ #if (BTA_AV_CO_CP_SCMS_T == TRUE) #define BTIF_MEDIA_AA_SBC_OFFSET (AVDT_MEDIA_OFFSET + BTA_AV_SBC_HDR_SIZE + 1) #else #define BTIF_MEDIA_AA_SBC_OFFSET (AVDT_MEDIA_OFFSET + BTA_AV_SBC_HDR_SIZE) #endif /* Define the bitrate step when trying to match bitpool value */ #ifndef BTIF_MEDIA_BITRATE_STEP #define BTIF_MEDIA_BITRATE_STEP 5 #endif #define DEFAULT_SBC_BITRATE 220 #ifndef A2DP_MEDIA_TASK_STACK_SIZE #define A2DP_MEDIA_TASK_STACK_SIZE 0x2000 /* In bytes */ #endif #define A2DP_MEDIA_TASK_TASK_STR ((INT8 *) "A2DP-MEDIA") static UINT32 a2dp_media_task_stack[(A2DP_MEDIA_TASK_STACK_SIZE + 3) / 4]; #define BT_MEDIA_TASK A2DP_MEDIA_TASK #define USEC_PER_SEC 1000000L #define TPUT_STATS_INTERVAL_US (1000*1000) /* * CONGESTION COMPENSATION CTRL :: * * Thus setting controls how many buffers we will hold in media task * during temp link congestion. Together with the stack buffer queues * it controls much temporary a2dp link congestion we can * compensate for. It however also depends on the default run level of sinks * jitterbuffers. Depending on type of sink this would vary. * Ideally the (SRC) max tx buffer capacity should equal the sinks * jitterbuffer runlevel including any intermediate buffers on the way * towards the sinks codec. */ /* fixme -- define this in pcm time instead of buffer count */ /* fixme -- tune optimal value. For now set a large buffer capacity */ #define MAX_OUTPUT_BUFFER_QUEUE_SZ 12 /* trigger rate adjustment if deviation is more than threshold */ #define BTIF_RA_OFFSET_TRIGGER_US 3000 //#define BTIF_MEDIA_VERBOSE_ENABLED #ifdef BTIF_MEDIA_VERBOSE_ENABLED #define VERBOSE(fmt, ...) \ LogMsg( TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | \ TRACE_TYPE_ERROR, fmt, ## __VA_ARGS__) #else #define VERBOSE(fmt, ...) #endif /***************************************************************************** ** Data types *****************************************************************************/ typedef struct { UINT32 aa_frame_counter; INT32 aa_feed_counter; INT32 aa_feed_residue; } tBTIF_AV_MEDIA_FEEDINGS_PCM_STATE; typedef union { tBTIF_AV_MEDIA_FEEDINGS_PCM_STATE pcm; } tBTIF_AV_MEDIA_FEEDINGS_STATE; /* pcm rate adjustment */ typedef struct { struct timespec time_start; /* offset used to calculate time elapsed */ unsigned long long tx_pcmtime_us; /* track pcm time transmitted since stream start */ /* add latency tracker */ } tBTIF_MEDIA_RA; typedef struct { #if (BTA_AV_INCLUDED == TRUE) BUFFER_Q TxAaQ; BOOLEAN is_tx_timer; UINT16 TxAaMtuSize; UINT32 timestamp; UINT8 TxTranscoding; tBTIF_AV_FEEDING_MODE feeding_mode; tBTIF_AV_MEDIA_FEEDINGS media_feeding; tBTIF_AV_MEDIA_FEEDINGS_STATE media_feeding_state; SBC_ENC_PARAMS encoder; UINT8 busy_level; void* av_sm_hdl; UINT8 a2dp_cmd_pending; /* we can have max one command pending */ BOOLEAN tx_flush; /* discards any outgoing data when true */ tBTIF_MEDIA_RA ra; /* tx rate adjustment logic */ #if ((defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE)) || \ (defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE))) UINT8 tx_counter; #endif #endif } tBTIF_MEDIA_CB; typedef struct { int rx; int rx_tot; int tx; int tx_tot; int ts_prev_us; } t_stat; /***************************************************************************** ** Local data *****************************************************************************/ static tBTIF_MEDIA_CB btif_media_cb; static int media_task_running = 0; /***************************************************************************** ** Local functions *****************************************************************************/ static void btif_a2dp_data_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event); static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event); static void btif_a2dp_encoder_update(void); /***************************************************************************** ** Externs *****************************************************************************/ static void btif_media_task_handle_cmd(BT_HDR *p_msg); static void btif_media_task_handle_media(BT_HDR *p_msg); #if (BTA_AV_INCLUDED == TRUE) static void btif_media_send_aa_frame(void); static void btif_media_task_feeding_state_reset(void); static void btif_media_task_aa_start_tx(void); static void btif_media_task_aa_stop_tx(void); static void btif_media_task_enc_init(BT_HDR *p_msg); static void btif_media_task_enc_update(BT_HDR *p_msg); static void btif_media_task_audio_feeding_init(BT_HDR *p_msg); static void btif_media_task_aa_tx_flush(BT_HDR *p_msg); static void btif_media_aa_prep_2_send(UINT8 nb_frame); #endif /***************************************************************************** ** Misc helper functions *****************************************************************************/ static void tput_mon(int is_rx, int len, int reset) { /* only monitor one connection at a time for now */ static t_stat cur_stat; struct timespec now; unsigned int prev_us; unsigned int now_us; if (reset == TRUE) { memset(&cur_stat, 0, sizeof(t_stat)); return; } if (is_rx) { cur_stat.rx+=len; cur_stat.rx_tot+=len; } else { cur_stat.tx+=len; cur_stat.tx_tot+=len; } clock_gettime(CLOCK_MONOTONIC, &now); now_us = now.tv_sec*USEC_PER_SEC + now.tv_nsec/1000; //APPL_TRACE_DEBUG1("%d us", now_us - cur_stat.ts_prev_us); if ((now_us - cur_stat.ts_prev_us) < TPUT_STATS_INTERVAL_US) return; APPL_TRACE_WARNING4("tput rx:%d, tx:%d (kB/s) (tot : rx %d, tx %d bytes)", (cur_stat.rx)/((now_us - cur_stat.ts_prev_us)/1000), (cur_stat.tx)/((now_us - cur_stat.ts_prev_us)/1000), cur_stat.rx_tot, cur_stat.tx_tot); /* stats dumped. now reset stats for next interval */ cur_stat.rx = 0; cur_stat.tx = 0; cur_stat.ts_prev_us = now_us; } static void log_tstamps_us(char *comment) { #define USEC_PER_SEC 1000000L static struct timespec prev = {0, 0}; struct timespec now, diff; unsigned int diff_us = 0; unsigned int now_us = 0; clock_gettime(CLOCK_MONOTONIC, &now); now_us = now.tv_sec*USEC_PER_SEC + now.tv_nsec/1000; diff_us = (now.tv_sec - prev.tv_sec) * USEC_PER_SEC + (now.tv_nsec - prev.tv_nsec)/1000; APPL_TRACE_DEBUG4("[%s] ts %08d, diff : %08d, queue sz %d", comment, now_us, diff_us, btif_media_cb.TxAaQ.count); prev = now; } const char* dump_media_event(UINT16 event) { switch(event) { CASE_RETURN_STR(BTIF_MEDIA_START_AA_TX) CASE_RETURN_STR(BTIF_MEDIA_STOP_AA_TX) CASE_RETURN_STR(BTIF_MEDIA_AA_RX_RDY) CASE_RETURN_STR(BTIF_MEDIA_UIPC_RX_RDY) CASE_RETURN_STR(BTIF_MEDIA_SBC_ENC_INIT) CASE_RETURN_STR(BTIF_MEDIA_SBC_ENC_UPDATE) CASE_RETURN_STR(BTIF_MEDIA_SBC_DEC_INIT) CASE_RETURN_STR(BTIF_MEDIA_VIDEO_DEC_INIT) CASE_RETURN_STR(BTIF_MEDIA_FLUSH_AA_TX) CASE_RETURN_STR(BTIF_MEDIA_FLUSH_AA_RX) CASE_RETURN_STR(BTIF_MEDIA_AUDIO_FEEDING_INIT) CASE_RETURN_STR(BTIF_MEDIA_AUDIO_RECEIVING_INIT) default: return "UNKNOWN MEDIA EVENT"; } } /***************************************************************************** ** A2DP CTRL PATH *****************************************************************************/ static const char* dump_a2dp_ctrl_event(UINT8 event) { switch(event) { CASE_RETURN_STR(A2DP_CTRL_CMD_NONE) CASE_RETURN_STR(A2DP_CTRL_CMD_CHECK_READY) CASE_RETURN_STR(A2DP_CTRL_CMD_START) CASE_RETURN_STR(A2DP_CTRL_CMD_STOP) CASE_RETURN_STR(A2DP_CTRL_CMD_SUSPEND) default: return "UNKNOWN MSG ID"; } } static void btif_audiopath_detached(void) { APPL_TRACE_EVENT0("## AUDIO PATH DETACHED ##"); /* send stop request only if we are actively streaming and haven't received a stop request. Potentially audioflinger detached abnormally */ if (btif_media_cb.is_tx_timer) { /* post stop event and wait for audio path to stop */ btif_dispatch_sm_event(BTIF_AV_STOP_STREAM_REQ_EVT, NULL, 0); } } static void a2dp_cmd_acknowledge(int status) { UINT8 ack = status; APPL_TRACE_EVENT2("## a2dp ack : %s, status %d ##", dump_a2dp_ctrl_event(btif_media_cb.a2dp_cmd_pending), status); /* sanity check */ if (btif_media_cb.a2dp_cmd_pending == A2DP_CTRL_CMD_NONE) { APPL_TRACE_ERROR0("warning : no command pending, ignore ack"); return; } /* clear pending */ btif_media_cb.a2dp_cmd_pending = A2DP_CTRL_CMD_NONE; /* acknowledge start request */ UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &ack, 1); } static void btif_recv_ctrl_data(void) { UINT8 cmd = 0; int n; n = UIPC_Read(UIPC_CH_ID_AV_CTRL, NULL, &cmd, 1); /* detach on ctrl channel means audioflinger process was terminated */ if (n == 0) { APPL_TRACE_EVENT0("CTRL CH DETACHED"); UIPC_Close(UIPC_CH_ID_AV_CTRL); /* we can operate only on datachannel, if af client wants to do send additional commands the ctrl channel would be reestablished */ //btif_audiopath_detached(); return; } APPL_TRACE_EVENT1("a2dp-ctrl-cmd : %s", dump_a2dp_ctrl_event(cmd)); btif_media_cb.a2dp_cmd_pending = cmd; switch(cmd) { case A2DP_CTRL_CMD_CHECK_READY: /* check whether avdtp is ready to start */ if (btif_av_stream_ready() == TRUE) { a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS); } else { a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE); } break; case A2DP_CTRL_CMD_START: if (btif_av_stream_ready() == TRUE) { /* setup audio data channel listener */ UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb); /* post start event and wait for audio path to open */ btif_dispatch_sm_event(BTIF_AV_START_STREAM_REQ_EVT, NULL, 0); a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS); } else if (btif_av_stream_started()) { /* setup audio data channel listener */ UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb); a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS); } else { a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE); break; } break; case A2DP_CTRL_CMD_STOP: if (btif_media_cb.is_tx_timer == FALSE) { /* we are already stopped, just ack back */ a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS); break; } btif_dispatch_sm_event(BTIF_AV_STOP_STREAM_REQ_EVT, NULL, 0); break; case A2DP_CTRL_CMD_SUSPEND: /* local suspend */ btif_dispatch_sm_event(BTIF_AV_SUSPEND_STREAM_REQ_EVT, NULL, 0); break; default: APPL_TRACE_ERROR1("UNSUPPORTED CMD (%d)", cmd); a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE); break; } APPL_TRACE_EVENT1("a2dp-ctrl-cmd : %s DONE", dump_a2dp_ctrl_event(cmd)); } static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event) { APPL_TRACE_DEBUG1("A2DP-CTRL-CHANNEL EVENT %s", dump_uipc_event(event)); switch(event) { case UIPC_OPEN_EVT: /* fetch av statemachine handle */ btif_media_cb.av_sm_hdl = btif_av_get_sm_handle(); break; case UIPC_CLOSE_EVT: /* restart ctrl server */ UIPC_Open(UIPC_CH_ID_AV_CTRL , btif_a2dp_ctrl_cb); break; case UIPC_RX_DATA_READY_EVT: btif_recv_ctrl_data(); break; default : APPL_TRACE_ERROR1("### A2DP-CTRL-CHANNEL EVENT %d NOT HANDLED ###", event); break; } } static void btif_a2dp_data_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event) { APPL_TRACE_DEBUG1("BTIF MEDIA (A2DP-DATA) EVENT %s", dump_uipc_event(event)); switch(event) { case UIPC_OPEN_EVT: /* read directly from media task from here on (keep callback for connection events */ UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_REMOVE_ACTIVE_READSET, NULL); /* make sure we update any changed sbc encoder params */ btif_a2dp_encoder_update(); /* Start the media task to encode SBC */ btif_media_task_start_aa_req(); /* ack back when media task is fully started */ break; case UIPC_CLOSE_EVT: a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS); btif_audiopath_detached(); break; default : APPL_TRACE_ERROR1("### A2DP-DATA EVENT %d NOT HANDLED ###", event); break; } } /***************************************************************************** ** BTIF ADAPTATION *****************************************************************************/ static void btif_a2dp_encoder_init(void) { UINT16 minmtu; tBTIF_MEDIA_INIT_AUDIO msg; tA2D_SBC_CIE sbc_config; /* lookup table for converting channel mode */ UINT16 codec_mode_tbl[5] = { SBC_JOINT_STEREO, SBC_STEREO, SBC_DUAL, 0, SBC_MONO }; /* lookup table for converting number of blocks */ UINT16 codec_block_tbl[5] = { 16, 12, 8, 0, 4 }; /* lookup table to convert freq */ UINT16 freq_block_tbl[5] = { SBC_sf48000, SBC_sf44100, SBC_sf32000, 0, SBC_sf16000 }; APPL_TRACE_DEBUG0("btif_a2dp_encoder_init"); /* Retrieve the current SBC configuration (default if currently not used) */ bta_av_co_audio_get_sbc_config(&sbc_config, &minmtu); msg.NumOfSubBands = (sbc_config.num_subbands == A2D_SBC_IE_SUBBAND_4) ? 4 : 8; msg.NumOfBlocks = codec_block_tbl[sbc_config.block_len >> 5]; msg.AllocationMethod = (sbc_config.alloc_mthd == A2D_SBC_IE_ALLOC_MD_L) ? SBC_LOUDNESS : SBC_SNR; msg.ChannelMode = codec_mode_tbl[sbc_config.ch_mode >> 1]; msg.SamplingFreq = freq_block_tbl[sbc_config.samp_freq >> 5]; msg.MtuSize = minmtu; APPL_TRACE_EVENT1("msg.ChannelMode %x", msg.ChannelMode); /* Init the media task to encode SBC properly */ btif_media_task_enc_init_req(&msg); } static void btif_a2dp_encoder_update(void) { UINT16 minmtu; tA2D_SBC_CIE sbc_config; tBTIF_MEDIA_UPDATE_AUDIO msg; UINT8 pref_min; UINT8 pref_max; APPL_TRACE_DEBUG0("btif_a2dp_encoder_update"); /* Retrieve the current SBC configuration (default if currently not used) */ bta_av_co_audio_get_sbc_config(&sbc_config, &minmtu); APPL_TRACE_DEBUG4("btif_a2dp_encoder_update: Common min_bitpool:%d(0x%x) max_bitpool:%d(0x%x)", sbc_config.min_bitpool, sbc_config.min_bitpool, sbc_config.max_bitpool, sbc_config.max_bitpool); if (sbc_config.min_bitpool > sbc_config.max_bitpool) { APPL_TRACE_ERROR0("btif_a2dp_encoder_update: ERROR btif_a2dp_encoder_update min_bitpool > max_bitpool"); } /* check if remote sink has a preferred bitpool range */ if (bta_av_co_get_remote_bitpool_pref(&pref_min, &pref_max) == TRUE) { /* adjust our preferred bitpool with the remote preference if within our capable range */ if (pref_min < sbc_config.min_bitpool) pref_min = sbc_config.min_bitpool; if (pref_max > sbc_config.max_bitpool) pref_max = sbc_config.max_bitpool; msg.MinBitPool = pref_min; msg.MaxBitPool = pref_max; if ((pref_min != sbc_config.min_bitpool) || (pref_max != sbc_config.max_bitpool)) { APPL_TRACE_EVENT2("## adjusted our bitpool range to peer pref [%d:%d] ##", pref_min, pref_max); } } else { msg.MinBitPool = sbc_config.min_bitpool; msg.MaxBitPool = sbc_config.max_bitpool; } msg.MinMtuSize = minmtu; /* Update the media task to encode SBC properly */ btif_media_task_enc_update_req(&msg); } /***************************************************************************** ** ** Function btif_a2dp_start_media_task ** ** Description ** ** Returns ** *******************************************************************************/ int btif_a2dp_start_media_task(void) { int retval; if (media_task_running) { APPL_TRACE_ERROR0("warning : media task already running"); return GKI_FAILURE; } APPL_TRACE_EVENT0("## A2DP START MEDIA TASK ##"); /* start a2dp media task */ retval = GKI_create_task((TASKPTR)btif_media_task, A2DP_MEDIA_TASK, A2DP_MEDIA_TASK_TASK_STR, (UINT16 *) ((UINT8 *)a2dp_media_task_stack + A2DP_MEDIA_TASK_STACK_SIZE), sizeof(a2dp_media_task_stack)); if (retval != GKI_SUCCESS) return retval; /* wait for task to come up to sure we are able to send messages to it */ while (media_task_running == 0) usleep(10); APPL_TRACE_EVENT0("## A2DP MEDIA TASK STARTED ##"); return retval; } /***************************************************************************** ** ** Function btif_a2dp_stop_media_task ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_stop_media_task(void) { APPL_TRACE_EVENT0("## A2DP STOP MEDIA TASK ##"); GKI_send_event(BT_MEDIA_TASK, BTIF_MEDIA_TASK_KILL); } /***************************************************************************** ** ** Function btif_a2dp_on_init ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_on_init(void) { //tput_mon(1, 0, 1); } /***************************************************************************** ** ** Function btif_a2dp_setup_codec ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_setup_codec(void) { tBTIF_AV_MEDIA_FEEDINGS media_feeding; tBTIF_STATUS status; APPL_TRACE_EVENT0("## A2DP SETUP CODEC ##"); GKI_disable(); /* for now hardcode 44.1 khz 16 bit stereo */ media_feeding.cfg.pcm.sampling_freq = 44100; media_feeding.cfg.pcm.bit_per_sample = 16; media_feeding.cfg.pcm.num_channel = 2; media_feeding.format = BTIF_AV_CODEC_PCM; if (bta_av_co_audio_set_codec(&media_feeding, &status)) { tBTIF_MEDIA_INIT_AUDIO_FEEDING mfeed; /* Init the encoding task */ btif_a2dp_encoder_init(); /* Build the media task configuration */ mfeed.feeding = media_feeding; mfeed.feeding_mode = BTIF_AV_FEEDING_ASYNCHRONOUS; /* Send message to Media task to configure transcoding */ btif_media_task_audio_feeding_init_req(&mfeed); } GKI_enable(); } /***************************************************************************** ** ** Function btif_a2dp_on_idle ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_on_idle(void) { APPL_TRACE_EVENT0("## ON A2DP IDLE ##"); /* Make sure media task is stopped */ btif_media_task_stop_aa_req(); bta_av_co_init(); } /***************************************************************************** ** ** Function btif_a2dp_on_open ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_on_open(void) { APPL_TRACE_EVENT0("## ON A2DP OPEN ##"); /* always use callback to notify socket events */ UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb); } /***************************************************************************** ** ** Function btif_a2dp_on_started ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_on_started(tBTA_AV_START *p_av) { tBTIF_AV_MEDIA_FEEDINGS media_feeding; tBTIF_STATUS status; APPL_TRACE_EVENT0("## ON A2DP STARTED ##"); if (p_av->status == BTA_AV_SUCCESS) { if (p_av->suspending == FALSE) { if (p_av->initiator) { a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS); } else { /* we were remotely started, make sure codec is setup before datapath is started */ btif_a2dp_setup_codec(); } /* media task is autostarted upon a2dp audiopath connection */ } } else { a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE); } } /***************************************************************************** ** ** Function btif_a2dp_on_stopped ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_on_stopped(tBTA_AV_SUSPEND *p_av) { APPL_TRACE_EVENT0("## ON A2DP STOPPED ##"); /* allow using this api for other than suspend */ if (p_av != NULL) { if (p_av->status != BTA_AV_SUCCESS) { APPL_TRACE_EVENT1("AV STOP FAILED (%d)", p_av->status); if (p_av->initiator) a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE); return; } } /* ensure tx frames are immediately suspended */ btif_media_cb.tx_flush = 1; /* request to stop media task */ btif_media_task_aa_tx_flush_req(); btif_media_task_stop_aa_req(); /* once stream is fully stopped we will ack back */ } /***************************************************************************** ** ** Function btif_a2dp_on_suspended ** ** Description ** ** Returns ** *******************************************************************************/ void btif_a2dp_on_suspended(tBTA_AV_SUSPEND *p_av) { APPL_TRACE_EVENT0("## ON A2DP SUSPENDED ##"); /* check for status failures */ if (p_av->status != BTA_AV_SUCCESS) { if (p_av->initiator == TRUE) a2dp_cmd_acknowledge(A2DP_CTRL_ACK_FAILURE); } /* once stream is fully stopped we will ack back */ /* ensure tx frames are immediately flushed */ btif_media_cb.tx_flush = 1; /* stop timer tick */ btif_media_task_stop_aa_req(); } /* when true media task discards any tx frames */ void btif_a2dp_set_tx_flush(BOOLEAN enable) { APPL_TRACE_EVENT1("## DROP TX %d ##", enable); btif_media_cb.tx_flush = enable; } /***************************************************************************** ** ** Function btif_calc_pcmtime ** ** Description Calculates the pcmtime equivalent of a datapacket ** ** Returns microseconds ** *******************************************************************************/ static int btif_calc_pcmtime(UINT32 bytes_processed) { int pcm_time_us = 0; tBTIF_AV_MEDIA_FEED_CFG *p_cfg; p_cfg = &btif_media_cb.media_feeding.cfg; /* calculate corresponding pcm time based on data processed */ switch(btif_media_cb.media_feeding.format) { case BTIF_AV_CODEC_PCM: pcm_time_us = (bytes_processed*1000000)/ (p_cfg->pcm.num_channel*p_cfg->pcm.sampling_freq*p_cfg->pcm.bit_per_sample/8); break; default : APPL_TRACE_ERROR1("mediafeeding format invalid : %d", btif_media_cb.media_feeding.format); break; } return pcm_time_us; } /***************************************************************************** ** ** Function ra_reset ** ** Description Media task tx rate adjustment ** ** Returns void ** *******************************************************************************/ static void ra_reset(void) { /* initialize start time of test interval */ btif_media_cb.ra.time_start.tv_nsec = 0; btif_media_cb.ra.time_start.tv_sec = 0; btif_media_cb.ra.tx_pcmtime_us= 0; } /***************************************************************************** ** ** Function ra_update ** ** Description Updates RA with amount of UIPC channel data processed ** ** Returns void ** *******************************************************************************/ static void ra_update(UINT32 bytes_processed) { /* if this is the first frame we will initialize tx start time */ if ( (btif_media_cb.ra.time_start.tv_sec == 0) && (btif_media_cb.ra.time_start.tv_nsec == 0) ) clock_gettime(CLOCK_MONOTONIC, &btif_media_cb.ra.time_start); btif_media_cb.ra.tx_pcmtime_us += btif_calc_pcmtime(bytes_processed); } /***************************************************************************** ** ** Function ra_adjust ** ** Description Calculates deviation between PCM time processed across ** UIPC audio channel and PCM time transmitted across the ** A2DP stream. Is checked every time slice (media timer ** tick). ** ** Returns Returns a frame count offset used to compensate for ** any drift versus the ideal clockrate ** *******************************************************************************/ static int ra_adjust(void) { unsigned long long time_elapsed_us; struct timespec now; int adjust = 0; /* don't start adjusting until we have read any pcm data */ if (btif_media_cb.ra.tx_pcmtime_us == 0) return 0; clock_gettime(CLOCK_MONOTONIC, &now); time_elapsed_us = (now.tv_sec - btif_media_cb.ra.time_start.tv_sec) * USEC_PER_SEC + \ (now.tv_nsec - btif_media_cb.ra.time_start.tv_nsec)/1000; VERBOSE("tx_pcmtime_us : %d us, elapsed : %d us", btif_media_cb.ra.tx_pcmtime_us, time_elapsed_us); /* compare elapsed time vs read pcm time */ if (btif_media_cb.ra.tx_pcmtime_us > time_elapsed_us) { //VERBOSE("TOO FAST : %06d us", btif_media_cb.ra.tx_pcmtime_us - time_elapsed_us); if ((btif_media_cb.ra.tx_pcmtime_us - time_elapsed_us) > BTIF_RA_OFFSET_TRIGGER_US) { VERBOSE("RA : -1 FRAME (%06d us)", btif_media_cb.ra.tx_pcmtime_us - time_elapsed_us); /* adjust by sending one frame less this time slice */ adjust--; } } else if (btif_media_cb.ra.tx_pcmtime_us < time_elapsed_us) { //VERBOSE("TOO SLOW : %06d us", time_elapsed_us - btif_media_cb.ra.tx_pcmtime_us); if ((time_elapsed_us - btif_media_cb.ra.tx_pcmtime_us) > BTIF_RA_OFFSET_TRIGGER_US) { VERBOSE("RA : +1 FRAME (%06d us)", time_elapsed_us - btif_media_cb.ra.tx_pcmtime_us); /* adjust by sending one frame more this time slice */ adjust++; } } return adjust; } /******************************************************************************* ** ** Function btif_media_task_aa_handle_timer ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_task_aa_handle_timer(void) { #if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) static UINT16 Debug = 0; APPL_TRACE_DEBUG1("btif_media_task_aa_handle_timer: %d", Debug++); #endif log_tstamps_us("media task tx timer"); #if (BTA_AV_INCLUDED == TRUE) btif_media_send_aa_frame(); #endif } #if (BTA_AV_INCLUDED == TRUE) /******************************************************************************* ** ** Function btif_media_task_aa_handle_timer ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_task_aa_handle_uipc_rx_rdy(void) { #if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) static UINT16 Debug = 0; APPL_TRACE_DEBUG1("btif_media_task_aa_handle_uipc_rx_rdy: %d", Debug++); #endif /* process all the UIPC data */ btif_media_aa_prep_2_send(0xFF); /* send it */ VERBOSE("btif_media_task_aa_handle_uipc_rx_rdy calls bta_av_ci_src_data_ready"); bta_av_ci_src_data_ready(BTA_AV_CHNL_AUDIO); } #endif /******************************************************************************* ** ** Function btif_media_task_init ** ** Description ** ** Returns void ** *******************************************************************************/ void btif_media_task_init(void) { memset(&(btif_media_cb), 0, sizeof(btif_media_cb)); UIPC_Init(NULL); #if (BTA_AV_INCLUDED == TRUE) UIPC_Open(UIPC_CH_ID_AV_CTRL , btif_a2dp_ctrl_cb); #endif } /******************************************************************************* ** ** Function btif_media_task ** ** Description Task for SBC encoder. This task receives an ** event when the waveIn interface has a pcm data buffer ** ready. On receiving the event, handle all ready pcm ** data buffers. If stream is started, run the SBC encoder ** on each chunk of pcm samples and build an output packet ** consisting of one or more encoded SBC frames. ** ** Returns void ** *******************************************************************************/ int btif_media_task(void *p) { UINT16 event; BT_HDR *p_msg; VERBOSE("================ MEDIA TASK STARTING ================"); btif_media_task_init(); media_task_running = 1; while (1) { event = GKI_wait(0xffff, 0); VERBOSE("================= MEDIA TASK EVENT %d ===============", event); if (event & BTIF_MEDIA_TASK_CMD) { /* Process all messages in the queue */ while ((p_msg = (BT_HDR *) GKI_read_mbox(BTIF_MEDIA_TASK_CMD_MBOX)) != NULL) { btif_media_task_handle_cmd(p_msg); } } if (event & BTIF_MEDIA_TASK_DATA) { /* Process all messages in the queue */ while ((p_msg = (BT_HDR *) GKI_read_mbox(BTIF_MEDIA_TASK_DATA_MBOX)) != NULL) { btif_media_task_handle_media(p_msg); } } if (event & BTIF_MEDIA_AA_TASK_TIMER) { /* advance audio timer expiration */ btif_media_task_aa_handle_timer(); } VERBOSE("=============== MEDIA TASK EVENT %d DONE ============", event); /* When we get this event we exit the task - should only happen on GKI_shutdown */ if (event & BTIF_MEDIA_TASK_KILL) { UIPC_Close(UIPC_CH_ID_ALL); break; } } /* Clear media task flag */ media_task_running = 0; APPL_TRACE_DEBUG0("MEDIA TASK EXITING"); return 0; } /******************************************************************************* ** ** Function btif_media_task_send_cmd_evt ** ** Description ** ** Returns TRUE is success ** *******************************************************************************/ BOOLEAN btif_media_task_send_cmd_evt(UINT16 Evt) { BT_HDR *p_buf; if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) { return FALSE; } p_buf->event = Evt; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); return TRUE; } /******************************************************************************* ** ** Function btif_media_flush_q ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_flush_q(BUFFER_Q *p_q) { while (GKI_IS_QUEUE_EMPTY(p_q) == FALSE) { GKI_freebuf(GKI_dequeue(p_q)); } } /******************************************************************************* ** ** Function btif_media_task_handle_cmd ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_task_handle_cmd(BT_HDR *p_msg) { VERBOSE("btif_media_task_handle_cmd : %d %s", p_msg->event, dump_media_event(p_msg->event)); switch (p_msg->event) { #if (BTA_AV_INCLUDED == TRUE) case BTIF_MEDIA_START_AA_TX: btif_media_task_aa_start_tx(); break; case BTIF_MEDIA_STOP_AA_TX: btif_media_task_aa_stop_tx(); break; case BTIF_MEDIA_SBC_ENC_INIT: btif_media_task_enc_init(p_msg); break; case BTIF_MEDIA_SBC_ENC_UPDATE: btif_media_task_enc_update(p_msg); break; case BTIF_MEDIA_AUDIO_FEEDING_INIT: btif_media_task_audio_feeding_init(p_msg); break; case BTIF_MEDIA_FLUSH_AA_TX: btif_media_task_aa_tx_flush(p_msg); break; case BTIF_MEDIA_UIPC_RX_RDY: btif_media_task_aa_handle_uipc_rx_rdy(); break; #endif default: APPL_TRACE_ERROR1("ERROR in btif_media_task_handle_cmd unknown event %d", p_msg->event); } GKI_freebuf(p_msg); VERBOSE("btif_media_task_handle_cmd : %s DONE", dump_media_event(p_msg->event)); } /******************************************************************************* ** ** Function btif_media_task_handle_media ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_task_handle_media(BT_HDR *p_msg) { APPL_TRACE_ERROR0("ERROR btif_media_task_handle_media: not in use"); GKI_freebuf(p_msg); } #if (BTA_AV_INCLUDED == TRUE) /******************************************************************************* ** ** Function btif_media_task_enc_init_req ** ** Description ** ** Returns TRUE is success ** *******************************************************************************/ BOOLEAN btif_media_task_enc_init_req(tBTIF_MEDIA_INIT_AUDIO *p_msg) { tBTIF_MEDIA_INIT_AUDIO *p_buf; if (NULL == (p_buf = GKI_getbuf(sizeof(tBTIF_MEDIA_INIT_AUDIO)))) { return FALSE; } memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_INIT_AUDIO)); p_buf->hdr.event = BTIF_MEDIA_SBC_ENC_INIT; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); return TRUE; } /******************************************************************************* ** ** Function btif_media_task_enc_update_req ** ** Description ** ** Returns TRUE is success ** *******************************************************************************/ BOOLEAN btif_media_task_enc_update_req(tBTIF_MEDIA_UPDATE_AUDIO *p_msg) { tBTIF_MEDIA_UPDATE_AUDIO *p_buf; if (NULL == (p_buf = GKI_getbuf(sizeof(tBTIF_MEDIA_UPDATE_AUDIO)))) { return FALSE; } memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_UPDATE_AUDIO)); p_buf->hdr.event = BTIF_MEDIA_SBC_ENC_UPDATE; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); return TRUE; } /******************************************************************************* ** ** Function btif_media_task_audio_feeding_init_req ** ** Description ** ** Returns TRUE is success ** *******************************************************************************/ BOOLEAN btif_media_task_audio_feeding_init_req(tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_msg) { tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_buf; if (NULL == (p_buf = GKI_getbuf(sizeof(tBTIF_MEDIA_INIT_AUDIO_FEEDING)))) { return FALSE; } memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_INIT_AUDIO_FEEDING)); p_buf->hdr.event = BTIF_MEDIA_AUDIO_FEEDING_INIT; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); return TRUE; } /******************************************************************************* ** ** Function btif_media_task_start_aa_req ** ** Description ** ** Returns TRUE is success ** *******************************************************************************/ BOOLEAN btif_media_task_start_aa_req(void) { BT_HDR *p_buf; if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) { APPL_TRACE_EVENT0("GKI failed"); return FALSE; } p_buf->event = BTIF_MEDIA_START_AA_TX; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); return TRUE; } /******************************************************************************* ** ** Function btif_media_task_stop_aa_req ** ** Description ** ** Returns TRUE is success ** *******************************************************************************/ BOOLEAN btif_media_task_stop_aa_req(void) { BT_HDR *p_buf; if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) { return FALSE; } p_buf->event = BTIF_MEDIA_STOP_AA_TX; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); return TRUE; } /******************************************************************************* ** ** Function btif_media_task_aa_tx_flush_req ** ** Description ** ** Returns TRUE is success ** *******************************************************************************/ BOOLEAN btif_media_task_aa_tx_flush_req(void) { BT_HDR *p_buf; if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) { return FALSE; } p_buf->event = BTIF_MEDIA_FLUSH_AA_TX; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); return TRUE; } /******************************************************************************* ** ** Function btif_media_task_aa_tx_flush ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_task_aa_tx_flush(BT_HDR *p_msg) { /* Flush all enqueued GKI music buffers (encoded) */ APPL_TRACE_DEBUG0("btif_media_task_aa_tx_flush"); btif_media_flush_q(&(btif_media_cb.TxAaQ)); UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REQ_RX_FLUSH, NULL); } /******************************************************************************* ** ** Function btif_media_task_enc_init ** ** Description Initialize encoding task ** ** Returns void ** *******************************************************************************/ static void btif_media_task_enc_init(BT_HDR *p_msg) { tBTIF_MEDIA_INIT_AUDIO *pInitAudio = (tBTIF_MEDIA_INIT_AUDIO *) p_msg; APPL_TRACE_DEBUG0("btif_media_task_enc_init"); btif_media_cb.timestamp = 0; /* SBC encoder config (enforced even if not used) */ btif_media_cb.encoder.s16ChannelMode = pInitAudio->ChannelMode; btif_media_cb.encoder.s16NumOfSubBands = pInitAudio->NumOfSubBands; btif_media_cb.encoder.s16NumOfBlocks = pInitAudio->NumOfBlocks; btif_media_cb.encoder.s16AllocationMethod = pInitAudio->AllocationMethod; btif_media_cb.encoder.s16SamplingFreq = pInitAudio->SamplingFreq; btif_media_cb.encoder.u16BitRate = DEFAULT_SBC_BITRATE; /* Default transcoding is PCM to SBC, modified by feeding configuration */ btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_SBC; btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET - sizeof(BT_HDR)) < pInitAudio->MtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET - sizeof(BT_HDR)) : pInitAudio->MtuSize; APPL_TRACE_DEBUG3("btif_media_task_enc_init busy %d, mtu %d, peer mtu %d", btif_media_cb.busy_level, btif_media_cb.TxAaMtuSize, pInitAudio->MtuSize); APPL_TRACE_DEBUG6("btif_media_task_enc_init ch mode %d, nbsubd %d, nb blk %d, alloc method %d, bit rate %d, Smp freq %d", btif_media_cb.encoder.s16ChannelMode, btif_media_cb.encoder.s16NumOfSubBands, btif_media_cb.encoder.s16NumOfBlocks, btif_media_cb.encoder.s16AllocationMethod, btif_media_cb.encoder.u16BitRate, btif_media_cb.encoder.s16SamplingFreq); /* Reset entirely the SBC encoder */ SBC_Encoder_Init(&(btif_media_cb.encoder)); APPL_TRACE_DEBUG1("btif_media_task_enc_init bit pool %d", btif_media_cb.encoder.s16BitPool); } /******************************************************************************* ** ** Function btif_media_task_enc_update ** ** Description Update encoding task ** ** Returns void ** *******************************************************************************/ static void btif_media_task_enc_update(BT_HDR *p_msg) { tBTIF_MEDIA_UPDATE_AUDIO * pUpdateAudio = (tBTIF_MEDIA_UPDATE_AUDIO *) p_msg; SBC_ENC_PARAMS *pstrEncParams = &btif_media_cb.encoder; UINT16 s16SamplingFreq; SINT16 s16BitPool; SINT16 s16BitRate; SINT16 s16FrameLen; UINT8 protect = 0; APPL_TRACE_DEBUG3("btif_media_task_enc_update : minmtu %d, maxbp %d minbp %d", pUpdateAudio->MinMtuSize, pUpdateAudio->MaxBitPool, pUpdateAudio->MinBitPool); /* Only update the bitrate and MTU size while timer is running to make sure it has been initialized */ //if (btif_media_cb.is_tx_timer) { btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET - sizeof(BT_HDR)) < pUpdateAudio->MinMtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET - sizeof(BT_HDR)) : pUpdateAudio->MinMtuSize; /* Set the initial target bit rate */ pstrEncParams->u16BitRate = DEFAULT_SBC_BITRATE; if (pstrEncParams->s16SamplingFreq == SBC_sf16000) s16SamplingFreq = 16000; else if (pstrEncParams->s16SamplingFreq == SBC_sf32000) s16SamplingFreq = 32000; else if (pstrEncParams->s16SamplingFreq == SBC_sf44100) s16SamplingFreq = 44100; else s16SamplingFreq = 48000; do { if ((pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) || (pstrEncParams->s16ChannelMode == SBC_STEREO) ) { s16BitPool = (SINT16)( (pstrEncParams->u16BitRate * pstrEncParams->s16NumOfSubBands * 1000 / s16SamplingFreq) -( (32 + (4 * pstrEncParams->s16NumOfSubBands * pstrEncParams->s16NumOfChannels) + ( (pstrEncParams->s16ChannelMode - 2) * pstrEncParams->s16NumOfSubBands ) ) / pstrEncParams->s16NumOfBlocks) ); s16FrameLen = 4 + (4*pstrEncParams->s16NumOfSubBands* pstrEncParams->s16NumOfChannels)/8 + ( ((pstrEncParams->s16ChannelMode - 2) * pstrEncParams->s16NumOfSubBands) + (pstrEncParams->s16NumOfBlocks * s16BitPool) ) / 8; s16BitRate = (8 * s16FrameLen * s16SamplingFreq) / (pstrEncParams->s16NumOfSubBands * pstrEncParams->s16NumOfBlocks * 1000); if (s16BitRate > pstrEncParams->u16BitRate) s16BitPool--; if(pstrEncParams->s16NumOfSubBands == 8) s16BitPool = (s16BitPool > 255) ? 255 : s16BitPool; else s16BitPool = (s16BitPool > 128) ? 128 : s16BitPool; } else { s16BitPool = (SINT16)( ((pstrEncParams->s16NumOfSubBands * pstrEncParams->u16BitRate * 1000) / (s16SamplingFreq * pstrEncParams->s16NumOfChannels)) -( ( (32 / pstrEncParams->s16NumOfChannels) + (4 * pstrEncParams->s16NumOfSubBands) ) / pstrEncParams->s16NumOfBlocks ) ); pstrEncParams->s16BitPool = (s16BitPool > (16 * pstrEncParams->s16NumOfSubBands)) ? (16*pstrEncParams->s16NumOfSubBands) : s16BitPool; } if (s16BitPool < 0) { s16BitPool = 0; } APPL_TRACE_EVENT2("bitpool candidate : %d (%d kbps)", s16BitPool, pstrEncParams->u16BitRate); if (s16BitPool > pUpdateAudio->MaxBitPool) { APPL_TRACE_WARNING1("btif_media_task_enc_update computed bitpool too large (%d)", s16BitPool); /* Decrease bitrate */ btif_media_cb.encoder.u16BitRate -= BTIF_MEDIA_BITRATE_STEP; /* Record that we have decreased the bitrate */ protect |= 1; } else if (s16BitPool < pUpdateAudio->MinBitPool) { APPL_TRACE_WARNING1("btif_media_task_enc_update computed bitpool too small (%d)", s16BitPool); /* Increase bitrate */ btif_media_cb.encoder.u16BitRate += BTIF_MEDIA_BITRATE_STEP; /* Record that we have increased the bitrate */ protect |= 2; } else { break; } /* In case we have already increased and decreased the bitrate, just stop */ if (protect == 3) { APPL_TRACE_ERROR0("btif_media_task_enc_update could not find bitpool in range"); break; } } while (1); /* Finally update the bitpool in the encoder structure */ pstrEncParams->s16BitPool = s16BitPool; APPL_TRACE_DEBUG2("btif_media_task_enc_update final bit rate %d, final bit pool %d", btif_media_cb.encoder.u16BitRate, btif_media_cb.encoder.s16BitPool); /* make sure we reinitialize encoder with new settings */ SBC_Encoder_Init(&(btif_media_cb.encoder)); } } /******************************************************************************* ** ** Function btif_media_task_pcm2sbc_init ** ** Description Init encoding task for PCM to SBC according to feeding ** ** Returns void ** *******************************************************************************/ static void btif_media_task_pcm2sbc_init(tBTIF_MEDIA_INIT_AUDIO_FEEDING * p_feeding) { BOOLEAN reconfig_needed = FALSE; APPL_TRACE_DEBUG0("PCM feeding:"); APPL_TRACE_DEBUG1("sampling_freq:%d", p_feeding->feeding.cfg.pcm.sampling_freq); APPL_TRACE_DEBUG1("num_channel:%d", p_feeding->feeding.cfg.pcm.num_channel); APPL_TRACE_DEBUG1("bit_per_sample:%d", p_feeding->feeding.cfg.pcm.bit_per_sample); /* Check the PCM feeding sampling_freq */ switch (p_feeding->feeding.cfg.pcm.sampling_freq) { case 8000: case 12000: case 16000: case 24000: case 32000: case 48000: /* For these sampling_freq the AV connection must be 48000 */ if (btif_media_cb.encoder.s16SamplingFreq != SBC_sf48000) { /* Reconfiguration needed at 48000 */ APPL_TRACE_DEBUG0("SBC Reconfiguration needed at 48000"); btif_media_cb.encoder.s16SamplingFreq = SBC_sf48000; reconfig_needed = TRUE; } break; case 11025: case 22050: case 44100: /* For these sampling_freq the AV connection must be 44100 */ if (btif_media_cb.encoder.s16SamplingFreq != SBC_sf44100) { /* Reconfiguration needed at 44100 */ APPL_TRACE_DEBUG0("SBC Reconfiguration needed at 44100"); btif_media_cb.encoder.s16SamplingFreq = SBC_sf44100; reconfig_needed = TRUE; } break; default: APPL_TRACE_DEBUG0("Feeding PCM sampling_freq unsupported"); break; } /* Some AV Headsets do not support Mono => always ask for Stereo */ if (btif_media_cb.encoder.s16ChannelMode == SBC_MONO) { APPL_TRACE_DEBUG0("SBC Reconfiguration needed in Stereo"); btif_media_cb.encoder.s16ChannelMode = SBC_JOINT_STEREO; reconfig_needed = TRUE; } if (reconfig_needed != FALSE) { APPL_TRACE_DEBUG0("btif_media_task_pcm2sbc_init calls SBC_Encoder_Init"); APPL_TRACE_DEBUG1("btif_media_task_pcm2sbc_init mtu %d", btif_media_cb.TxAaMtuSize); APPL_TRACE_DEBUG6("btif_media_task_pcm2sbc_init ch mode %d, nbsubd %d, nb blk %d, alloc method %d, bit rate %d, Smp freq %d", btif_media_cb.encoder.s16ChannelMode, btif_media_cb.encoder.s16NumOfSubBands, btif_media_cb.encoder.s16NumOfBlocks, btif_media_cb.encoder.s16AllocationMethod, btif_media_cb.encoder.u16BitRate, btif_media_cb.encoder.s16SamplingFreq); SBC_Encoder_Init(&(btif_media_cb.encoder)); } else { APPL_TRACE_DEBUG0("btif_media_task_pcm2sbc_init no SBC reconfig needed"); } } /******************************************************************************* ** ** Function btif_media_task_audio_feeding_init ** ** Description Initialize the audio path according to the feeding format ** ** Returns void ** *******************************************************************************/ static void btif_media_task_audio_feeding_init(BT_HDR *p_msg) { tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_feeding = (tBTIF_MEDIA_INIT_AUDIO_FEEDING *) p_msg; APPL_TRACE_DEBUG1("btif_media_task_audio_feeding_init format:%d", p_feeding->feeding.format); /* Save Media Feeding information */ btif_media_cb.feeding_mode = p_feeding->feeding_mode; btif_media_cb.media_feeding = p_feeding->feeding; /* Handle different feeding formats */ switch (p_feeding->feeding.format) { case BTIF_AV_CODEC_PCM: btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_SBC; btif_media_task_pcm2sbc_init(p_feeding); break; default : APPL_TRACE_ERROR1("unknown feeding format %d", p_feeding->feeding.format); break; } } /******************************************************************************* ** ** Function btif_media_task_uipc_cback ** ** Description UIPC call back function for synchronous mode only ** ** Returns void ** *******************************************************************************/ static void btif_media_task_uipc_cback(BT_HDR *p_msg) { /* Sanity check */ if (NULL == p_msg) { return; } /* Just handle RX_EVT */ if (p_msg->event != UIPC_RX_DATA_EVT) { return; } p_msg->event = BTIF_MEDIA_UIPC_RX_RDY; GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_msg); } /******************************************************************************* ** ** Function btif_media_task_feeding_state_reset ** ** Description Reset the media feeding state ** ** Returns void ** *******************************************************************************/ static void btif_media_task_feeding_state_reset(void) { /* By default, just clear the entire state */ memset(&btif_media_cb.media_feeding_state, 0, sizeof(btif_media_cb.media_feeding_state)); /* reset pcm time tracker */ ra_reset(); } /******************************************************************************* ** ** Function btif_media_task_aa_start_tx ** ** Description Start media task encoding ** ** Returns void ** *******************************************************************************/ static void btif_media_task_aa_start_tx(void) { APPL_TRACE_DEBUG2("btif_media_task_aa_start_tx is timer %d, feeding mode %d", btif_media_cb.is_tx_timer, btif_media_cb.feeding_mode); /* Use a timer to poll the UIPC, get rid of the UIPC call back */ // UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_CBACK, NULL); btif_media_cb.is_tx_timer = TRUE; #if ((defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE)) || \ (defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE))) btif_media_cb.tx_counter = 0; #endif /* Reset the media feeding state */ btif_media_task_feeding_state_reset(); APPL_TRACE_EVENT2("starting timer %d ticks (%d)", GKI_MS_TO_TICKS(BTIF_MEDIA_TIME_TICK), TICKS_PER_SEC); GKI_start_timer(BTIF_MEDIA_AA_TASK_TIMER_ID, GKI_MS_TO_TICKS(BTIF_MEDIA_TIME_TICK), TRUE); } /******************************************************************************* ** ** Function btif_media_task_aa_stop_tx ** ** Description Stop media task encoding ** ** Returns void ** *******************************************************************************/ static void btif_media_task_aa_stop_tx(void) { APPL_TRACE_DEBUG1("btif_media_task_aa_stop_tx is timer: %d", btif_media_cb.is_tx_timer); /* Stop the timer first */ GKI_stop_timer(BTIF_MEDIA_AA_TASK_TIMER_ID); btif_media_cb.is_tx_timer = FALSE; UIPC_Close(UIPC_CH_ID_AV_AUDIO); /* audio engine stopped, reset tx suspended flag */ btif_media_cb.tx_flush = 0; /* Reset the media feeding state */ btif_media_task_feeding_state_reset(); } /******************************************************************************* ** ** Function btif_get_num_aa_frame ** ** Description ** ** Returns The number of media frames in this time slice ** *******************************************************************************/ static UINT8 btif_get_num_aa_frame(void) { UINT8 result=0; switch (btif_media_cb.TxTranscoding) { case BTIF_MEDIA_TRSCD_PCM_2_SBC: switch (btif_media_cb.encoder.s16SamplingFreq) { case SBC_sf16000: result = BTIF_MEDIA_FR_PER_TICKS_16; break; case SBC_sf32000: result = BTIF_MEDIA_FR_PER_TICKS_32; break; case SBC_sf48000: result = BTIF_MEDIA_FR_PER_TICKS_48; break; case SBC_sf44100: if ((btif_media_cb.media_feeding_state.pcm.aa_frame_counter++ % 32) < 7) { result = BTIF_MEDIA_FR_PER_TICKS_44_1_L; } else { result = BTIF_MEDIA_FR_PER_TICKS_44_1_H; } break; } result += ra_adjust(); VERBOSE("WRITE %d FRAMES", result); #if ((defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE)) || \ (defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE))) btif_media_cb.tx_counter++; if (btif_media_cb.tx_counter == 10) { btif_media_cb.tx_counter = 0; #if defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE) result++; #endif #if defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE) result--; #endif } #endif break; default: APPL_TRACE_ERROR1("ERROR btif_get_num_aa_frame Unsupported transcoding format 0x%x", btif_media_cb.TxTranscoding); result = 0; break; } #if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) APPL_TRACE_DEBUG1("btif_get_num_aa_frame returns %d", result); #endif return result; } /******************************************************************************* ** ** Function btif_media_aa_readbuf ** ** Description This function is called by the av_co to get the next buffer to send ** ** ** Returns void *******************************************************************************/ BT_HDR *btif_media_aa_readbuf(void) { return GKI_dequeue(&(btif_media_cb.TxAaQ)); } /******************************************************************************* ** ** Function btif_media_aa_read_feeding ** ** Description ** ** Returns void ** *******************************************************************************/ BOOLEAN btif_media_aa_read_feeding(tUIPC_CH_ID channel_id) { UINT16 event; /* coverity[SIGN_EXTENSION] False-positive: Parameter are always in range avoiding sign extension*/ UINT16 blocm_x_subband = btif_media_cb.encoder.s16NumOfSubBands * btif_media_cb.encoder.s16NumOfBlocks; UINT32 read_size; UINT16 sbc_sampling = 48000; UINT32 src_samples; UINT16 bytes_needed = blocm_x_subband * btif_media_cb.encoder.s16NumOfChannels * sizeof(SINT16); static UINT16 up_sampled_buffer[SBC_MAX_NUM_FRAME * SBC_MAX_NUM_OF_BLOCKS * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS * 2]; static UINT16 read_buffer[SBC_MAX_NUM_FRAME * SBC_MAX_NUM_OF_BLOCKS * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS]; UINT32 src_size_used; UINT32 dst_size_used; BOOLEAN fract_needed; INT32 fract_max; INT32 fract_threshold; UINT32 nb_byte_read; /* Get the SBC sampling rate */ switch (btif_media_cb.encoder.s16SamplingFreq) { case SBC_sf48000: sbc_sampling = 48000; break; case SBC_sf44100: sbc_sampling = 44100; break; case SBC_sf32000: sbc_sampling = 32000; break; case SBC_sf16000: sbc_sampling = 16000; break; } /* Some Feeding PCM frequencies require to split the number of sample */ /* to read. */ /* E.g 128/6=21.3333 => read 22 and 21 and 21 => max = 2; threshold = 0*/ fract_needed = FALSE; /* Default */ switch (btif_media_cb.media_feeding.cfg.pcm.sampling_freq) { case 32000: case 8000: fract_needed = TRUE; fract_max = 2; /* 0, 1 and 2 */ fract_threshold = 0; /* Add one for the first */ break; case 16000: fract_needed = TRUE; fract_max = 2; /* 0, 1 and 2 */ fract_threshold = 1; /* Add one for the first two frames*/ break; } /* Compute number of sample to read from source */ src_samples = blocm_x_subband; src_samples *= btif_media_cb.media_feeding.cfg.pcm.sampling_freq; src_samples /= sbc_sampling; /* The previous division may have a remainder not null */ if (fract_needed) { if (btif_media_cb.media_feeding_state.pcm.aa_feed_counter <= fract_threshold) { src_samples++; /* for every read before threshold add one sample */ } /* do nothing if counter >= threshold */ btif_media_cb.media_feeding_state.pcm.aa_feed_counter++; /* one more read */ if (btif_media_cb.media_feeding_state.pcm.aa_feed_counter > fract_max) { btif_media_cb.media_feeding_state.pcm.aa_feed_counter = 0; } } /* Compute number of bytes to read from source */ read_size = src_samples; read_size *= btif_media_cb.media_feeding.cfg.pcm.num_channel; read_size *= (btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8); /* Read Data from UIPC channel */ nb_byte_read = UIPC_Read(channel_id, &event, (UINT8 *)read_buffer, read_size); /* update read 'pcmtime' */ ra_update(nb_byte_read); //tput_mon(TRUE, nb_byte_read, FALSE); if (nb_byte_read < read_size) { APPL_TRACE_WARNING2("### UNDERRUN :: ONLY READ %d BYTES OUT OF %d ###", nb_byte_read, read_size); if (nb_byte_read == 0) return FALSE; if(btif_media_cb.feeding_mode == BTIF_AV_FEEDING_ASYNCHRONOUS) { /* Fill the unfilled part of the read buffer with silence (0) */ memset(((UINT8 *)read_buffer) + nb_byte_read, 0, read_size - nb_byte_read); nb_byte_read = read_size; } } /* Initialize PCM up-sampling engine */ bta_av_sbc_init_up_sample(btif_media_cb.media_feeding.cfg.pcm.sampling_freq, sbc_sampling, btif_media_cb.media_feeding.cfg.pcm.bit_per_sample, btif_media_cb.media_feeding.cfg.pcm.num_channel); /* re-sample read buffer */ /* The output PCM buffer will be stereo, 16 bit per sec */ dst_size_used = bta_av_sbc_up_sample((UINT8 *)read_buffer, (UINT8 *)up_sampled_buffer + btif_media_cb.media_feeding_state.pcm.aa_feed_residue, nb_byte_read, sizeof(up_sampled_buffer) - btif_media_cb.media_feeding_state.pcm.aa_feed_residue, &src_size_used); #if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) APPL_TRACE_DEBUG3("btif_media_aa_read_feeding read_size:%d src_size_used:%d dst_size_used:%d", read_size, src_size_used, dst_size_used); #endif /* update the residue */ btif_media_cb.media_feeding_state.pcm.aa_feed_residue += dst_size_used; /* only copy the pcm sample when we have up-sampled enough PCM */ if(btif_media_cb.media_feeding_state.pcm.aa_feed_residue >= bytes_needed) { /* Copy the output pcm samples in SBC encoding buffer */ memcpy((UINT8 *)btif_media_cb.encoder.as16PcmBuffer, (UINT8 *)up_sampled_buffer, bytes_needed); /* update the residue */ btif_media_cb.media_feeding_state.pcm.aa_feed_residue -= bytes_needed; if (btif_media_cb.media_feeding_state.pcm.aa_feed_residue != 0) { memcpy((UINT8 *)up_sampled_buffer, (UINT8 *)up_sampled_buffer + bytes_needed, btif_media_cb.media_feeding_state.pcm.aa_feed_residue); } return TRUE; } #if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) APPL_TRACE_DEBUG3("btif_media_aa_read_feeding residue:%d, dst_size_used %d, bytes_needed %d", btif_media_cb.media_feeding_state.pcm.aa_feed_residue, dst_size_used, bytes_needed); #endif return FALSE; } /******************************************************************************* ** ** Function btif_media_aa_prep_sbc_2_send ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_aa_prep_sbc_2_send(UINT8 nb_frame) { BT_HDR * p_buf; UINT16 blocm_x_subband = btif_media_cb.encoder.s16NumOfSubBands * btif_media_cb.encoder.s16NumOfBlocks; #if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) APPL_TRACE_DEBUG2("btif_media_aa_prep_sbc_2_send nb_frame %d, TxAaQ %d", nb_frame, btif_media_cb.TxAaQ.count); #endif while (nb_frame) { if (NULL == (p_buf = GKI_getpoolbuf(BTIF_MEDIA_AA_POOL_ID))) { APPL_TRACE_ERROR1 ("ERROR btif_media_aa_prep_sbc_2_send no buffer TxCnt %d ", btif_media_cb.TxAaQ.count); return; } /* Init buffer */ p_buf->offset = BTIF_MEDIA_AA_SBC_OFFSET; p_buf->len = 0; p_buf->layer_specific = 0; do { /* Write @ of allocated buffer in encoder.pu8Packet */ btif_media_cb.encoder.pu8Packet = (UINT8 *) (p_buf + 1) + p_buf->offset + p_buf->len; /* Fill allocated buffer with 0 */ /* coverity[SIGN_EXTENSION] False-positive: Parameter are always in range avoiding sign extension*/ memset(btif_media_cb.encoder.as16PcmBuffer, 0, blocm_x_subband * btif_media_cb.encoder.s16NumOfChannels); /* Read PCM data and upsample them if needed */ if (btif_media_aa_read_feeding(UIPC_CH_ID_AV_AUDIO)) { /* SBC encode and descramble frame */ SBC_Encoder(&(btif_media_cb.encoder)); A2D_SbcChkFrInit(btif_media_cb.encoder.pu8Packet); A2D_SbcDescramble(btif_media_cb.encoder.pu8Packet, btif_media_cb.encoder.u16PacketLength); /* Update SBC frame length */ p_buf->len += btif_media_cb.encoder.u16PacketLength; nb_frame--; p_buf->layer_specific++; } else { /* no more pcm to read */ nb_frame = 0; /* break read loop if timer was stopped (media task stopped) */ if ( btif_media_cb.is_tx_timer == FALSE ) return; } } while (((p_buf->len + btif_media_cb.encoder.u16PacketLength) < btif_media_cb.TxAaMtuSize) && (p_buf->layer_specific < 0x0F) && nb_frame); /* coverity[SIGN_EXTENSION] False-positive: Parameter are always in range avoiding sign extension*/ btif_media_cb.timestamp += p_buf->layer_specific * blocm_x_subband; /* store the time stamp in the buffer to send */ *((UINT32 *) (p_buf + 1)) = btif_media_cb.timestamp; VERBOSE("TX QUEUE NOW %d", btif_media_cb.TxAaQ.count); if (btif_media_cb.tx_flush) { APPL_TRACE_DEBUG0("### tx suspended, discarded frame ###"); if (btif_media_cb.TxAaQ.count > 0) btif_media_flush_q(&(btif_media_cb.TxAaQ)); GKI_freebuf(p_buf); return; } /* Enqueue the encoded SBC frame in AA Tx Queue */ GKI_enqueue(&(btif_media_cb.TxAaQ), p_buf); } } /******************************************************************************* ** ** Function btif_media_aa_prep_2_send ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_aa_prep_2_send(UINT8 nb_frame) { VERBOSE("btif_media_aa_prep_2_send : %d frames (queue %d)", nb_frame, btif_media_cb.TxAaQ.count); /* Remove all the buffers not sent until there are only 4 in the queue */ while (btif_media_cb.TxAaQ.count >= MAX_OUTPUT_BUFFER_QUEUE_SZ) { APPL_TRACE_WARNING1("btif_media_aa_prep_2_send congestion buf count %d",btif_media_cb.TxAaQ.count); GKI_freebuf(GKI_dequeue(&(btif_media_cb.TxAaQ))); } switch (btif_media_cb.TxTranscoding) { case BTIF_MEDIA_TRSCD_PCM_2_SBC: btif_media_aa_prep_sbc_2_send(nb_frame); break; default: APPL_TRACE_ERROR1("ERROR btif_media_aa_prep_2_send unsupported transcoding format 0x%x",btif_media_cb.TxTranscoding); break; } } /******************************************************************************* ** ** Function btif_media_send_aa_frame ** ** Description ** ** Returns void ** *******************************************************************************/ static void btif_media_send_aa_frame(void) { UINT8 nb_frame_2_send; /* get the number of frame to send */ nb_frame_2_send = btif_get_num_aa_frame(); /* format and Q buffer to send */ btif_media_aa_prep_2_send(nb_frame_2_send); /* send it */ VERBOSE("btif_media_send_aa_frame : send %d frames", nb_frame_2_send); bta_av_ci_src_data_ready(BTA_AV_CHNL_AUDIO); } #endif /* BTA_AV_INCLUDED == TRUE */ /******************************************************************************* ** ** Function dump_codec_info ** ** Description Decode and display codec_info (for debug) ** ** Returns void ** *******************************************************************************/ void dump_codec_info(unsigned char *p_codec) { tA2D_STATUS a2d_status; tA2D_SBC_CIE sbc_cie; a2d_status = A2D_ParsSbcInfo(&sbc_cie, p_codec, FALSE); if (a2d_status != A2D_SUCCESS) { APPL_TRACE_ERROR1("ERROR dump_codec_info A2D_ParsSbcInfo fail:%d", a2d_status); return; } APPL_TRACE_DEBUG0("dump_codec_info"); if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_16) { APPL_TRACE_DEBUG1("\tsamp_freq:%d (16000)", sbc_cie.samp_freq);} else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_32) { APPL_TRACE_DEBUG1("\tsamp_freq:%d (32000)", sbc_cie.samp_freq);} else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_44) { APPL_TRACE_DEBUG1("\tsamp_freq:%d (44.100)", sbc_cie.samp_freq);} else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_48) { APPL_TRACE_DEBUG1("\tsamp_freq:%d (48000)", sbc_cie.samp_freq);} else { APPL_TRACE_DEBUG1("\tBAD samp_freq:%d", sbc_cie.samp_freq);} if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_MONO) { APPL_TRACE_DEBUG1("\tch_mode:%d (Mono)", sbc_cie.ch_mode);} else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_DUAL) { APPL_TRACE_DEBUG1("\tch_mode:%d (Dual)", sbc_cie.ch_mode);} else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_STEREO) { APPL_TRACE_DEBUG1("\tch_mode:%d (Stereo)", sbc_cie.ch_mode);} else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_JOINT) { APPL_TRACE_DEBUG1("\tch_mode:%d (Joint)", sbc_cie.ch_mode);} else { APPL_TRACE_DEBUG1("\tBAD ch_mode:%d", sbc_cie.ch_mode);} if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_4) { APPL_TRACE_DEBUG1("\tblock_len:%d (4)", sbc_cie.block_len);} else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_8) { APPL_TRACE_DEBUG1("\tblock_len:%d (8)", sbc_cie.block_len);} else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_12) { APPL_TRACE_DEBUG1("\tblock_len:%d (12)", sbc_cie.block_len);} else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_16) { APPL_TRACE_DEBUG1("\tblock_len:%d (16)", sbc_cie.block_len);} else { APPL_TRACE_DEBUG1("\tBAD block_len:%d", sbc_cie.block_len);} if (sbc_cie.num_subbands == A2D_SBC_IE_SUBBAND_4) { APPL_TRACE_DEBUG1("\tnum_subbands:%d (4)", sbc_cie.num_subbands);} else if (sbc_cie.num_subbands == A2D_SBC_IE_SUBBAND_8) { APPL_TRACE_DEBUG1("\tnum_subbands:%d (8)", sbc_cie.num_subbands);} else { APPL_TRACE_DEBUG1("\tBAD num_subbands:%d", sbc_cie.num_subbands);} if (sbc_cie.alloc_mthd == A2D_SBC_IE_ALLOC_MD_S) { APPL_TRACE_DEBUG1("\talloc_mthd:%d (SNR)", sbc_cie.alloc_mthd);} else if (sbc_cie.alloc_mthd == A2D_SBC_IE_ALLOC_MD_L) { APPL_TRACE_DEBUG1("\talloc_mthd:%d (Loundess)", sbc_cie.alloc_mthd);} else { APPL_TRACE_DEBUG1("\tBAD alloc_mthd:%d", sbc_cie.alloc_mthd);} APPL_TRACE_DEBUG2("\tBit pool Min:%d Max:%d", sbc_cie.min_bitpool, sbc_cie.max_bitpool); }