aud_ctm.c

最新MTK手机软件源码

                    aud_ctm_send_text_req_queue_count(&aud_ctm_ctx.send_req_queue),
                    *send_num_p) if (--aud_ctm_ctx.unsent_count == 0)
                    CTM_ENTER_STATE(AUD_CTM_STATE_CONNECTED);
                (*send_num_p)--;
                if (*send_num_p == 0)
                {
                    aud_ctm_send_text_req_queue_del(&aud_ctm_ctx.send_req_queue);
                    aud_send_ctm_send_text_cnf(aud_ctm_ctx.src_mod_id, MED_RES_OK);
                }
            }
            break;
        case CTM_CHAR_RECEIVED:
            if (aud_ctm_ctx.state == AUD_CTM_STATE_SENDING || aud_ctm_ctx.state == AUD_CTM_STATE_CONNECTED)
            {
                do
                {
                    num_of_char = aud_ctm_read_text_from_recv_buf(
                                    aud_ctm_ctx.ucs2_utf8_buf_p,
                                    CTM_SEND_TEXT_CHAR_MAX_NUM,
                                    &more_data);
                    if (num_of_char != 0)
                    {
                        aud_send_ctm_recv_text_ind(aud_ctm_ctx.src_mod_id, num_of_char, aud_ctm_ctx.ucs2_utf8_buf_p);
                    }
                } while (more_data);
            }
            break;
    }
}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    CTM_STATE_TRACE(aud_ctm_ctx.state) if (aud_ctm_ctx.state != AUD_CTM_STATE_IDLE)
    {
        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);

        L1Ctm_Close();

        if (aud_ctm_ctx.buf_p != NULL)
        {
            med_free_ext_mem((void **)&aud_ctm_ctx.buf_p);
        }

        if (aud_ctm_ctx.ucs2_utf8_buf_p != NULL)
        {
            med_free_ext_mem((void **)&aud_ctm_ctx.ucs2_utf8_buf_p);
        }

        /* restore speech input & output path / volume */
        aud_ctm_set_speech_vol_and_path(aud_context_p->audio_mode);
    }
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_open_req_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_ctm_open_req_hdlr(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_ctm_open_req_struct *req = (media_ctm_open_req_struct*) ilm_ptr->local_para_ptr;
    kal_uint32 buf_len;
    kal_uint8 result, ctm_inferface;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    CTM_FUNC_ENTRY(AUD_CTM_OPEN_REQ_HDLR) if (aud_context_p->speech_on)
    {
        /* close up if possible */
        aud_ctm_close_up();

        /* check memory requirement */
        buf_len = L1Ctm_GetMemReq();

        /* alloc from ext mem */
        aud_ctm_ctx.buf_p = (kal_uint8*) med_alloc_ext_mem(buf_len);
        ASSERT(aud_ctm_ctx.buf_p != NULL);

        aud_ctm_ctx.ucs2_utf8_buf_p = (kal_uint8*) med_alloc_ext_mem(CTM_TEXT_CONVERT_BUF_SIZE);
        ASSERT(aud_ctm_ctx.ucs2_utf8_buf_p != NULL);

        /* update state to ready state */
        CTM_ENTER_STATE(AUD_CTM_STATE_READY);
        aud_ctm_ctx.src_mod_id = ilm_ptr->src_mod_id;
        aud_ctm_ctx.mode = ctm_inferface = req->ctm_interface;

        /* call l1audio ctm open */
        if (ctm_inferface > AUD_CTM_BAUDOT_MODE)
        {
            ctm_inferface = AUD_CTM_BAUDOT_MODE;
        }
        L1Ctm_Open(ctm_inferface, aud_ctm_event_callback, aud_ctm_ctx.buf_p, buf_len, (CTM_Param*) & req->ctm_param);

        aud_ctm_ctx.input_vol = req->ctm_param.input_vol;
        aud_ctm_ctx.output_vol = req->ctm_param.output_vol;

        aud_ctm_set_speech_vol_and_path(aud_context_p->audio_mode);

        result = MED_RES_OK;
    }
    else
    {
        result = MED_RES_FAIL;
    }

    /* send a confirm message back to caller */
    aud_send_ctm_open_cnf(ilm_ptr->src_mod_id, result);
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_close_req_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_ctm_close_req_hdlr(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    CTM_FUNC_ENTRY(AUD_CTM_CLOSE_REQ_HDLR)
        /* close up if possible */
        aud_ctm_close_up();

    /* send a confirm message back to caller */
    aud_send_ctm_close_cnf(ilm_ptr->src_mod_id, MED_RES_OK);
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_connect_req_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_ctm_connect_req_hdlr(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    CTM_FUNC_ENTRY(AUD_CTM_CONNECT_REQ_HDLR)
        CTM_STATE_TRACE(aud_ctm_ctx.state) if (aud_ctm_ctx.state != AUD_CTM_STATE_READY)
        aud_send_ctm_connect_cnf(ilm_ptr->src_mod_id, MED_RES_FAIL);
    else
    {
        if (aud_ctm_ctx.mode == DIRECT_MODE)
        {
            aud_ctm_ctx.src_mod_id = ilm_ptr->src_mod_id;
            CTM_ENTER_STATE(AUD_CTM_STATE_CONNECTING);
            L1Ctm_StartNegotiation();
        }
        else
        {
            aud_send_ctm_connect_cnf(ilm_ptr->src_mod_id, MED_RES_FAIL);
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_send_text_req_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_ctm_send_text_req_hdlr(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_ctm_send_text_req_struct *req_p = (media_ctm_send_text_req_struct*) ilm_ptr->local_para_ptr;
    kal_uint32 text_bytes;
    kal_uint32 sent_bytes;
    kal_uint32 left_count;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    CTM_FUNC_ENTRY(AUD_CTM_SEND_TEXT_REQ_HDLR) CTM_STATE_TRACE(aud_ctm_ctx.state) if (aud_ctm_ctx.mode != DIRECT_MODE)
    {
        aud_send_ctm_connect_cnf(ilm_ptr->src_mod_id, MED_RES_FAIL);
        return;
    }

    switch (aud_ctm_ctx.state)
    {
        case AUD_CTM_STATE_CONNECTED:
            ASSERT(aud_ctm_send_text_req_queue_count(&aud_ctm_ctx.send_req_queue) == 0);
            if (aud_ctm_ctx.mode == DIRECT_MODE)
            {
                CTM_ENTER_STATE(AUD_CTM_STATE_SENDING);
            }
            else
            {
                aud_send_ctm_send_text_cnf(ilm_ptr->src_mod_id, MED_RES_FAIL);
            }
        case AUD_CTM_STATE_SENDING:
            if (aud_ctm_ctx.mode == DIRECT_MODE)
            {
                if (aud_ctm_send_text_req_queue_full(&aud_ctm_ctx.send_req_queue))
                {
                    aud_send_ctm_send_text_cnf(ilm_ptr->src_mod_id, MED_RES_FAIL);
                }
                else
                {
                    aud_ctm_ctx.src_mod_id = ilm_ptr->src_mod_id;
                    /* convert ucs2 to utf8 */
                    text_bytes =
                        (kal_uint32) med_util_ucs2_to_utf8(
                                        aud_ctm_ctx.ucs2_utf8_buf_p,
                                        CTM_TEXT_CONVERT_BUF_SIZE,
                                        (kal_uint8*) req_p->text,
                                        (kal_uint32) req_p->num_of_char * 2) - 1;

                    CTM_VALUES_TRACE(
                        aud_ctm_ctx.unsent_count,
                        aud_ctm_send_text_req_queue_count(&aud_ctm_ctx.send_req_queue),
                        text_bytes) aud_ctm_ctx.unsent_count += (kal_uint16) text_bytes;
                    aud_ctm_send_text_req_queue_add(&aud_ctm_ctx.send_req_queue, (kal_uint16) text_bytes);

                    /* fill utf8 text to l1audio ctm Tx text buffer */
                    sent_bytes = L1Ctm_TxPutText(aud_ctm_ctx.ucs2_utf8_buf_p, text_bytes, &left_count);
                    ASSERT(sent_bytes == text_bytes);
                }
            }
            else
            {
                aud_send_ctm_send_text_cnf(ilm_ptr->src_mod_id, MED_RES_FAIL);
            }
            break;
        default:
            aud_send_ctm_send_text_cnf(ilm_ptr->src_mod_id, MED_RES_FAIL);
            break;
    }
}


/*****************************************************************************
 * FUNCTION
 *  aud_ctm_main
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_ctm_main(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    switch (ilm_ptr->msg_id)
    {
        case MSG_ID_MEDIA_CTM_EVENT_IND:
            aud_ctm_event_ind_hdlr(ilm_ptr);
            break;
        case MSG_ID_MEDIA_CTM_OPEN_REQ:
            aud_ctm_open_req_hdlr(ilm_ptr);
            break;
        case MSG_ID_MEDIA_CTM_CLOSE_REQ:
            aud_ctm_close_req_hdlr(ilm_ptr);
            break;
        case MSG_ID_MEDIA_CTM_CONNECT_REQ:
            aud_ctm_connect_req_hdlr(ilm_ptr);
            break;
        case MSG_ID_MEDIA_CTM_SEND_TEXT_REQ:
            aud_ctm_send_text_req_hdlr(ilm_ptr);
            break;
        default:
            ASSERT(0);
    }
}
#endif /* __MED_CTM_MOD__ */ 

#endif /* MED_NOT_PRESENT */ 

#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif /* 0 */