aud_bt_a2dp.c

最新MTK手机软件源码

        {
        #ifdef AMR_DECODE
            case MED_TYPE_AMR:
        #ifdef AMRWB_DECODE
            case MED_TYPE_AMR_WB:
        #endif 
                get_aud_info_func = AMR_GetContentDescInfo;
                break;
        #endif /* AMR_DECODE */ 
            case MED_TYPE_GSM_FR:
            case MED_TYPE_GSM_HR:
            case MED_TYPE_GSM_EFR:
        #ifdef __MED_VR_MOD__
            case MED_TYPE_VR:
        #endif 
                get_aud_info_func = VM_GetContentDescInfo;
                break;
            case MED_TYPE_PCM_16K:
            case MED_TYPE_PCM_8K:
            case MED_TYPE_DVI_ADPCM:
                get_aud_info_func = PCM_GetContentDescInfo;
                break;
        #ifdef DAF_DECODE
            case MED_TYPE_DAF:
                get_aud_info_func = DAF_GetContentDescInfo;
                break;
        #endif /* DAF_DECODE */ 
            case MED_TYPE_WAV:
            case MED_TYPE_WAV_ALAW:
            case MED_TYPE_WAV_ULAW:
            case MED_TYPE_WAV_DVI_ADPCM:
                get_aud_info_func = WAV_GetContentDescInfo;
                break;
            case MED_TYPE_AU:
                get_aud_info_func = AU_GetContentDescInfo;
                break;
            case MED_TYPE_AIFF:
                get_aud_info_func = AIFF_GetContentDescInfo;
                break;
        #ifdef WMA_DECODE
            case MED_TYPE_WMA:
                get_aud_info_func = WMA_GetContentDescInfo;
                break;
        #endif /* WMA_DECODE */ 
        #ifdef AAC_DECODE
            case MED_TYPE_AAC:
                get_aud_info_func = AAC_GetContentDescInfo;
                break;
        #endif /* AAC_DECODE */ 
        #if defined(MP4_CODEC) && defined(AAC_DECODE)
            case MED_TYPE_M4A:
                get_aud_info_func = M4A_GetContentDescInfo;
                break;
        #endif /* defined(MP4_CODEC) && defined(AAC_DECODE) */ 
            default:
                samplerate = 32000;
                stereo = KAL_TRUE;
                break;
        }
        if (get_aud_info_func != NULL)
        {
            FSAL_Open_Attach(&file, &current_file_stream);
            get_aud_info_func(&file, &aud_info, (void*)aud_context_p->current_format);
            samplerate = aud_info.sampleRate;
            stereo = aud_info.stereo;
        }
        if (aud_bt_a2dp_calc_audio_config(aud_context_p->current_format, BT_A2DP_SBC, stereo, samplerate, &cfg))
        {
            for (i = 0; i < audio_cap_num; i++)
            {
                if (bt_a2dp_match_audio_capabilities(&audio_cap_list[i], &cfg, &result))
                {
                    AUD_BT_A2DP_VALUE_TRACE(
                        result,
                        audio_cap_list[i].codec_cap.sbc.sample_rate,
                        audio_cap_list[i].codec_cap.sbc.channel_mode);

                    memcpy( audio_config, &cfg, sizeof (bt_a2dp_audio_cap_struct) );

                    AUD_BT_A2DP_FUNC_TRACE1(AUD_BT_A2DP_GET_AUDIO_CONFIG, 2);

                    return KAL_TRUE;
                }

                AUD_BT_A2DP_VALUE_TRACE(
                    result,
                    audio_cap_list[i].codec_cap.sbc.sample_rate,
                    audio_cap_list[i].codec_cap.sbc.channel_mode);
            }
        }
    }
    else
    {
        /* init default audio cap */
        cfg.codec_type = BT_A2DP_SBC;
        memcpy(&(cfg.codec_cap.sbc), &sbc_cap[0], sizeof(bt_a2dp_sbc_codec_cap_struct));

        aud_bt_a2dp_audio_cap_to_config(audio_cap_list, audio_config);

        AUD_BT_A2DP_FUNC_TRACE1(AUD_BT_A2DP_GET_AUDIO_CONFIG, 1);

        /* compare the remote audio config with local cap */
        if (!bt_a2dp_match_audio_capabilities(&cfg, audio_config, &result))
        {
            AUD_BT_A2DP_VALUE_TRACE(
                result,
                audio_config->codec_cap.sbc.sample_rate,
                audio_config->codec_cap.sbc.channel_mode)
            return KAL_FALSE;
        }

        AUD_BT_A2DP_VALUE_TRACE(
            result,
            audio_config->codec_cap.sbc.sample_rate,
            audio_config->codec_cap.sbc.channel_mode)
        
        return KAL_TRUE;
    }

    AUD_BT_A2DP_FUNC_TRACE1(AUD_BT_A2DP_GET_AUDIO_CONFIG, 0);
    
    return KAL_FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  aud_bt_a2dp_select_remote_seid
 * DESCRIPTION
 *  
 * PARAMETERS
 *  sep_num         [IN]        
 *  sep_list        [?]         
 * RETURNS
 *  
 *****************************************************************************/
kal_uint8 aud_bt_a2dp_select_remote_seid(kal_uint8 sep_num, bt_sep_info_struct *sep_list)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int16 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 0; i < sep_num; i++)
    {
        if (sep_list[i].sep_type == BT_A2DP_SINK && sep_list[i].media_type == BT_A2DP_MEDIA_AUDIO)
        {
            return sep_list[i].seid;
        }
    }

    return 0;
}


/*****************************************************************************
 * FUNCTION
 *  aud_bt_a2dp_stream_config_and_open_req
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_uint16 aud_bt_a2dp_stream_config_and_open_req(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 result;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    AUD_BT_A2DP_FUNC_ENTRY(AUD_BT_A2DP_STREAM_CONFIG_AND_OPEN_REQ);
    
    ASSERT(aud_bt_a2dp_ctx.wait == AUD_BT_A2DP_WAIT_NONE);

    result = MED_RES_OK;

    if (aud_bt_a2dp_ctx.mode == BT_A2DP_AGGRESSIVE_MODE)
    {
        switch (aud_bt_a2dp_ctx.state)
        {
            case AUD_BT_A2DP_STATE_IDLE:
                if (aud_bt_a2dp_ctx.remote_seid != 0)
                {
                    if (aud_bt_a2dp_ctx.audio_cap_num != 0)
                    {
                        if (aud_bt_a2dp_get_audio_config
                            (&aud_bt_a2dp_ctx.audio_config, aud_bt_a2dp_ctx.audio_cap_num,
                             aud_bt_a2dp_ctx.audio_cap_list))
                        {
                            bt_a2dp_send_stream_config_req(
                                MOD_MED,
                                aud_bt_a2dp_ctx.connect_id,
                                aud_bt_a2dp_ctx.remote_seid,
                                aud_bt_a2dp_ctx.local_seid,
                                &aud_bt_a2dp_ctx.audio_config);
                            aud_bt_a2dp_ctx.wait = AUD_BT_A2DP_WAIT_CONFIG_STREAM;
                        }
                        else
                        {
                            result = MED_RES_A2DP_NO_MATCH_CAP;
                        }
                    }
                    else
                    {
                        bt_a2dp_send_capabilities_get_req(
                            MOD_MED,
                            aud_bt_a2dp_ctx.connect_id,
                            aud_bt_a2dp_ctx.remote_seid);
                        aud_bt_a2dp_ctx.wait = AUD_BT_A2DP_WAIT_GET_CAP;
                    }
                }
                else
                {
                    bt_a2dp_send_sep_discover_req(MOD_MED, aud_bt_a2dp_ctx.connect_id);
                    aud_bt_a2dp_ctx.wait = AUD_BT_A2DP_WAIT_DISCOVER;
                }
                break;
            case AUD_BT_A2DP_STATE_CONFIGURED:
                bt_a2dp_send_stream_open_req(MOD_MED, aud_bt_a2dp_ctx.stream_handle);
                aud_bt_a2dp_ctx.wait = AUD_BT_A2DP_WAIT_OPEN_STREAM;
                break;
            default:
                ASSERT(0);
        }
    }
    else
    {
    }

    return result;
}


/*****************************************************************************
 * FUNCTION
 *  aud_bt_a2dp_cmd_queue_init
 * DESCRIPTION
 *  
 * PARAMETERS
 *  cmd_queue       [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_bt_a2dp_cmd_queue_init(aud_bt_a2dp_cmd_queue_struct *cmd_queue)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    cmd_queue->count = 0;
    cmd_queue->cmds[0] = AUD_BT_A2DP_CMD_NONE;
    cmd_queue->cmds[1] = AUD_BT_A2DP_CMD_NONE;
    cmd_queue->cmds[2] = AUD_BT_A2DP_CMD_NONE;
}


/*****************************************************************************
 * FUNCTION
 *  aud_bt_a2dp_cmd_queue_clear
 * DESCRIPTION
 *  
 * PARAMETERS
 *  cmd_queue       [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_bt_a2dp_cmd_queue_clear(aud_bt_a2dp_cmd_queue_struct *cmd_queue)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    AUD_BT_A2DP_FUNC_TRACE3(AUD_BT_A2DP_CMD_QUEUE_CLR, cmd_queue->cmds[0], cmd_queue->cmds[1], cmd_queue->cmds[2])
    
    aud_bt_a2dp_cmd_queue_init(cmd_queue);
}


/*****************************************************************************
 * FUNCTION
 *  aud_bt_a2dp_cmd_queue_pop
 * DESCRIPTION
 *  
 * PARAMETERS
 *  cmd_queue       [?]     
 * RETURNS
 *  
 *****************************************************************************/
kal_uint8 aud_bt_a2dp_cmd_queue_pop(aud_bt_a2dp_cmd_queue_struct *cmd_queue)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 cmd, i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (cmd_queue->count == 0)
    {
        ASSERT(cmd_queue->cmds[0] == AUD_BT_A2DP_CMD_NONE);

        cmd = AUD_BT_A2DP_CMD_NONE;
    }
    else
    {
        ASSERT(cmd_queue->cmds[0] != AUD_BT_A2DP_CMD_NONE);

        cmd = cmd_queue->cmds[0];
        cmd_queue->count--;
        for (i = 0; i < 3; i++)
        {
            if (i < cmd_queue->count)
            {
                cmd_queue->cmds[i] = cmd_queue->cmds[i + 1];    /* move forward */
            }
            else
            {
                cmd_queue->cmds[i] = AUD_BT_A2DP_CMD_NONE;  /* clear */
            }
        }
    }

    AUD_BT_A2DP_FUNC_TRACE3(AUD_BT_A2DP_CMD_QUEUE_POP, cmd_queue->cmds[0], cmd_queue->cmds[1], cmd_queue->cmds[2])
    
    return cmd;
}


/*****************************************************************************
 * FUNCTION
 *  aud_bt_a2dp_cmd_queue_add
 * DESCRIPTION
 *  
 * PARAMETERS
 *  cmd_queue       [?]         
 *  cmd0            [IN]        
 *  cmd1            [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void aud_bt_a2dp_cmd_queue_add(aud_bt_a2dp_cmd_queue_struct *cmd_queue, kal_uint8 cmd0, kal_uint8 cmd1)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 count;
    kal_uint16 queue_status = (kal_uint16) (cmd_queue->cmds[0] | (cmd_queue->cmds[1] << 3) | (cmd_queue->cmds[2] << 6));

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    switch (queue_status)
    {
            /* none, none, none */
        case AUD_BT_A2DP_CMD_QUEUE_EMPTY:
            cmd_queue->cmds[0] = cmd0;
            cmd_queue->cmds[1] = cmd1;
            break;

            /* abort, none, none */
        case AUD_BT_A2DP_CMD_QUEUE_ABORT:
            break;

            /* close, none, none */
        case AUD_BT_A2DP_CMD_QUEUE_CLOSE_STREAM:
            if (cmd0 == AUD_BT_A2DP_CMD_ABORT)
            {
                cmd_queue->cmds[0] = cmd0;  /* abort, none, none */
            }
            break;

            /* reconfig, none, none */
        case AUD_BT_A2DP_CMD_QUEUE_RECONFIG_STREAM:
            if (cmd0 == AUD_BT_A2DP_CMD_ABORT)
            {
                cmd_queue->cmds[0] = cmd0;  /* abort, none, none */
            }
            else if (cmd0 == AUD_BT_A2DP_CMD_START_STREAM)