aud_vr_sd.c

最新MTK手机软件源码

/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_rcg_callback
 * DESCRIPTION
 *  vr sd recognition call back function, send a message to media task itself and process then
 * PARAMETERS
 *  data        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_vr_sd_rcg_callback(void *data)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    aud_send_ilm(MOD_MED, MSG_ID_MEDIA_VR_RCG_PROCESS_REQ, NULL, NULL);
}


/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_trn_callback
 * DESCRIPTION
 *  vr sd training call back function, send a message to media task itself and process then
 * PARAMETERS
 *  data        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void aud_vr_sd_trn_callback(void *data)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    aud_send_ilm(MOD_MED, MSG_ID_MEDIA_VR_TRN_PROCESS_REQ, NULL, NULL);
}


/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_rcg_process
 * DESCRIPTION
 *  vr sd recognition call back process function
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void aud_vr_sd_rcg_process(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 med_res;
    kal_uint16 id_array[VR_MAX_RCG_RESULT_NUM];
    kal_uint16 id_length = 0;
    VR_Result result;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    AUD_FUNC_ENTRY(AUD_VR_VOICE_IN_RCG_CALLBACK);

    if (vr_ctx.state != AUD_VR_STATE_RCG_SESSION)
        return;

    result = VR_Process(&vr_ctx.word_id);

    AUD_VALUE_TRACE(result, vr_ctx.state, vr_sd_ctx.stage);

    switch (result)
    {
        case VR_OK:
            return;
        case VR_NO_SOUND:
            med_res = MED_RES_NO_SOUND;
            aud_vr_sd_abort();
            break;
        case VR_TOO_LONG:
            med_res = MED_RES_SPEAK_TOO_LONG;
            aud_vr_sd_abort();
            break;
        case VR_TOO_SHORT:
            med_res = MED_RES_SPEAK_TOO_SHORT;
            aud_vr_sd_abort();
            break;
        case VR_FAILED:
            med_res = MED_RES_NO_MATCH;
            aud_vr_sd_abort();
            break;
        case VR_FINISHED:
            med_res = MED_RES_OK;
            id_array[0] = vr_ctx.word_id;
            id_length = 1;
            med_free_ext_mem((void **)&vr_sd_ctx.buffer);
            /* finish a session naturely */
            vr_ctx.state = AUD_VR_STATE_IDLE;
            vr_sd_ctx.stage = AUD_VR_SD_SESSION_STAGE_NOT_READY;
            break;
        default:    /* other error cases */
            med_res = MED_RES_FAIL;
            aud_vr_sd_abort();
            break;
    }

    aud_send_vr_rcg_result_ind(vr_ctx.src_mod, vr_ctx.session_id, med_res, id_length, id_array);
}


/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_trn_process
 * DESCRIPTION
 *  vr sd training call back process function
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void aud_vr_sd_trn_process(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 med_res;
    VR_Result result;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    AUD_FUNC_ENTRY(AUD_VR_VOICE_IN_TRN_CALLBACK);

    if (vr_ctx.state != AUD_VR_STATE_TRN_SESSION)
        return;

    result = VR_Process(&vr_ctx.word_id);

    AUD_VALUE_TRACE(result, vr_ctx.state, vr_sd_ctx.stage);

    switch (result)
    {
        case VR_OK:
            return;
        case VR_NO_SOUND:
            med_res = MED_RES_NO_SOUND;
            aud_vr_sd_abort();
            break;
        case VR_TOO_DIFF:
            med_res = MED_RES_TOO_DIFFERENT;
            aud_vr_sd_abort();
            break;
        case VR_TOO_SIM:
            med_res = MED_RES_TOO_SIMILAR;
            aud_vr_sd_abort();
            break;
        case VR_FLASH_DISK_FULL:
            med_res = MED_RES_DISC_FULL;
            aud_vr_sd_abort();
            break;
        case VR_FLASH_ERROR:
            med_res = MED_RES_FAIL;
            aud_vr_sd_abort();
            break;
        case VR_TOO_LONG:
            med_res = MED_RES_SPEAK_TOO_LONG;
            aud_vr_sd_abort();
            break;
        case VR_TOO_SHORT:
            med_res = MED_RES_SPEAK_TOO_SHORT;
            aud_vr_sd_abort();
            break;
        case VR_FAILED:
            med_res = MED_RES_FAIL;
            aud_vr_sd_abort();
            break;
        case VR_CONTINUE:
            med_res = MED_RES_TRAINING_CONTINUE;
            vr_sd_ctx.stage = AUD_VR_SD_SESSION_STAGE_WAIT;
            break;
        case VR_FINISHED:
            med_res = MED_RES_OK;
            if (aud_vr_sd_find_word_id(vr_ctx.group_id, vr_ctx.word_id) < 0)
            {
                vr_sd_ctx.id_array[vr_ctx.group_id][vr_sd_ctx.id_length[vr_ctx.group_id]++] = vr_ctx.word_id;
            }
            med_free_ext_mem((void **)&vr_sd_ctx.buffer);
            /* finish a session naturely */
            vr_ctx.state = AUD_VR_STATE_IDLE;
            vr_sd_ctx.stage = AUD_VR_SD_SESSION_STAGE_NOT_READY;
            break;
        default:    /* other error cases */
            med_res = MED_RES_FAIL;
            aud_vr_sd_abort();
            break;
    }

    aud_send_vr_trn_result_ind(vr_ctx.src_mod, vr_ctx.session_id, med_res);
}


/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_startup
 * DESCRIPTION
 *  initialize vr sd module
 * PARAMETERS
 *  void
 * RETURNS
 *  kal_bool
 *****************************************************************************/
kal_bool aud_vr_sd_startup(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 filename[VR_MAX_DB_PATH_LEN + 1];
    kal_uint16 filepath[VR_MAX_DB_PATH_LEN + 1];
    kal_int32 group_id;
    FS_HANDLE fd_cursor;
    FS_DOSDirEntry file_info;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    vr_sd_ctx.buffer = NULL;
    vr_sd_ctx.stage = AUD_VR_SD_SESSION_STAGE_NOT_READY;
    kal_mem_set(vr_sd_ctx.id_length, 0, VR_SD_MAX_GROUP_NUM << 1);
    kal_wsprintf(filepath, "%c:\\VRDB\\ISD\\*", (kal_uint8) vr_ctx.db_drive);

#ifdef __NVRAM_IN_USB_MS__
    if (stack_query_boot_mode() == USBMS_BOOT)
    {
        return KAL_FALSE;
    }
#endif /* __NVRAM_IN_USB_MS__ */ 

    if ((fd_cursor = FS_FindFirst(filepath, 0, 0, &file_info, filename, (VR_MAX_DB_PATH_LEN + 1) << 1)) >= 0)
    {
        /* loop through each group folder */
        do
        {
            /* filter out non-folder results */
            if (file_info.Attributes & FS_ATTR_DIR)
            {
                /* parse group id */
                if ((group_id = aud_vr_sd_extract_group_id(filename)) >= 0)
                {
                    /* scan all tag files in each group folder */
                    kal_wsprintf(filepath, "%c:\\VRDB\\ISD\\%d\\", (kal_uint8) vr_ctx.db_drive, group_id);
                    aud_vr_sd_scan_tags_in_group_folder((kal_uint16) group_id, filepath);
                }
            }
        } while (FS_FindNext(fd_cursor, &file_info, filename, (VR_MAX_DB_PATH_LEN + 1) << 1) == FS_NO_ERROR);
        FS_FindClose(fd_cursor);
    }

    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_init_rcg
 * DESCRIPTION
 *  vr sd initialize a recognition session
 * PARAMETERS
 *  void
 * RETURNS
 *  kal_int32
 *****************************************************************************/
kal_int32 aud_vr_sd_init_rcg(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint32 buff_size;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (vr_ctx.state != AUD_VR_STATE_IDLE)
    {
        return MED_RES_BUSY;
    }

    /* scan and filter out non-exisiting tag files in id array */
    aud_vr_sd_filter_out_not_exist_tags(vr_ctx.group_id);

    /* detect memory leakage */
    ASSERT(vr_sd_ctx.buffer == NULL);

    /* get buffer size and alloc buffer */
    buff_size = VR_GetBufferSize();
    if ((vr_sd_ctx.buffer = (kal_uint8*) med_alloc_ext_mem(buff_size)) == NULL)
    {
        return MED_RES_MEM_INSUFFICIENT;
    }
    VR_SetBuffer(vr_sd_ctx.buffer);

    /* set database dir */
    VR_SetDatabaseDir((kal_uint8*) vr_ctx.db_path);

    /* start a session */
    vr_ctx.state = AUD_VR_STATE_RCG_SESSION;
    vr_sd_ctx.stage = AUD_VR_SD_SESSION_STAGE_READY;

    return MED_RES_OK;
}


/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_init_trn
 * DESCRIPTION
 *  vr sd initialize a training session
 * PARAMETERS
 *  void
 * RETURNS
 *  kal_int32
 *****************************************************************************/
kal_int32 aud_vr_sd_init_trn(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint32 buff_size;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (vr_ctx.state != AUD_VR_STATE_IDLE)
    {
        return MED_RES_BUSY;
    }

    /* scan and filter out non-exisiting tag files in id array */
    aud_vr_sd_filter_out_not_exist_tags(vr_ctx.group_id);
    /*
     * if( aud_vr_sd_find_word_id( vr_ctx.group_id, vr_ctx.word_id ) >= 0 )
     * return MED_RES_ID_EXIST;
     */
    /* detect memory leakage */
    ASSERT(vr_sd_ctx.buffer == NULL);

    /* get buffer size and alloc buffer */
    buff_size = VR_GetBufferSize();
    if ((vr_sd_ctx.buffer = (kal_uint8*) med_alloc_ext_mem(buff_size)) == NULL)
    {
        return MED_RES_MEM_INSUFFICIENT;
    }
    VR_SetBuffer(vr_sd_ctx.buffer);

    /* set database dir */
    VR_SetDatabaseDir((kal_uint8*) vr_ctx.db_path);

    /* start a session */
    vr_ctx.state = AUD_VR_STATE_TRN_SESSION;
    vr_sd_ctx.stage = AUD_VR_SD_SESSION_STAGE_READY;

    return MED_RES_OK;
}


/*****************************************************************************
 * FUNCTION
 *  aud_vr_sd_rcg_voice_in
 * DESCRIPTION
 *  vr sd voice in notification in a recognition session
 * PARAMETERS
 *  void
 * RETURNS
 *  kal_int32
 *****************************************************************************/
kal_int32 aud_vr_sd_rcg_voice_in(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 result;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    AUD_FUNC_ENTRY(AUD_VR_SD_RCG_VOICE_IN_REQ_HDLR);
    AUD_VALUE_TRACE(vr_ctx.state, vr_sd_ctx.stage, -1);

    if (vr_sd_ctx.stage == AUD_VR_SD_SESSION_STAGE_READY)
    {
        if (VR_RCG_Start(
                vr_sd_ctx.id_array[vr_ctx.group_id],
                &vr_sd_ctx.id_length[vr_ctx.group_id],
                aud_vr_sd_rcg_callback) == VR_OK)
        {
            result = MED_RES_OK;