uttproc.c

WinCE平台上的语音识别程序

            ("uttproc_rawdata mixed with uttproc_cepdata in same utterance??\n");
        return -1;
    }
    inputtype = INPUT_RAW;

    if (utt_ofl)
        return -1;

    k = (MAX_UTT_LEN - n_cepfr) * fe->FRAME_RATE;
    if (len > k) {
        len = k;
        utt_ofl = 1;
        E_ERROR("Utterance too long; truncating to about %d frames\n",
                MAX_UTT_LEN);
    }

    if (rawfp && (len > 0))
        fwrite(raw, sizeof(int16), len, rawfp);

    if ((k = fe_process_utt(fe, raw, len, &temp_mfc, &nfr)) < 0)
        return -1;
    if (nfr > 0)
        memcpy(mfcbuf[n_cepfr], temp_mfc[0], nfr * feat_cepsize(fcb) * sizeof(mfcc_t));

    if (mfcfp && (nfr > 0)) {
        fe_mfcc_to_float(fe, temp_mfc, (float32 **) temp_mfc, nfr);
        fwrite(temp_mfc[0], sizeof(float), nfr * feat_cepsize(fcb), mfcfp);
    }
    fe_free_2d(temp_mfc);

    if (livemode) {
        nfr = feat_s2mfc2feat_block(fcb, mfcbuf + n_cepfr, nfr,
                                    uttstart, FALSE,
                                    feat_buf + n_featfr);
        uttstart = FALSE;
        n_cepfr += nfr;
        n_featfr += nfr;

        if (n_searchfr < n_featfr)
            uttproc_frame();

        if (block) {
            while (n_searchfr < n_featfr)
                uttproc_frame();
        }
    }
    else
        n_cepfr += nfr;

    return (n_featfr - n_searchfr);
}

int32
uttproc_cepdata(float32 ** cep, int32 nfr, int32 block)
{
    int32 i, k;

    if (uttstate != UTTSTATE_BEGUN) {
        E_ERROR("uttproc_cepdata called when utterance not begun\n");
        return -1;
    }
    if (inputtype == INPUT_RAW) {
        E_ERROR
            ("uttproc_cepdata mixed with uttproc_rawdata in same utterance??\n");
        return -1;
    }
    inputtype = INPUT_MFC;

    if (utt_ofl)
        return -1;

    k = MAX_UTT_LEN - n_cepfr;
    if (nfr > k) {
        nfr = k;
        utt_ofl = 1;
        E_ERROR("Utterance too long; truncating to about %d frames\n",
                MAX_UTT_LEN);
    }

    for (i = 0; i < nfr; i++) {
#ifdef FIXED_POINT
        int j;
        for (j = 0; j < feat_cepsize(fcb); ++j)
            mfcbuf[n_cepfr + i][j] = FLOAT2FIX(cep[i][j]);
#else
        memcpy(mfcbuf[i + n_cepfr], cep[i], feat_cepsize(fcb) * sizeof(float));
#endif
        if (mfcfp && (nfr > 0))
            fwrite(cep[i], sizeof(float32), feat_cepsize(fcb), mfcfp);
    }

    if (livemode) {
        nfr = feat_s2mfc2feat_block(fcb, mfcbuf + n_cepfr, nfr,
                                    uttstart, FALSE,
                                    feat_buf + n_featfr);
        uttstart = FALSE;
        n_cepfr += nfr;
        n_featfr += nfr;

        if (n_searchfr < n_featfr)
            uttproc_frame();

        if (block) {
            while (n_searchfr < n_featfr)
                uttproc_frame();
        }
    }
    else
        n_cepfr += nfr;

    return (n_featfr - n_searchfr);
}

int32
uttproc_end_utt(void)
{
    int32 i, k, nfr;
    mfcc_t *leftover_cep;

    /* kal */
    leftover_cep = ckd_calloc(feat_cepsize(fcb), sizeof(mfcc_t));

    /* Dump samples histogram */
    k = 0;
    for (i = 0; i < 5; i++)
        k += samp_hist[i];
    if (k > 0) {
        E_INFO("Samples histogram (%s) (4/8/16/30/32K):",
               uttproc_get_uttid());
        for (i = 0; i < 5; i++)
            E_INFOCONT(" %.1f%%(%d)", samp_hist[i] * 100.0 / k,
                       samp_hist[i]);
        E_INFOCONT("; max: %d\n", max_samp);
    }

    if (uttstate != UTTSTATE_BEGUN) {
        E_ERROR("uttproc_end_utt called when utterance not begun\n");
        return -1;
    }

    uttstate = nosearch ? UTTSTATE_IDLE : UTTSTATE_ENDED;

    if (inputtype == INPUT_RAW) {
        fe_end_utt(fe, leftover_cep, &nfr);
        if (nfr && mfcfp) {
            fe_mfcc_to_float(fe, &leftover_cep, &leftover_cep, nfr);
            fwrite(leftover_cep, sizeof(float32), nfr * feat_cepsize(fcb), mfcfp);
        }

        if (livemode) {
            nfr = feat_s2mfc2feat_block(fcb, &leftover_cep, nfr,
                                        uttstart, TRUE,
                                        feat_buf + n_featfr);
            uttstart = FALSE;
            n_featfr += nfr;
        }
        else {
            if (nfr) {
                memcpy(mfcbuf[i + n_cepfr], leftover_cep,
                       nfr * feat_cepsize(fcb) * sizeof(float));
                n_cepfr += nfr;
            }
        }
    }

    /* Do feature computation if not in livemode. */
    if (!livemode) {
        /* If we had file input, n_cepfr will be zero. */
        if (n_cepfr) {
            nfr = feat_s2mfc2feat_block(fcb, mfcbuf, n_cepfr,
                                        TRUE, TRUE, feat_buf);
            n_featfr += nfr;
        }
    }

    /* Do any further searching necessary. */
    if (!nosearch) {
        while (n_searchfr < n_featfr)
            uttproc_frame();
    }

    if (rawfp) {
        fclose(rawfp);
        rawfp = NULL;
    }
    if (mfcfp) {
        int32 k;

        fflush(mfcfp);
        fseek(mfcfp, 0, SEEK_SET);
        k = n_cepfr * feat_cepsize(fcb);
        fwrite(&k, sizeof(int32), 1, mfcfp);

        fclose(mfcfp);
        mfcfp = NULL;
    }

    free(leftover_cep);

    return 0;
}

int32
uttproc_abort_utt(void)
{
    int32 fr;
    char *hyp;

    if (uttproc_end_utt() < 0)
        return -1;

    /* Truncate utterance to the portion already processed */
    n_featfr = n_searchfr;

    uttstate = UTTSTATE_IDLE;

    if (!nosearch) {
        if (fsg_search_mode)
            fsg_search_utt_end(fsg_search);
        else {
            if (cmd_ln_boolean("-fwdtree"))
                search_finish_fwd();
            else
                search_fwdflat_finish();

            search_result(&fr, &hyp);

            write_results(hyp, 1);
        }
        timing_stop(fr);
    }

    return 0;
}

int32
uttproc_stop_utt(void)
{
    if (uttstate != UTTSTATE_BEGUN) {
        E_ERROR("uttproc_stop_utt called when utterance not begun\n");
        return -1;
    }

    uttstate = UTTSTATE_STOPPED;

    if (!nosearch) {
        if (fsg_search_mode)
            fsg_search_utt_end(fsg_search);
        else {
            if (cmd_ln_boolean("-fwdtree"))
                search_finish_fwd();
            else
                search_fwdflat_finish();
        }
    }

    return 0;
}

int32
uttproc_restart_utt(void)
{
    if (uttstate != UTTSTATE_STOPPED) {
        E_ERROR("uttproc_restart_utt called when decoding not stopped\n");
        return -1;
    }

    uttstate = UTTSTATE_BEGUN;

    if (!nosearch) {
        if (fsg_search_mode)
            fsg_search_utt_start(fsg_search);
        else if (cmd_ln_boolean("-fwdtree"))
            search_start_fwd();
        else
            search_fwdflat_start();

        n_searchfr = 0;
        n_searchfr = 0;
    }

    return 0;
}

int32
uttproc_partial_result(int32 * fr, char **hyp)
{
    if ((uttstate != UTTSTATE_BEGUN) && (uttstate != UTTSTATE_ENDED)) {
        E_ERROR("uttproc_partial_result called outside utterance\n");
        *fr = -1;
        *hyp = NULL;
        return -1;
    }

    if (fsg_search_mode) {
        fsg_search_history_backtrace(fsg_search, FALSE);
        search_result(fr, hyp);
    }
    else
        search_partial_result(fr, hyp);

    return 0;
}

int32
uttproc_result(int32 * fr, char **hyp, int32 block)
{
    if (uttstate != UTTSTATE_ENDED) {
        E_ERROR("uttproc_result called when utterance not ended\n");
        *hyp = NULL;
        *fr = -1;

        return -1;
    }

    if (n_searchfr < n_featfr)
        uttproc_frame();

    if (block) {
        while (n_searchfr < n_featfr)
            uttproc_frame();
    }

    if (n_searchfr < n_featfr)
        return (n_featfr - n_searchfr);

    uttproc_windup(fr, hyp);

    return 0;
}

void
uttproc_align(char *sent)
{
    time_align_utterance("alignment", NULL, "<s>", -1, sent, -1, "</s>");
}

void
utt_seghyp_free(search_hyp_t * h)
{
    search_hyp_t *tmp;

    while (h) {
        tmp = h->next;
        listelem_free(h, sizeof(search_hyp_t));
        h = tmp;
    }
}

static void
build_utt_seghyp(void)
{
    int32 i;
    search_hyp_t *seghyp, *last, *new;

    /* Obtain word segmentation result */
    seghyp = search_get_hyp();

    /* Fill in missing details and build segmentation linked list */
    last = NULL;
    for (i = 0; seghyp[i].wid >= 0; i++) {
        new = (search_hyp_t *) listelem_alloc(sizeof(search_hyp_t));
        new->wid = seghyp[i].wid;
        new->word = kb_get_word_str(new->wid);
        new->sf = seghyp[i].sf;
        new->ef = seghyp[i].ef;
        new->latden = seghyp[i].latden;
        new->next = NULL;

        if (!last)
            utt_seghyp = new;
        else
            last->next = new;
        last = new;
    }
}

int32
uttproc_partial_result_seg(int32 * fr, search_hyp_t ** hyp)
{
    char *str;

    /* Free any previous segmentation result */
    utt_seghyp_free(utt_seghyp);
    utt_seghyp = NULL;

    if ((uttstate != UTTSTATE_BEGUN) && (uttstate != UTTSTATE_ENDED)) {
        E_ERROR("uttproc_partial_result called outside utterance\n");
        *fr = -1;
        *hyp = NULL;
        return -1;
    }

    if (fsg_search_mode) {
        fsg_search_history_backtrace(fsg_search, FALSE);
        search_result(fr, &str);
    }
    else
        search_partial_result(fr, &str);        /* Internally makes partial result */

    build_utt_seghyp();
    *hyp = utt_seghyp;

    return 0;
}

int32
uttproc_result_seg(int32 * fr, search_hyp_t ** hyp, int32 block)
{
    char *str;
    int32 res;

    /* Free any previous segmentation result */
    utt_seghyp_free(utt_seghyp);
    utt_seghyp = NULL;

    if ((res = uttproc_result(fr, &str, block)) != 0)
        return res;             /* Not done yet; or ERROR */

    build_utt_seghyp();
    *hyp = utt_seghyp;

    return 0;
}

int32
uttproc_lmupdate(char const *lmname)
{
    lm_t *lm, *cur_lm;

    warn_notidle("uttproc_lmupdate");

    if ((lm = lm_name2lm(lmname)) == NULL)
        return -1;

    cur_lm = lm_get_current();
    if (lm == cur_lm)
        search_set_current_lm();

    return 0;
}

int32
uttproc_set_context(char const *wd1, char const *wd2)
{
    int32 w1, w2;

    warn_notidle("uttproc_set_context");

    if (wd1) {
        w1 = kb_get_word_id(wd1);
        if ((w1 < 0) || (!dictwd_in_lm(w1))) {
            E_ERROR("Unknown word: %s\n", wd1);
            search_set_context(-1, -1);

            return -1;
        }
    }
    else
        w1 = -1;