uttproc.c

WinCE平台上的语音识别程序

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

            return -1;
        }
    }
    else
        w2 = -1;

    if (w2 < 0) {
        search_set_context(-1, -1);
        return ((w1 >= 0) ? -1 : 0);
    }
    else {
        /* Because of the perverse way search_set_context was defined... */
        if (w1 < 0)
            search_set_context(w2, -1);
        else
            search_set_context(w1, w2);
    }

    return 0;
}

int32
uttproc_set_lm(char const *lmname)
{
    warn_notidle("uttproc_set_lm");

    if (lmname == NULL) {
        E_ERROR("uttproc_set_lm called with NULL argument\n");
        return -1;
    }

    if (lm_set_current(lmname) < 0)
        return -1;

    fsg_search_mode = FALSE;

    search_set_current_lm();

    E_INFO("LM= \"%s\"\n", lmname);

    return 0;
}


int32
uttproc_load_fsg(s2_fsg_t * fsg,
                 int32 use_altpron,
                 int32 use_filler,
                 float32 silprob, float32 fillprob, float32 lw)
{
    word_fsg_t *word_fsg;

    word_fsg =
        word_fsg_load(fsg, use_altpron, use_filler, silprob, fillprob, lw);

    if (!word_fsg)
        return 0;

    if (!fsg_search_add_fsg(fsg_search, word_fsg)) {
        E_ERROR("Failed to add FSG '%s' to system\n",
                word_fsg_name(word_fsg));
        word_fsg_free(word_fsg);
        return 0;
    }

    return 1;
}


char *
uttproc_load_fsgfile(char *fsgfile)
{
    word_fsg_t *fsg;

    fsg = word_fsg_readfile(fsgfile,
                            cmd_ln_boolean("-fsgusealtpron"),
                            cmd_ln_boolean("-fsgusefiller"),
                            cmd_ln_float32("-silpen"),
                            cmd_ln_float32("-fillpen"),
                            cmd_ln_float32("-lw"));
    if (!fsg)
        return NULL;

    if (!fsg_search_add_fsg(fsg_search, fsg)) {
        E_ERROR("Failed to add FSG '%s' to system\n", word_fsg_name(fsg));
        word_fsg_free(fsg);
        return NULL;
    }

    return fsg->name;
}


int32
uttproc_del_fsg(char *fsgname)
{
    warn_notidle("uttproc_del_fsg");

    if (fsgname == NULL) {
        E_ERROR("uttproc_del_fsg called with NULL argument\n");
        return -1;
    }

    if (!fsg_search_del_fsg_byname(fsg_search, fsgname))
        return -1;

    return 0;
}


int32
uttproc_set_fsg(char *fsgname)
{
    warn_notidle("uttproc_set_fsg");

    if (fsgname == NULL) {
        E_ERROR("uttproc_set_fsg called with NULL argument\n");
        return -1;
    }

    if (!fsg_search_set_current_fsg(fsg_search, fsgname))
        return -1;

    fsg_search_mode = TRUE;

    E_INFO("FSG= \"%s\"\n", fsgname);

    return 0;
}



int32
uttproc_get_fsg_start_state(void)
{
    return fsg_search_get_start_state(fsg_search);
}


int32
uttproc_get_fsg_final_state(void)
{
    return fsg_search_get_final_state(fsg_search);
}


int32
uttproc_set_fsg_start_state(int32 state)
{
    return fsg_search_set_start_state(fsg_search, state);
}


int32
uttproc_set_fsg_final_state(int32 state)
{
    return fsg_search_set_final_state(fsg_search, state);
}


boolean
uttproc_fsg_search_mode(void)
{
    return fsg_search_mode;
}


int32
uttproc_set_rescore_lm(char const *lmname)
{
    searchlat_set_rescore_lm(lmname);
    return 0;
}

int32
uttproc_set_startword(char const *str)
{
    warn_notidle("uttproc_set_startword");

    search_set_startword(str);
    return 0;
}

void
uttproc_set_feat(feat_t *new_fcb)
{
    if (fcb)
        feat_free(fcb);
    fcb = new_fcb;
    feat_alloc();
}

#if 0
int32
uttproc_set_uttid(char const *id)
{
    warn_notidle("uttproc_set_uttid");

    assert(strlen(id) < UTTIDSIZE);
    strcpy(uttid, id);

    return 0;
}
#endif

char const *
uttproc_get_uttid(void)
{
    return uttid;
}

int32
uttproc_set_auto_uttid_prefix(char const *prefix)
{
    if (uttid_prefix)
        free(uttid_prefix);
    uttid_prefix = ckd_salloc(prefix);
    uttno = 0;

    return 0;
}

void
uttproc_cepmean_set(mfcc_t * cep)
{
    warn_notidle("uttproc_cepmean_set");
    cmn_prior_set(fcb->cmn_struct, cep);
}

void
uttproc_cepmean_get(mfcc_t * cep)
{
    cmn_prior_get(fcb->cmn_struct, cep);
}

void
uttproc_agcemax_set(float32 c0max)
{
    warn_notidle("uttproc_agcemax_set");
    agc_emax_set(fcb->agc_struct, c0max);
}

float32
uttproc_agcemax_get(void)
{
    return agc_emax_get(fcb->agc_struct);
}

int32
uttproc_nosearch(int32 flag)
{
    warn_notidle("uttproc_nosearch");

    nosearch = flag;
    return 0;
}

int32
uttproc_set_rawlogdir(char const *dir)
{
    warn_notidle("uttproc_set_rawlogdir");

    if (!rawlogdir) {
        if ((rawlogdir = calloc(1024, 1)) == NULL) {
            E_ERROR("calloc(1024,1) failed\n");
            return -1;
        }
    }
    if (rawlogdir)
        strcpy(rawlogdir, dir);

    return 0;
}

int32
uttproc_set_mfclogdir(char const *dir)
{
    warn_notidle("uttproc_set_mfclogdir");

    if (!mfclogdir) {
        if ((mfclogdir = calloc(1024, 1)) == NULL) {
            E_ERROR("calloc(1024,1) failed\n");
            return -1;
        }
    }
    if (mfclogdir)
        strcpy(mfclogdir, dir);

    return 0;
}

int32
uttproc_parse_ctlfile_entry(char *line,
                            char *filename, int32 * sf, int32 * ef,
                            char *idspec)
{
    int32 k;

    /* Default; process entire file */
    *sf = 0;
    *ef = -1;

    if ((k = sscanf(line, "%s %d %d %s", filename, sf, ef, idspec)) <= 0)
        return -1;

    if (k == 1)
        strcpy(idspec, filename);
    else {
        if ((k == 2) || (*sf < 0) || (*ef <= *sf)) {
            E_ERROR("Bad ctlfile entry: %s\n", line);
            return -1;
        }
        if (k == 3)
            sprintf(idspec, "%s_%d_%d", filename, *sf, *ef);
    }

    return 0;
}

/* Return #frames converted to feature vectors; -1 if error */
int32
uttproc_file2feat(const char *utt, int32 sf, int32 ef, int32 nosearch)
{
    FILE *uttfp;
    char *utt_name;

    utt_name = build_uttid(utt);

    if (cmd_ln_boolean("-adcin")) {
        int16 *adbuf;
        int32 k;

        inputtype = INPUT_RAW;
        if ((uttfp = adcfile_open(utt)) == NULL)
            return -1;

        if (uttproc_nosearch(nosearch) < 0)
            return -1;

        if (uttproc_begin_utt(utt_name) < 0)
            return -1;

        adbuf = ckd_calloc(4096, sizeof(int16));
        while ((k = adc_file_read(uttfp, adbuf, 4096)) >= 0) {
            if (uttproc_rawdata(adbuf, k, 1) < 0) {
                ckd_free(adbuf);
                return -1;
            }
        }
        ckd_free(adbuf);

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

        return n_featfr;
    }
    else {
        if (uttproc_nosearch(nosearch) < 0)
            return -1;

        if (uttproc_begin_utt(utt_name) < 0)
            return -1;

        n_cepfr = 0;
        n_featfr = feat_s2mfc2feat(fcb, utt,
                                   cmd_ln_str("-cepdir"),
                                   cmd_ln_str("-cepext"),
                                   sf, ef, feat_buf, MAX_UTT_LEN);

        if (nosearch == FALSE) {
            while (n_searchfr < n_featfr)
                uttproc_frame();
        }

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

        return n_featfr;
    }
}

search_hyp_t *
uttproc_allphone_file(char const *utt)
{
    int32 nfr;
    search_hyp_t *hyplist, *h;
    extern search_hyp_t * allphone_utt(int32 nfr, mfcc_t ***feat_buf);

    if ((nfr = uttproc_file2feat(utt, 0, -1, 1)) < 0)
        return NULL;

    hyplist = allphone_utt(nfr, feat_buf);

    /* Write match and matchseg files if needed */
    if (matchfp) {
        for (h = hyplist; h; h = h->next)
            fprintf(matchfp, "%s ", h->word);
        fprintf(matchfp, "(%s)\n", uttid);
        fflush(matchfp);
    }
    if (matchsegfp) {
        fprintf(matchsegfp, "%s ", uttid);
        for (h = hyplist; h; h = h->next)
            fprintf(matchsegfp, " %d %d %s", h->sf, h->ef, h->word);
        fprintf(matchsegfp, "\n");
        fflush(matchsegfp);
    }

    return hyplist;
}

static FILE *logfp;
static char logfile[MAXPATHLEN]; /* FIXME buffer */
int32
uttproc_set_logfile(char const *file)
{
    FILE *fp;

    E_INFO("uttproc_set_logfile(%s)\n", file);

    if ((fp = fopen(file, "w")) == NULL) {
        E_ERROR("fopen(%s,w) failed; logfile unchanged\n", file);
        return -1;
    }
    else {
        if (logfp)
            fclose(logfp);

        logfp = fp;
        /* 
         * Rolled back the dup2() bug fix for windows only. In
         * Microsoft Visual C, dup2 seems to cause problems in some
         * applications: the files are opened, but nothing is written
         * to it.
         */
#if defined(_WIN32) || defined(GNUWINCE)
#ifndef _WIN32_WCE /* FIXME: Possible? */
        *stdout = *logfp;
        *stderr = *logfp;
#endif
#else
        dup2(fileno(logfp), 1);
        dup2(fileno(logfp), 2);
#endif

        E_INFO("Previous logfile: '%s'\n", logfile);
        strcpy(logfile, file);
    }

    return 0;
}