aud_ctm.c

最新MTK手机软件源码

 * RETURNS
 *  
 *****************************************************************************/
kal_uint16 aud_ctm_read_text_from_recv_buf(kal_uint8 *dest, kal_uint16 max_num_of_char, kal_bool *more_data)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint32 recv_bytes, left_count;
    kal_uint8 text_bytes;
    kal_uint8 text[3];
    kal_bool align;
    kal_wchar ucs2;
    kal_uint16 num_of_char;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    *more_data = KAL_FALSE;

    /* get the first byte of the utf8 char */
    if (aud_ctm_ctx.more_recv_utf8_byte)
    {
        /* from previous read cache */
        text[0] = aud_ctm_ctx.first_recv_utf8_byte;

        /* clear cache */
        aud_ctm_ctx.first_recv_utf8_byte = 0;
        aud_ctm_ctx.more_recv_utf8_byte = KAL_FALSE;
    }
    else
    {
        /* from l1audio text buffer */
        recv_bytes = L1Ctm_RxGetText((kal_uint8*) text, 1, &left_count);
        if (recv_bytes == 0)
        {
            return 0;
        }
    }

    CTM_READ_TEXT_TRACE1(aud_ctm_ctx.first_recv_utf8_byte, aud_ctm_ctx.more_recv_utf8_byte, text[0])
        /* get the rest of bytes of the utf8 char */
        for (num_of_char = 0; num_of_char < max_num_of_char; num_of_char++)
    {
        CTM_VALUE_TRACE(num_of_char)
            /* skip utf8 - 4 bytes char or non-utf8 data & align with the begin of utf8 - 1, 2, 3 bytes char */
            for (align = KAL_FALSE; !align;)
        {
            /* check utf8 char size, if it's non-utf8 data, its size will be 0 */
            text_bytes = utf8_bytes_per_char[text[0] >> 4];

            CTM_READ_TEXT_TRACE2(text[0], text_bytes, num_of_char)
                /* skip utf8 - 4 bytes char */
                switch (text_bytes)
            {
                case 1:
                case 2:
                case 3:
                    align = KAL_TRUE;
                    break;
                case 4:
                    /* get the rest 3 bytes char */
                    recv_bytes = L1Ctm_RxGetText((kal_uint8*) text, 3, &left_count);
                    if (recv_bytes < 3)
                    {
                        return num_of_char;
                    }
                    /* continue to get next byte */
                case 0:
                    /* get next byte */
                    recv_bytes = L1Ctm_RxGetText((kal_uint8*) text, 1, &left_count);
                    if (recv_bytes == 0)
                    {
                        return num_of_char;
                    }
                    break;
            }
        }

        text_bytes--;
        if (text_bytes != 0)
        {
            L1Ctm_RxGetText((kal_uint8*) text, 0, &left_count);
            if (left_count < (kal_uint32) text_bytes)
            {
                /* set cache */
                aud_ctm_ctx.more_recv_utf8_byte = KAL_TRUE;
                aud_ctm_ctx.first_recv_utf8_byte = text[0];
                return num_of_char;
            }
            recv_bytes = L1Ctm_RxGetText((kal_uint8*) text + 1, (kal_uint32) text_bytes, &left_count);
            ASSERT(recv_bytes == (kal_uint32) text_bytes);
        }

        switch (text_bytes)
        {
            case 0:
                ucs2 = (kal_wchar) text[0];
                break;
            case 1:
                ucs2 = ((kal_uint16) (text[0] & 0x1F) << 6) | (kal_uint16) (text[1] & 0x3F);
                break;
            case 2:
                ucs2 =
                    ((kal_uint16) (text[0] & 0x0F) << 12) | ((kal_uint16) (text[1] & 0x3F) << 6) | (kal_uint16) (text[2]
                                                                                                                 &
                                                                                                                 0x3F);
                break;
        }

        CTM_VALUE_TRACE(ucs2) dest[num_of_char << 1] = (kal_uint8) (ucs2 & 0xFF);
        dest[(num_of_char << 1) + 1] = (kal_uint8) (ucs2 >> 8);

        /* get next byte from l1audio text buffer */
        recv_bytes = L1Ctm_RxGetText((kal_uint8*) text, 1, &left_count);
        if (recv_bytes == 0)
        {
            return num_of_char + 1;
        }
    }

    *more_data = KAL_TRUE;
    return num_of_char;
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_init
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_bool aud_ctm_init(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    CTM_ENTER_STATE(AUD_CTM_STATE_IDLE);
    aud_ctm_ctx.first_recv_utf8_byte = 0;
    aud_ctm_ctx.more_recv_utf8_byte = KAL_FALSE;
    aud_ctm_ctx.unsent_count = 0;
    aud_ctm_send_text_req_queue_init(&aud_ctm_ctx.send_req_queue);
    aud_ctm_ctx.buf_p = NULL;
    aud_ctm_ctx.ucs2_utf8_buf_p = NULL;
    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_set_speech_vol_and_path
 * DESCRIPTION
 *  
 * PARAMETERS
 *  audio_mode      [IN]        
 * RETURNS
 *  
 *****************************************************************************/
kal_bool aud_ctm_set_speech_vol_and_path(kal_uint8 audio_mode)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int16 *input_fir_coeff_p, *output_fir_coeff_p;
    kal_uint8 input_device, output_device;
    kal_uint8 volume_gain, volume_level;
    kal_int16 baudot_fir_coeff[30];
    kal_bool on = ((aud_ctm_ctx.state != AUD_CTM_STATE_IDLE) && (aud_ctm_ctx.mode != DIRECT_MODE));

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    baudot_fir_coeff[0] = 0x7FFF;
    memset(&baudot_fir_coeff[1], 0, 58);

    /* set speech output volume, device & fir coeff */
    if (on && aud_ctm_ctx.mode != AUD_CTM_HCO_MODE)
    {
        output_device = AUDIO_DEVICE_SPEAKER2;
        output_fir_coeff_p = &baudot_fir_coeff[0];
        volume_gain = aud_ctm_ctx.output_vol;
    }
    else
    {
        switch (audio_mode)
        {
            case AUD_MODE_NORMAL:
                output_device = AUDIO_DEVICE_SPEAKER;
                output_fir_coeff_p =
                    &aud_context_p->audio_param.FIR_output_coeff[aud_context_p->audio_param.
                                                                 selected_FIR_output_index][0];
                break;
            case AUD_MODE_HEADSET:
                output_device = AUDIO_DEVICE_SPEAKER2;
                output_fir_coeff_p = &aud_context_p->audio_param.FIR_output_coeff[6][0];
                break;
            case AUD_MODE_LOUDSPK:
                output_device = AUDIO_DEVICE_LOUDSPEAKER;
                output_fir_coeff_p = &aud_context_p->audio_param.FIR_output_coeff[5][0];
                break;
        }
        volume_level = aud_get_volume_level(audio_mode, AUD_VOLUME_SPH);
        volume_gain = aud_get_volume_gain(audio_mode, AUD_VOLUME_SPH, volume_level);
    }
    aud_speech_set_output_device(custom_cfg_hw_aud_output_path(output_device));
    aud_speech_set_output_volume(volume_gain, 0);

    /* set speech input volume, device & fir */
    if (on && aud_ctm_ctx.mode != AUD_CTM_VCO_MODE)
    {
        input_device = AUDIO_DEVICE_MIC2;
        input_fir_coeff_p = &baudot_fir_coeff[0];
        volume_gain = aud_ctm_ctx.input_vol;
    }
    else
    {
        switch (audio_mode)
        {
            case AUD_MODE_NORMAL:
                input_device = AUDIO_DEVICE_MIC1;
                input_fir_coeff_p = &aud_context_p->audio_param.FIR_input_coeff[0][0];
                break;
            case AUD_MODE_HEADSET:
                input_device = AUDIO_DEVICE_MIC2;
                input_fir_coeff_p = &aud_context_p->audio_param.FIR_input_coeff[1][0];
                break;
            case AUD_MODE_LOUDSPK:
                input_device = AUDIO_DEVICE_MIC1;
                input_fir_coeff_p = &aud_context_p->audio_param.FIR_input_coeff[0][0];
                break;
        }
        volume_level = aud_get_volume_level(audio_mode, AUD_VOLUME_MIC);
        volume_gain = aud_get_volume_gain(audio_mode, AUD_VOLUME_MIC, volume_level);
    }
    aud_mic_set_device(custom_cfg_hw_aud_input_path(input_device));
    aud_mic_set_volume(volume_gain, volume_gain);

    /* set speech FIR coefficient */
    L1SP_Write_Audio_Coefficients(input_fir_coeff_p, output_fir_coeff_p);
    aud_speech_set_fir(KAL_TRUE);

    return on;
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_event_callback
 * DESCRIPTION
 *  
 * PARAMETERS
 *  event       [IN]        
 *  param       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
void aud_ctm_event_callback(L1Ctm_Event event, void *param)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_ctm_event_ind_struct *ind_p;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    switch (event)
    {
        case CTM_MO_SUCCESS:
        case CTM_MO_FAIL:
        case CTM_MT_DETECTED:
        case CTM_CHAR_SENT:
        case CTM_CHAR_RECEIVED:
            ind_p = (media_ctm_event_ind_struct*) construct_local_para(sizeof(media_ctm_event_ind_struct), TD_CTRL);
            ind_p->event = event;
            aud_send_ilm(MOD_MED, MSG_ID_MEDIA_CTM_EVENT_IND, ind_p, NULL);
            break;
    }
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_event_ind_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_ctm_event_ind_hdlr(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_ctm_event_ind_struct *ind_p = (media_ctm_event_ind_struct*) ilm_ptr->local_para_ptr;
    kal_uint16 *send_num_p;
    kal_uint16 num_of_char;
    kal_bool more_data;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    CTM_FUNC_ENTRY(AUD_CTM_EVENT_IND_HDLR)
        CTM_STATE_TRACE(aud_ctm_ctx.state) CTM_VALUE_TRACE(ind_p->event) switch (ind_p->event)
    {
        case CTM_MO_SUCCESS:
            if (aud_ctm_ctx.state == AUD_CTM_STATE_CONNECTING)
            {
                CTM_ENTER_STATE(AUD_CTM_STATE_CONNECTED);
                aud_send_ctm_connect_cnf(aud_ctm_ctx.src_mod_id, MED_RES_OK);
            }
            break;
        case CTM_MO_FAIL:
            if (aud_ctm_ctx.state == AUD_CTM_STATE_CONNECTING)
            {
                CTM_ENTER_STATE(AUD_CTM_STATE_READY);
                aud_send_ctm_connect_cnf(aud_ctm_ctx.src_mod_id, MED_RES_FAIL);
            }
            break;
        case CTM_MT_DETECTED:
            if (aud_ctm_ctx.state == AUD_CTM_STATE_READY || aud_ctm_ctx.state == AUD_CTM_STATE_CONNECTING)
            {
                CTM_ENTER_STATE(AUD_CTM_STATE_CONNECTED);
                aud_send_ctm_connected_ind(aud_ctm_ctx.src_mod_id);
            }
            break;
        case CTM_CHAR_SENT:
            if (aud_ctm_ctx.state == AUD_CTM_STATE_SENDING)
            {
                send_num_p = aud_ctm_send_text_req_queue_head(&aud_ctm_ctx.send_req_queue);
                ASSERT(send_num_p != NULL && *send_num_p != 0);

                CTM_VALUES_TRACE(
                    aud_ctm_ctx.unsent_count,