/* * Wait for the user to type a <CR> then capture input audio for approx. 2 sec * and compute a measure of its power. */ int main (int32 argc, char *argv[]) { char line[1024]; ad_rec_t *ad; int16 buf[1000]; int32 sps; sps = DEFAULT_SAMPLES_PER_SEC; if ((ad = ad_open_sps (sps)) == NULL) E_FATAL("ad_open_sps failed\n"); for (;;) { printf ("Hit <CR> to measure A/D power; Q<CR> to quit: "); fgets (line, sizeof(line), stdin); if ((line[0] == 'q') || (line[0] == 'Q')) break; ad_start_rec (ad); adpow(ad); ad_stop_rec (ad); while (ad_read (ad, buf, 1000) >= 0); /* Flush any buffered, unread data */ } ad_close (ad); return 0; }
/** * Reads all the N-grams in the given N-gram file into the array of strings. * * args: * ngrams_file - the N-gram file to read N-grams from * ngrams - the array of string to read N-grams into * * returns: the number of ngrams read */ int read_ngrams(char *ngrams_file, char **ngrams, s3lmwid32_t * wid[], int32 nwords[], int max_lines, lm_t * lm) { FILE *fp; char line_read[MAX_STRLEN]; int n, length; if ((fp = fopen(ngrams_file, "r")) == NULL) { E_FATAL("Unable to open N-gram file %s\n", ngrams_file); } n = 0; /* read each line in the file into the ngrams array */ while (fgets(line_read, MAX_STRLEN, fp) != NULL) { if (n < max_lines) { length = strlen(line_read); line_read[length - 1] = '\0'; ngrams[n] = (char *) ckd_calloc(length, sizeof(char)); strncpy(ngrams[n], line_read, length - 1); wid[n] = (s3lmwid32_t *) ckd_calloc(3, sizeof(s3lmwid32_t)); nwords[n] = ngram2wid(line_read, length, wid[n], lm); n++; } else { break; } } return n; }
static int read_seno_cluster(int32 **seno_cluster, const char *seno_dir, const char *base_name, const char **ext, uint32 n_weights) { unsigned int f; int n_read; char seno_filename[MAXPATHLEN]; E_INFO("reading mixing weights for %s\n", base_name); for (f = 0; f < S2_N_FEATURE; f++) { sprintf(seno_filename, "%s/%s.%s", seno_dir, base_name, ext[f]); areadint(seno_filename, &seno_cluster[f], &n_read); if (n_read != n_weights) { E_FATAL("expected %d weights in %s but got %d\n", n_weights, seno_filename, n_read); } } return S3_SUCCESS; }
void agc(float32 *mfcc, uint32 n_frame) { const char *agc_type = cmd_ln_access("-agc"); uint32 i; if (strcmp(agc_type, "noise") == 0) { real_agc_noise(mfcc, n_frame, veclen); } else if (strcmp(agc_type, "max") == 0) { agc_max(mfcc, n_frame, veclen); } else if (strcmp(agc_type, "emax") == 0) { for (i = 0; i < n_frame; i++) { agc_emax_proc(&mfcc[i*veclen], &mfcc[i*veclen], veclen); } } else if (strcmp(agc_type, "none") == 0) { /* do nothing */ } else if (agc_type == NULL) { E_WARN("no agc set\n"); return ; } else { E_FATAL("unsupported agc type %s\n", agc_type); } }
void listelem_free(void *elem, int32 elemsize) { char **cpp; list_t *prev, *list; /* Find list for elemsize */ prev = NULL; for (list = head; list && (list->elemsize != elemsize); list = list->next) prev = list; if (!list) { E_FATAL("Unknown list item size: %d\n", elemsize); } else if (prev) { /* List found; move entry to head of list */ prev->next = list->next; list->next = head; head = list; } /* * Insert freed item at head of list. * NOTE: skipping check for size being multiple of (void *). */ cpp = (char **) elem; *cpp = (char *) list->freelist; list->freelist = cpp; (list->n_freed)++; }
static void recognize_from_microphone() { ad_rec_t *ad; int16 adbuf[2048]; uint8 utt_started, in_speech; int32 k; char const *hyp; if ((ad = ad_open_dev(AUDIO_DEVICE_NAME, (int) SAMPLE_RATE )) == NULL) { E_FATAL("Failed to open audio device\n"); } if (ad_start_rec(ad) < 0) { E_FATAL("Failed to start recording\n"); } if (ps_start_utt(ps) < 0) { E_FATAL("Failed to start utterance\n"); } utt_started = FALSE; printf("READY....\n"); for (;;) { if ((k = ad_read(ad, adbuf, 2048)) < 0) E_FATAL("Failed to read audio\n"); ps_process_raw(ps, adbuf, k, FALSE, FALSE); in_speech = ps_get_in_speech(ps); if (in_speech && !utt_started) { utt_started = TRUE; printf("Listening...\n"); } if (!in_speech && utt_started) { /* speech -> silence transition, time to start new utterance */ ps_end_utt(ps); hyp = ps_get_hyp(ps, NULL ); if (hyp != NULL) printf("%s\n", hyp); if (ps_start_utt(ps) < 0) E_FATAL("Failed to start utterance\n"); utt_started = FALSE; printf("READY....\n"); } sleep_msec(100); } ad_close(ad); }
/* * Record A/D data for approximately specified number of seconds into specified file. */ int main (int32 argc, char *argv[]) { char line[1024]; ad_rec_t *ad; int16 buf[1000]; int32 len, k, sps; FILE *fp; if ((argc != 4) || (sscanf (argv[1], "%d", &sps) != 1) || (sscanf (argv[2], "%d", &len) != 1)) { E_FATAL("Usage: %s <sampling-rate> <#sec-to-record> <output-file>\n", argv[0]); } if ((fp = fopen (argv[3], "wb")) == NULL) E_FATAL("fopen(%s,wb) failed\n", argv[3]); len *= sps; /* Convert to min. #samples to record */ if ((ad = ad_open_sps (sps)) == NULL) E_FATAL("ad_open_sps(%d) failed\n", sps); printf ("Hit <CR> to start recording\n"); fgets (line, sizeof(line), stdin); ad_start_rec (ad); /* Record desired no. of samples */ while (len > 0) { /* Read A/D */ if ((k = ad_read (ad, buf, 1000)) < 0) E_FATAL("ad_read returned %d\n", k); /* Write data read, if any, to file (ad_read may return 0 samples) */ if (k > 0) { fwrite (buf, sizeof(int16), k, fp); fflush (fp); len -= k; } } ad_stop_rec (ad); ad_close (ad); fclose (fp); return 0; }
static void subvq_map_compact (subvq_t *vq, mgau_model_t *g) { int32 r, c, c2, s; if (g) { if ((g->n_mgau != vq->origsize.r) || (g->max_comp != vq->origsize.c)) E_FATAL("Model size conflict: %d x %d (SubVQ) vs %d x %d (Original)\n", vq->origsize.r, vq->origsize.c, g->n_mgau, g->max_comp); } /* * Compress map entries by removing invalid ones. NOTE: There's not much of a consistency * check to ensure that the entries remaining do map correctly on to the valid entries in * the original (parent) mixture Gaussian model g. The only check we have is to verify * the NUMBER of valid entries (components) in each mixture. */ for (r = 0; r < vq->origsize.r; r++) { for (c = 0, c2 = 0; c < vq->origsize.c; c++) { if (vq->map[r][c][0] < 0) { /* All ought to be < 0 */ for (s = 1; s < vq->n_sv; s++) { if (vq->map[r][c][s] >= 0) E_FATAL("Partially undefined map[%d][%d]\n", r, c); } } else { if (c2 != c) { for (s = 0; s < vq->n_sv; s++) { if (vq->map[r][c][s] < 0) E_FATAL("Partially undefined map[%d][%d]\n", r, c); vq->map[r][c2][s] = vq->map[r][c][s]; } } c2++; } } if (g && (c2 != mgau_n_comp (g, r))) E_FATAL("Mixture %d: #Valid components conflict: %d (SubVQ) vs %d (Original)\n", r, c2, mgau_n_comp(g,r)); /* Invalidate the remaining map entries, for good measure */ for (; c2 < vq->origsize.c; c2++) { for (s = 0; s < vq->n_sv; s++) vq->map[r][c2][s] = -1; } } }
static void parse_base_line(mdef_t * m, char *line, int p) { int32 wlen, n; __BIGSTACKVARIABLE__ char word[1024], *lp; int ci; lp = line; /* Read base phone name */ if (sscanf(lp, "%s%n", word, &wlen) != 1) E_FATAL("Missing base phone name: %s\n", line); lp += wlen; /* Make sure it's not a duplicate */ ci = mdef_ciphone_id(m, word); if (ci >= 0) E_FATAL("Duplicate base phone: %s\n", line); /* Add ciphone to ciphone table with id p */ ciphone_add(m, word, p); ci = (int) p; /* Read and skip "-" for lc, rc, wpos */ for (n = 0; n < 3; n++) { if ((sscanf(lp, "%s%n", word, &wlen) != 1) || (strcmp(word, "-") != 0)) E_FATAL("Bad context info for base phone: %s\n", line); lp += wlen; } /* Read filler attribute, if present */ if (sscanf(lp, "%s%n", word, &wlen) != 1) E_FATAL("Missing filler atribute field: %s\n", line); lp += wlen; if (strcmp(word, "filler") == 0) m->ciphone[(int) ci].filler = 1; else if (strcmp(word, "n/a") == 0) m->ciphone[(int) ci].filler = 0; else E_FATAL("Bad filler attribute field: %s\n", line); triphone_add(m, ci, -1, -1, WORD_POSN_UNDEFINED, p); /* Parse remainder of line: transition matrix and state->senone mappings */ parse_tmat_senmap(m, line, lp - line, p); }
void phone_add_diphones (void) /*------------------------* * DESCRIPTION - figure out what the word begin/end diphones of intrest are * and add them to the phone set. */ { int32 phone_cnt = phone_count(); int32 pid; int32 ret; int32 new_phone_id = phone_cnt; char tp[64]; char ci[32], lc[64], rc[64], pc[64]; for (pid = 0; pid < phone_cnt; pid++) { strcpy (tp, phone_from_id (pid)); ret = parse_triphone (tp, ci, lc, rc, pc); if (ret == 4) { switch (pc[0]) { case 'b': sprintf (tp, "%s(%%s,%s)b", ci, rc); if (phone_to_id (tp, FALSE) == NO_PHONE) { add_phone (tp, new_phone_id, phone_to_id(ci, TRUE), PT_DIPHONE, 1); new_phone_id++; } break; case 'e': sprintf (tp, "%s(%s,%%s)e", ci, lc); if (phone_to_id (tp, FALSE) == NO_PHONE) { add_phone (tp, new_phone_id, phone_to_id(ci, TRUE), PT_DIPHONE, 1); new_phone_id++; } break; case 's': sprintf (tp, "%s(%%s,%%s)s", ci); if (phone_to_id (tp, FALSE) == NO_PHONE) { add_phone (tp, new_phone_id, phone_to_id(ci, TRUE), PT_DIPHONE_S, 1); new_phone_id++; } break; case '\0': break; default: E_FATAL("Unknown position context in %s == '%c'\n", tp, pc[0]); } } } /* * Remake the phone map to account for the diphones */ mk_phone_map (); E_INFO("Added %d new begin/end word diphones\n", new_phone_id - phone_cnt); }
float32 gs_fread_float32(gs_t * gs) { float32 val; if (fread(&val, sizeof(float32), 1, gs->fp) != 1) E_FATAL("fread failed\n"); return (val); }
static void read_1rule(s3_cfg_t *_cfg, FILE *_file, float32 *_score, s3_cfg_id_t *_src, s3_cfg_id_t *_products) { char name[S3_CFG_MAX_ITEM_STR_LEN + 1]; float32 score; s3_cfg_id_t src; s3_cfg_id_t products[S3_CFG_MAX_ITEM_COUNT + 1]; s3_cfg_id_t item; char format[1024]; int len; int i; assert(_cfg != NULL); assert(_file != NULL); sprintf(format, "%%%ds", S3_CFG_MAX_ITEM_STR_LEN); /* read the prior */ if (fscanf(_file, "%f", &score) != 1 || score < 0) E_FATAL("Bad CFG production rule\n"); /* read the source */ if (fscanf(_file, format, name) != 1) E_FATAL("Bad CFG production rule\n"); src = s3_cfg_str2id(_cfg, name); if (src == S3_CFG_INVALID_ID) E_FATAL("Bad CFG production rule\n"); if (s3_cfg_is_terminal(src)) E_FATAL("Bad CFG production rule\n"); if (fscanf(_file, "%d", &len) != 1) E_FATAL("Bad CFG production rule\n"); if (len > S3_CFG_MAX_ITEM_COUNT) E_FATAL("CFG Production rule too long\n"); /* read the products */ for (i = 0; i < len; i++) { if (fscanf(_file, format, name) != 1) E_FATAL("Bad CFG production rule\n"); item = s3_cfg_str2id(_cfg, name); if (item == S3_CFG_INVALID_ID) E_FATAL("Bad CFG production term\n"); products[i] = item; } products[len] = S3_CFG_EOR_ITEM; *_src = src; *_score = score; memcpy(_products, products, (len + 1) * sizeof(s3_cfg_id_t)); }
float fe_warp_unwarped_to_warped(melfb_t *mel,float linear) { if (mel->warp_id <= FE_WARP_ID_MAX) { return fe_warp_conf[mel->warp_id].unwarped_to_warped(linear); } else if (mel->warp_id == FE_WARP_ID_NONE) { E_FATAL("fe_warp module must be configured w/ a valid ID\n"); } else { E_FATAL ("fe_warp module misconfigured with invalid fe_warp_id %u\n", mel->warp_id); } return 0; }
int main(int argc, char *argv[]) { cmd_ln_t *config; ngram_model_t *lm = NULL; logmath_t *lmath; const char *lmfn, *probdefn, *lsnfn, *text; if ((config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE)) == NULL) return 1; verbose = cmd_ln_boolean_r(config, "-verbose"); /* Create log math object. */ if ((lmath = logmath_init (cmd_ln_float64_r(config, "-logbase"), 0, 0)) == NULL) { E_FATAL("Failed to initialize log math\n"); } /* Load the language model. */ lmfn = cmd_ln_str_r(config, "-lm"); if (lmfn == NULL || (lm = ngram_model_read(config, lmfn, NGRAM_AUTO, lmath)) == NULL) { E_FATAL("Failed to load language model from %s\n", cmd_ln_str_r(config, "-lm")); } if ((probdefn = cmd_ln_str_r(config, "-probdef")) != NULL) ngram_model_read_classdef(lm, probdefn); ngram_model_apply_weights(lm, cmd_ln_float32_r(config, "-lw"), cmd_ln_float32_r(config, "-wip"), cmd_ln_float32_r(config, "-uw")); /* Now evaluate some text. */ lsnfn = cmd_ln_str_r(config, "-lsn"); text = cmd_ln_str_r(config, "-text"); if (lsnfn) { evaluate_file(lm, lmath, lsnfn); } else if (text) { evaluate_string(lm, lmath, text); } return 0; }
const char * fe_warp_doc(melfb_t *mel) { if (mel->warp_id <= FE_WARP_ID_MAX) { return fe_warp_conf[mel->warp_id].doc(); } else if (mel->warp_id == FE_WARP_ID_NONE) { E_FATAL("fe_warp module must be configured w/ a valid ID\n"); } else { E_FATAL ("fe_warp module misconfigured with invalid fe_warp_id %u\n", mel->warp_id); } return NULL; }
uint32 fe_warp_n_param(melfb_t *mel) { if (mel->warp_id <= FE_WARP_ID_MAX) { return fe_warp_conf[mel->warp_id].n_param(); } else if (mel->warp_id == FE_WARP_ID_NONE) { E_FATAL("fe_warp module must be configured w/ a valid ID\n"); } else { E_FATAL ("fe_warp module misconfigured with invalid fe_warp_id %u\n", mel->warp_id); } return 0; }
static void homfile_load (char *file) { FILE *fp; char line[16380], w1[4096], w2[4096]; int32 k, n; s3wid_t wid1, wid2; s3cipid_t ci[1]; hom_t *h; E_INFO("Reading homophones file %s\n", file); if ((fp = fopen(file, "r")) == NULL) E_FATAL("fopen(%s,r) failed\n", file); ci[0] = (s3cipid_t) 0; /* Dummy */ n = 0; while (fgets (line, sizeof(line), fp) != NULL) { if ((k = sscanf (line, "%s %s", w1, w2)) == 2) { wid1 = dict_wordid (dict, w1); if (NOT_WID(wid1)) { E_INFO("Adding %s to dictionary\n", w1); wid1 = dict_add_word (dict, w1, ci, 1); if (NOT_WID(wid1)) E_FATAL("dict_add_word(%s) failed\n", w1); } wid2 = dict_wordid (dict, w2); if ((NOT_WID(wid2)) || (wid2 >= oovbegin)) E_FATAL("%s not in dictionary\n", w2); h = (hom_t *) listelem_alloc (sizeof(hom_t)); h->w1 = wid1; h->w2 = wid2; h->next = homlist; homlist = h; n++; } else E_FATAL("Bad homophones line: %s\n", line); } E_INFO("%d homophone pairs read\n", n); fclose (fp); }
uint32 feat_n_stream() { if (sv.subvecs != NULL) { return sv.n_sv; } else if (fid <= FEAT_ID_MAX) { return feat_conf[fid].n_stream(); } else if (fid == FEAT_ID_NONE) { E_FATAL("feat module must be configured w/ a valid ID\n"); } else { E_FATAL("feat module misconfigured with invalid feat_id %u\n", fid); } return 0; }
static int read_audio_file(int16 * buf, int len) { if (!infile) { E_FATAL("Failed to read audio from file\n"); return -1; } return fread(buf, sizeof(int16), len, infile); }
static void evaluate_file(ngram_model_t *lm, logmath_t *lmath, const char *lsnfn) { FILE *fh; lineiter_t *litor; int32 nccs, noovs, nwords, lscr; float64 ch, log_to_log2;; if ((fh = fopen(lsnfn, "r")) == NULL) E_FATAL_SYSTEM("failed to open transcript file %s", lsnfn); /* We have to keep ch in floating-point to avoid overflows, so * we might as well use log2. */ log_to_log2 = log(logmath_get_base(lmath)) / log(2); lscr = nccs = noovs = nwords = 0; ch = 0.0; for (litor = lineiter_start(fh); litor; litor = lineiter_next(litor)) { char **words; int32 n, tmp_ch, tmp_noovs, tmp_nccs, tmp_lscr; n = str2words(litor->buf, NULL, 0); if (n < 0) E_FATAL("str2words(line, NULL, 0) = %d, should not happen\n", n); if (n == 0) /* Do nothing! */ continue; words = ckd_calloc(n, sizeof(*words)); str2words(litor->buf, words, n); /* Remove any utterance ID (FIXME: has to be a single "word") */ if (words[n-1][0] == '(' && words[n-1][strlen(words[n-1])-1] == ')') n = n - 1; tmp_ch = calc_entropy(lm, words, n, &tmp_nccs, &tmp_noovs, &tmp_lscr); ch += (float64) tmp_ch * (n - tmp_nccs - tmp_noovs) * log_to_log2; nccs += tmp_nccs; noovs += tmp_noovs; lscr += tmp_lscr; nwords += n; ckd_free(words); } ch /= (nwords - nccs - noovs); printf("cross-entropy: %f bits\n", ch); /* Calculate perplexity pplx = exp CH */ printf("perplexity: %f\n", pow(2.0, ch)); printf("lm score: %d\n", lscr); /* Report OOVs and CCs */ printf("%d words evaluated\n", nwords); printf("%d OOVs (%.2f%%), %d context cues removed\n", noovs, (double)noovs / nwords * 100, nccs); }
int main(int argc, char *argv[]) { parse_cmd_ln(argc, argv); if(rd_parm()==S3_ERROR) { E_FATAL("Problem in reading input parameters.\n"); } if(cp_parm()==S3_ERROR) { E_FATAL("Problem in copying parameters.\n"); } if(wr_parm()==S3_ERROR) { E_FATAL("Problem in writing output parameters.\n"); } return 0; }
int32 gauden_mean_reload (gauden_t *g, char *meanfile) { int32 i, m, f, d, *flen; assert (g->mean != NULL); gauden_param_read (&(g->mean), &m, &f, &d, &flen, meanfile); /* Verify original and new mean parameter dimensions */ if ((m != g->n_mgau) || (f != g->n_feat) || (d != g->n_density)) E_FATAL("Mixture-gaussians dimensions for original and new means differ\n"); for (i = 0; i < g->n_feat; i++) if (g->featlen[i] != flen[i]) E_FATAL("Feature lengths for original and new means differ\n"); ckd_free (flen); return 0; }
bool Theme::load(const char *f) { E_RETURN_VAL_IF_FAIL(f != NULL, false); /* do not allow loading if clear() wasn't called before */ E_RETURN_VAL_IF_FAIL(priv->sc == NULL, false); priv->is_loaded = false; init_interpreter(); scheme *ss = priv->sc; /* * Determine from which directory we loads file, and set that file as base directory * where '(include)' statement can search additional files. Include uses 'private::theme.search-path'. */ char *path = edelib_strndup(f, PATH_MAX); if(!path) E_FATAL(E_STRLOC ": No memory\n"); char *dir = local_dirname(path); /* If returned name is the same as file, dirname wasn't found directory name in given path. */ if(strcmp(dir, f) != 0) { pointer sym = mk_symbol(ss, "private:theme.search-path"); edelib_scheme_define(ss, ss->global_env, sym, mk_string(ss, dir)); ss->vptr->setimmutable(sym); } /* scheme copies path, so we do not need it any more */ free(path); FILE *fd = fopen(f, "r"); if(!fd) { edelib_scheme_deinit(ss); free(ss); priv->sc = 0; return false; } edelib_scheme_load_named_file(ss, fd, f); fclose(fd); if(ss->no_memory) { E_WARNING(E_STRLOC ": No memory to load theme source in interpreter\n"); return false; } if(ss->retcode != 0) return false; /* fetch common variables */ priv->name = get_string_var(ss, "private:theme.name"); priv->author = get_string_var(ss, "private:theme.author"); priv->sample = get_string_var(ss, "private:theme.sample"); priv->is_loaded = true; return true; }
void *__ckd_malloc__(size_t size, const char *caller_file, int caller_line) { void *mem; if ((mem = malloc(size)) == NULL) E_FATAL("malloc(%d) failed from %s(%d)\n", size, caller_file, caller_line); return mem; }
int main (int argc, char *argv[]) { short *samps; int i, j, buflen, endutt, blksize, nhypwds, nsamp; char *argsfile, *ctlfile, *indir; char filename[512], cepfile[512]; partialhyp_t *parthyp; FILE *fp, *sfp; if (argc != 4) E_FATAL("\nUSAGE: %s <ctlfile> <inrawdir> <argsfile>\n",argv[0]); ctlfile = argv[1]; indir = argv[2]; argsfile = argv[3]; samps = (short *) calloc(MAXSAMPLES,sizeof(short)); blksize = 2000; if ((fp = fopen(ctlfile,"r")) == NULL) E_FATAL("Unable to read %s\n",ctlfile); live_initialize_decoder(argsfile); while (fscanf(fp,"%s",filename) != EOF){ sprintf(cepfile,"%s/%s.raw",indir,filename); if ((sfp = fopen(cepfile,"rb")) == NULL) E_FATAL("Unable to read %s\n",cepfile); nsamp = fread(samps, sizeof(short), MAXSAMPLES, sfp); fprintf(stdout,"%d samples in file %s.\nWill be decoded in blocks of %d\n",nsamp,cepfile,blksize); fflush(stdout); fclose(sfp); for (i=0;i<nsamp;i+=blksize){ buflen = i+blksize < nsamp ? blksize : nsamp-i; endutt = i+blksize <= nsamp-1 ? 0 : 1; nhypwds = live_utt_decode_block(samps+i,buflen,endutt,&parthyp); E_INFO("PARTIAL HYP:"); if (nhypwds > 0) for (j=0; j < nhypwds; j++) fprintf(stderr," %s",parthyp[j].word); fprintf(stderr,"\n"); } } return 0; }
static void ciphone_add(mdef_t * m, const char *ci, s3pid_t p) { assert(p < m->n_ciphone); m->ciphone[p].name = (char *) ckd_salloc(ci); /* freed in mdef_free */ if (hash_table_enter(m->ciphone_ht, m->ciphone[p].name, (void *)(long)p) != (void *)(long)p) E_FATAL("hash_table_enter(%s) failed; duplicate CIphone?\n", m->ciphone[p].name); }
int32 line2wid (dict_t *dict, char *line, s3wid_t *wid, int32 max_n_wid, int32 add_oov, char *uttid) { char *lp, word[1024]; int32 n, k; s3wid_t w; s3cipid_t ci[1]; uttid[0] = '\0'; ci[0] = (s3cipid_t) 0; lp = line; n = 0; while (sscanf (lp, "%s%n", word, &k) == 1) { lp += k; if (n >= max_n_wid) return -n; if (is_uttid (word, uttid)) break; wid[n] = dict_wordid (dict, word); /* Up to caller to handle BAD_WIDs */ if (NOT_WID(wid[n])) { /* OOV word */ if (add_oov) { E_INFO("Adding %s to dictionary\n", word); wid[n] = dict_add_word (dict, word, NULL, 0); if (NOT_WID(wid[n])) E_FATAL("dict_add_word(%s) failed for line: %s\n", word, line); } else E_FATAL("Unknown word (%s) in line: %s\n", word, line); } n++; } if (sscanf (lp, "%s", word) == 1) /* Check that line really ended */ E_WARN("Nonempty data ignored after uttid(%s) in line: %s\n", uttid, line); return n; }
/* * Return ptr WITHIN path (i.e., not a copy) of the base filename. * FATAL error if path ends in a /. */ static char *path2basename (char *path) { int32 i; for (i = strlen(path)-1; (i >= 0) && (path[i] != '/'); --i); i++; if (path[i] == '/') E_FATAL("Path %s has no basename\n", path); return (path + i); }
/* the main() function is modified for MMIE training lqin 2010-03 */ int main(int argc, char *argv[]) { if (initialize(argc, argv) != S3_SUCCESS) { E_FATAL("errors initializing.\n"); } if (cmd_ln_int32("-mmie")) { if (mmi_normalize() != S3_SUCCESS) { E_FATAL("errors mmie normalizing.\n"); } } else { if (normalize() != S3_SUCCESS) { E_FATAL("errors normalizing.\n"); } } return 0; }
static void parse_ctl_line(char *line, char **path, uint32 *sf, uint32 *ef, char **id) { char *sp; char sv_line[4192]; strcpy(sv_line, line); sp = strchr(sv_line, ' '); if (sp == NULL) { /* 'old' style control file */ if (path) *path = strdup(sv_line); if (sf) *sf = NO_FRAME; if (ef) *ef = NO_FRAME; if (id) *id = NULL; } else { *sp = '\0'; if (path) *path = strdup(sv_line); /* at least one space, so try to parse rest of line */ if (sf != NULL) *sf = atoi(sp+1); /* set the start frame */ sp = strchr(sp+1, ' '); if (sp == NULL) { E_FATAL("Control file line must be '<path> [<sf> <ef> [<id>]]', instead saw '%s'\n", line); } if (ef != NULL) *ef = atoi(sp+1); /* set the end frame */ sp = strchr(sp+1, ' '); if (id != NULL) { if (sp == NULL) { /* assume that the optional ID has been omitted */ *id = NULL; } else { *id = strdup(sp+1); /* set the utterance ID */ } } } }