void
s3_decode_end_utt(s3_decode_t * _decode)
{
int32 num_features;
if (_decode == NULL)
return;
if (_decode->state != S3_DECODE_STATE_DECODING) {
E_WARN("Cannot end utterance in current decoder state.\n");
return;
}
/* Call this with no frames, to update CMN and AGC statistics. */
num_features = feat_s2mfc2feat_live(kbcore_fcb(_decode->kbcore),
NULL, NULL, FALSE,
TRUE, _decode->kb.feat);
if (num_features > 0)
utt_decode_block(_decode->kb.feat,
num_features,
&_decode->num_frames_decoded,
&_decode->kb);
_decode->kb.stat->tot_fr += _decode->kb.stat->nfr;
s3_decode_record_hyps(_decode, TRUE);
utt_end(&_decode->kb);
_decode->state = S3_DECODE_STATE_IDLE;
}
int
ld_init(live_decoder_t *decoder, int argc, char **argv)
{
param_t fe_param;
if (argc == 2) {
/*
* lgalescu: check if args need to be processed from file
*/
parse_args_file(argv[1]);
} else
cmd_ln_parse(arg_def, argc, argv);
unlimit();
/* some decoder parameter capturing
* !!! NOTE - HARDCODED FOR NOW. REPLACE WITH PARSE_ARG() ASAP !!!!
*/
memset(decoder, 0, sizeof(live_decoder_t));
kb_init(&decoder->kb);
decoder->max_wpf = cmd_ln_int32 ("-maxwpf");;
decoder->max_histpf = cmd_ln_int32 ("-maxhistpf");
decoder->max_hmmpf = cmd_ln_int32 ("-maxhmmpf");
decoder->phones_skip = cmd_ln_int32 ("-ptranskip");
decoder->hmm_log = cmd_ln_int32("-hmmdump") ? stderr : NULL;
decoder->kbcore = decoder->kb.kbcore;
decoder->kb.uttid = decoder->uttid;
decoder->hypsegs = 0;
decoder->num_hypsegs = 0;
decoder->hypstr_len = 0;
decoder->hypstr[0] = '\0';
decoder->features =
feat_array_alloc(kbcore_fcb(decoder->kbcore), LIVEBUFBLOCKSIZE);
decoder->ld_state = LD_STATE_IDLE;
/* some front-end parameter capturing
* !!! NOTE - HARDCODED FOR NOW. REPLACE WITH PARSE_ARG() ASAP !!!!
*/
memset(&fe_param, 0, sizeof(param_t));
fe_param.SAMPLING_RATE = (float32)cmd_ln_int32 ("-samprate");
fe_param.LOWER_FILT_FREQ = cmd_ln_float32("-lowerf");
fe_param.UPPER_FILT_FREQ = cmd_ln_float32("-upperf");
fe_param.NUM_FILTERS = cmd_ln_int32("-nfilt");
fe_param.FRAME_RATE = cmd_ln_int32("-frate");
fe_param.PRE_EMPHASIS_ALPHA = cmd_ln_float32("-alpha");
fe_param.FFT_SIZE = cmd_ln_int32("-nfft");
fe_param.WINDOW_LENGTH = cmd_ln_float32("-wlen");
decoder->fe = fe_init(&fe_param);
if (!decoder->fe) {
E_WARN("Front end initialization fe_init() failed\n");
return -1;
}
return 0;
}
int
ld_utt_proc_raw_impl(live_decoder_t *decoder,
int16 *samples,
int32 num_samples,
int32 begin_utt,
int32 end_utt)
{
float32 dummy_frame[MAX_CEP_LEN];
float32 **frames = 0;
int32 num_frames = 0;
int32 num_features = 0;
num_frames = fe_process_utt(decoder->fe, samples, num_samples, &frames);
if (end_utt) {
fe_end_utt(decoder->fe, dummy_frame);
}
if (num_frames > 0) {
num_features = feat_s2mfc2feat_block(kbcore_fcb(decoder->kbcore),
frames,
num_frames,
begin_utt,
end_utt,
decoder->features);
}
if (num_features > 0) {
utt_decode_block(decoder->features,
num_features,
&decoder->frame_num,
&decoder->kb,
decoder->max_wpf,
decoder->max_histpf,
decoder->max_hmmpf,
decoder->phones_skip,
decoder->hmm_log);
}
if (frames) {
ckd_free_2d((void **)frames);
}
return 0;
}
int
s3_decode_process(s3_decode_t * _decode,
float32 ** _cep_frames,
int32 _num_frames)
{
int32 num_features = 0;
int32 begin_utt = _decode->num_frames_entered == 0;
if (_decode == NULL)
return S3_DECODE_ERROR_NULL_POINTER;
if (_num_frames >= S3_MAX_FRAMES)
return S3_DECODE_ERROR_OUT_OF_MEMORY;
if (_num_frames > 0) {
num_features = feat_s2mfc2feat_live(kbcore_fcb(_decode->kbcore),
_cep_frames,
&_num_frames,
begin_utt,
FALSE,
_decode->kb.feat);
_decode->num_frames_entered += _num_frames;
if (num_features > 0) {
if (_decode->num_frames_entered >= S3_MAX_FRAMES)
return S3_DECODE_ERROR_OUT_OF_MEMORY;
utt_decode_block(_decode->kb.feat,
num_features,
&_decode->num_frames_decoded,
&_decode->kb);
}
}
return S3_DECODE_SUCCESS;
}
void
ld_process_ceps(live_decoder_t * _decoder,
float32 ** _cep_frames, int32 _num_frames)
{
int32 num_features = 0;
int32 begin_utt = _decoder->num_frames_entered == 0;
assert(_decoder != NULL);
if (_num_frames > 0) {
num_features = feat_s2mfc2feat_block(kbcore_fcb(_decoder->kbcore),
_cep_frames,
_num_frames,
begin_utt,
FALSE, _decoder->features);
_decoder->num_frames_entered += _num_frames;
}
if (num_features > 0) {
utt_decode_block(_decoder->features,
num_features,
&_decoder->num_frames_decoded, &_decoder->kb);
}
}
void
kb_init(kb_t * kb, cmd_ln_t *config)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
int32 cisencnt;
/* STRUCTURE: Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = kbcore_init(config);
if (kb->kbcore == NULL)
E_FATAL("Initialization of kb failed\n");
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
d2p = kbcore_dict2pid(kbcore);
err_set_debug_level(cmd_ln_int32_r(config, "-debug"));
/* STRUCTURE INITIALIZATION: Initialize the beam data structure */
if (cmd_ln_exists_r(config, "-ptranskip")) {
kb->beam = beam_init(cmd_ln_float64_r(config, "-beam"),
cmd_ln_float64_r(config, "-pbeam"),
cmd_ln_float64_r(config, "-wbeam"),
cmd_ln_float64_r(config, "-wend_beam"),
cmd_ln_int32_r(config, "-ptranskip"), mdef_n_ciphone(mdef),
kbcore->logmath
);
/* REPORT : Report the parameters in the beam data structure */
if (REPORT_KB)
beam_report(kb->beam);
}
/* STRUCTURE INITIALIZATION: Initialize the fast GMM computation data structure */
if (cmd_ln_exists_r(config, "-ci_pbeam")) {
kb->fastgmm = fast_gmm_init(cmd_ln_int32_r(config, "-ds"),
cmd_ln_int32_r(config, "-cond_ds"),
cmd_ln_int32_r(config, "-dist_ds"),
cmd_ln_int32_r(config, "-gs4gs"),
cmd_ln_int32_r(config, "-svq4svq"),
cmd_ln_float64_r(config, "-subvqbeam"),
cmd_ln_float64_r(config, "-ci_pbeam"),
cmd_ln_float64_r(config, "-tighten_factor"),
cmd_ln_int32_r(config, "-maxcdsenpf"),
mdef->n_ci_sen,
kbcore->logmath);
/* REPORT : Report the parameters in the fast_gmm_t data struture */
if (REPORT_KB)
fast_gmm_report(kb->fastgmm);
}
/* STRUCTURE INITIALIZATION: Initialize the phoneme lookahead data structure */
if (cmd_ln_exists_r(config, "-pl_beam")) {
kb->pl = pl_init(cmd_ln_int32_r(config, "-pheurtype"),
cmd_ln_float64_r(config, "-pl_beam"), mdef_n_ciphone(mdef),
kbcore->logmath
);
/* REPORT : Report the parameters in the pl_t data struture */
if (REPORT_KB)
pl_report(kb->pl);
}
/* STRUCTURE INITIALIZATION: Initialize the acoustic score data structure */
{
int32 pl_window = 1;
if (cmd_ln_exists_r(config, "-pl_window"))
pl_window = cmd_ln_int32_r(config, "-pl_window");
for (cisencnt = 0; cisencnt == mdef->cd2cisen[cisencnt]; cisencnt++) ;
kb->ascr = ascr_init(kbcore_n_mgau(kbcore),
kb->kbcore->dict2pid->n_comstate,
mdef_n_sseq(mdef),
dict2pid_n_comsseq(d2p),
pl_window, cisencnt);
if (REPORT_KB)
ascr_report(kb->ascr);
}
/* Initialize the front end if -adcin is specified */
if (cmd_ln_exists_r(config, "-adcin") && cmd_ln_boolean_r(config, "-adcin")) {
if ((kb->fe = fe_init_auto_r(config)) == NULL) {
E_FATAL("fe_init_auto_r() failed\n");
}
}
/* STRUCTURE INITIALIZATION : The feature vector */
if ((kb->feat =
feat_array_alloc(kbcore_fcb(kbcore), S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
/* STRUCTURE INITIALIZATION : The statistics for the search */
kb->stat = stat_init();
/* STRUCTURE INITIALIZATION : The adaptation routines of the search */
kb->adapt_am = adapt_am_init();
if (cmd_ln_str_r(config, "-mllr")) {
kb_setmllr(cmd_ln_str_r(config, "-mllr"), cmd_ln_str_r(config, "-cb2mllr"), kb);
}
/* CHECK: make sure when (-cond_ds) is specified, a Gaussian map is also specified */
if (cmd_ln_int32_r(config, "-cond_ds") > 0 && kb->kbcore->gs == NULL)
E_FATAL
("Conditional Down Sampling require the use of Gaussian Selection map\n");
/* MEMORY ALLOCATION : Word best score and exit */
/* Open hypseg file if specified */
kb->matchsegfp = kb->matchfp = NULL;
kb->matchsegfp = file_open(cmd_ln_str_r(config, "-hypseg"));
kb->matchfp = file_open(cmd_ln_str_r(config, "-hyp"));
if (cmd_ln_exists_r(config, "-hmmdump"))
kb->hmmdumpfp = cmd_ln_int32_r(config, "-hmmdump") ? stderr : NULL;
/* STRUCTURE INITIALIZATION : The search data structure, done only
after kb is initialized kb is acted as a clipboard. */
if (cmd_ln_exists_r(config, "-op_mode")) {
/* -op_mode, if set (i.e. not -1), takes precedence over -mode. */
if (cmd_ln_int32_r(config, "-op_mode") != -1)
kb->op_mode = cmd_ln_int32_r(config, "-op_mode");
else
kb->op_mode = srch_mode_str_to_index(cmd_ln_str_r(config, "-mode"));
E_INFO("SEARCH MODE INDEX %d\n", kb->op_mode);
if ((kb->srch = (srch_t *) srch_init(kb, kb->op_mode)) == NULL) {
E_FATAL("Search initialization failed. Forced exit\n");
}
if (REPORT_KB) {
srch_report(kb->srch);
}
}
}
/*ARCHAN, to allow backward compatibility -lm, -lmctlfn coexists. This makes the current implmentation more complicated than necessary. */
void kb_init (kb_t *kb)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
lmset_t *lmset;
s3cipid_t sil, ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
char *str;
int32 cisencnt;
int32 j;
/* Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = NULL;
kb->kbcore = kbcore_init (cmd_ln_float32 ("-logbase"),
cmd_ln_str("-feat"),
cmd_ln_str("-cmn"),
cmd_ln_str("-varnorm"),
cmd_ln_str("-agc"),
cmd_ln_str("-mdef"),
cmd_ln_str("-dict"),
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant
for -compsep argument */
cmd_ln_str("-lm"),
cmd_ln_str("-lmctlfn"),
cmd_ln_str("-lmdumpdir"),
cmd_ln_str("-fillpen"),
cmd_ln_str("-senmgau"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"),
cmd_ln_str("-mean"),
cmd_ln_str("-var"),
cmd_ln_float32("-varfloor"),
cmd_ln_str("-mixw"),
cmd_ln_float32("-mixwfloor"),
cmd_ln_str("-subvq"),
cmd_ln_str("-gs"),
cmd_ln_str("-tmat"),
cmd_ln_float32("-tmatfloor"));
if(kb->kbcore==NULL){
E_FATAL("Initialization of kb failed\n");
}
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
lm = kbcore_lm(kbcore);
lmset=kbcore_lmset(kbcore);
d2p = kbcore_dict2pid(kbcore);
if (NOT_S3WID(dict_startwid(dict)) || NOT_S3WID(dict_finishwid(dict)))
E_FATAL("%s or %s not in dictionary\n", S3_START_WORD, S3_FINISH_WORD);
if(lmset){
for(i=0;i<kbcore_nlm(kbcore);i++){
if (NOT_S3LMWID(lm_startwid(lmset[i].lm)) || NOT_S3LMWID(lm_finishwid(lmset[i].lm)))
E_FATAL("%s or %s not in LM %s\n", S3_START_WORD, S3_FINISH_WORD,lmset[i].name);
}
}else if(lm){
if (NOT_S3LMWID(lm_startwid(lm)) || NOT_S3LMWID(lm_finishwid(lm)))
E_FATAL("%s or %s not in LM\n", S3_START_WORD, S3_FINISH_WORD);
}
/* Check that HMM topology restrictions are not violated */
if (tmat_chk_1skip (kbcore->tmat) < 0)
E_FATAL("Tmat contains arcs skipping more than 1 state\n");
/*
* Unlink <s> and </s> between dictionary and LM, to prevent their
* recognition. They are merely dummy words (anchors) at the beginning
* and end of each utterance.
*/
if(lmset){
for(i=0;i<kbcore_nlm(kbcore);i++){
lm_lmwid2dictwid(lmset[i].lm, lm_startwid(lmset[i].lm)) = BAD_S3WID;
lm_lmwid2dictwid(lmset[i].lm, lm_finishwid(lmset[i].lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
lmset[i].lm->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
lmset[i].lm->dict2lmwid[w] = BAD_S3LMWID;
}
}else if(lm){ /* No LM is set at this point*/
lm_lmwid2dictwid(lm, lm_startwid(lm)) = BAD_S3WID;
lm_lmwid2dictwid(lm, lm_finishwid(lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
}
sil = mdef_silphone (kbcore_mdef (kbcore));
if (NOT_S3CIPID(sil))
E_FATAL("Silence phone '%s' not in mdef\n", S3_SILENCE_CIPHONE);
kb->sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->rec_sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->ssid_active = (int32 *) ckd_calloc (mdef_n_sseq(mdef), sizeof(int32));
kb->comssid_active = (int32 *) ckd_calloc (dict2pid_n_comsseq(d2p), sizeof(int32));
/* Build set of all possible left contexts */
lc = (s3cipid_t *) ckd_calloc (mdef_n_ciphone(mdef) + 1, sizeof(s3cipid_t));
lc_active = bitvec_alloc (mdef_n_ciphone (mdef));
for (w = 0; w < dict_size (dict); w++) {
ci = dict_pron (dict, w, dict_pronlen(dict, w) - 1);
if (! mdef_is_fillerphone (mdef, (int)ci))
bitvec_set (lc_active, ci);
}
ci = mdef_silphone(mdef);
bitvec_set (lc_active, ci);
for (ci = 0, n_lc = 0; ci < mdef_n_ciphone(mdef); ci++) {
if (bitvec_is_set (lc_active, ci))
lc[n_lc++] = ci;
}
lc[n_lc] = BAD_S3CIPID;
E_INFO("Building lextrees\n");
/* Get the number of lexical tree*/
kb->n_lextree = cmd_ln_int32 ("-Nlextree");
if (kb->n_lextree < 1) {
E_ERROR("No. of ugtrees specified: %d; will instantiate 1 ugtree\n",
kb->n_lextree);
kb->n_lextree = 1;
}
/* ARCHAN: This code was rearranged in s3.4 implementation of dynamic LM */
/* Build active word list */
wp = (wordprob_t *) ckd_calloc (dict_size(dict), sizeof(wordprob_t));
if(lmset){
kb->ugtreeMulti = (lextree_t **) ckd_calloc (kbcore_nlm(kbcore)*kb->n_lextree, sizeof(lextree_t *));
/* Just allocate pointers*/
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for(i=0;i<kbcore_nlm(kbcore);i++){
E_INFO("Creating Unigram Table for lm %d name %s\n",i,lmset[i].name);
n=0;
for(j=0;j<dict_size(dict);j++){ /*try to be very careful again */
wp[j].wid=-1;
wp[j].prob=-1;
}
n = lm_ug_wordprob (lmset[i].lm, dict,MAX_NEG_INT32, wp);
E_INFO("Size of word table after unigram + words in class: %d.\n",n);
if (n < 1)
E_FATAL("%d active words in %s\n", n,lmset[i].name);
n = wid_wordprob2alt(dict,wp,n);
E_INFO("Size of word table after adding alternative prons: %d.\n",n);
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
for (j = 0; j < kb->n_lextree; j++) {
kb->ugtreeMulti[i*kb->n_lextree+j] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtreeMulti[i*kb->n_lextree+j]) = 0;
E_INFO("Lextrees (%d) for lm %d name %s, %d nodes(ug)\n",
kb->n_lextree, i, lmset[i].name,lextree_n_node(kb->ugtreeMulti[i*kb->n_lextree+j]));
}
}
}else if (lm){
E_INFO("Creating Unigram Table\n");
n=0;
n = lm_ug_wordprob (lm, dict,MAX_NEG_INT32, wp);
E_INFO("Size of word table after unigram + words in class: %d\n",n);
if (n < 1)
E_FATAL("%d active words\n", n);
n = wid_wordprob2alt (dict, wp, n); /* Add alternative pronunciations */
/* Retain or remove unigram probs from lextree, depending on option */
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
/* Create the desired no. of unigram lextrees */
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for (i = 0; i < kb->n_lextree; i++) {
kb->ugtree[i] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtree[i]) = 0;
}
E_INFO("Lextrees(%d), %d nodes(ug)\n",
kb->n_lextree, lextree_n_node(kb->ugtree[0]));
}
/* Create filler lextrees */
/* ARCHAN : only one filler tree is supposed to be build even for dynamic LMs */
n = 0;
for (i = dict_filler_start(dict); i <= dict_filler_end(dict); i++) {
if (dict_filler_word(dict, i)) {
wp[n].wid = i;
wp[n].prob = fillpen (kbcore->fillpen, i);
n++;
}
}
kb->fillertree = (lextree_t **)ckd_calloc(kb->n_lextree,sizeof(lextree_t*));
for (i = 0; i < kb->n_lextree; i++) {
kb->fillertree[i] = lextree_build (kbcore, wp, n, NULL);
lextree_type (kb->fillertree[i]) = -1;
}
ckd_free ((void *) wp);
ckd_free ((void *) lc);
bitvec_free (lc_active);
E_INFO("Lextrees(%d), %d nodes(filler)\n",
kb->n_lextree,
lextree_n_node(kb->fillertree[0]));
if (cmd_ln_int32("-lextreedump")) {
if(lmset){
E_FATAL("Currently, doesn't support -lextreedump for multiple-LMs\n");
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "UGTREE %d\n", i);
lextree_dump (kb->ugtree[i], dict, stderr);
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "FILLERTREE %d\n", i);
lextree_dump (kb->fillertree[i], dict, stderr);
}
fflush (stderr);
}
kb->ascr = ascr_init (mgau_n_mgau(kbcore_mgau(kbcore)),
kbcore->dict2pid->n_comstate);
kb->beam = beam_init (cmd_ln_float64("-subvqbeam"),
cmd_ln_float64("-beam"),
cmd_ln_float64("-pbeam"),
cmd_ln_float64("-wbeam"));
E_INFO("Beam= %d, PBeam= %d, WBeam= %d, SVQBeam= %d\n",
kb->beam->hmm, kb->beam->ptrans, kb->beam->word, kb->beam->subvq);
/*Sections of optimization related parameters*/
kb->ds_ratio=cmd_ln_int32("-ds");
E_INFO("Down Sampling Ratio = %d\n",kb->ds_ratio);
kb->rec_bstcid=-1;
kb->skip_count=0;
kb->cond_ds=cmd_ln_int32("-cond_ds");
E_INFO("Conditional Down Sampling Parameter = %d\n",kb->cond_ds);
if(kb->cond_ds>0&&kb->kbcore->gs==NULL) E_FATAL("Conditional Down Sampling require the use of Gaussian Selection map\n");
kb->gs4gs=cmd_ln_int32("-gs4gs");
E_INFO("GS map would be used for Gaussian Selection? = %d\n",kb->gs4gs);
kb->svq4svq=cmd_ln_int32("-svq4svq");
E_INFO("SVQ would be used as Gaussian Score ?= %d\n",kb->svq4svq);
kb->ci_pbeam=-1*logs3(cmd_ln_float32("-ci_pbeam"));
E_INFO("CI phone beam to prune the number of parent CI phones in CI-base GMM Selection = %d\n",kb->ci_pbeam);
if(kb->ci_pbeam>10000000){
E_INFO("Virtually no CI phone beam is applied now. (ci_pbeam>1000000)\n");
}
kb->wend_beam=-1*logs3(cmd_ln_float32("-wend_beam"));
E_INFO("Word-end pruning beam: %d\n",kb->wend_beam);
kb->pl_window=cmd_ln_int32("-pl_window");
E_INFO("Phoneme look-ahead window size = %d\n",kb->pl_window);
kb->pl_window_start=0;
kb->pl_beam=logs3(cmd_ln_float32("-pl_beam"));
E_INFO("Phoneme look-ahead beam = %d\n",kb->pl_beam);
for(cisencnt=0;cisencnt==mdef->cd2cisen[cisencnt];cisencnt++)
;
kb->cache_ci_senscr=(int32**)ckd_calloc_2d(kb->pl_window,cisencnt,sizeof(int32));
kb->cache_best_list=(int32*)ckd_calloc(kb->pl_window,sizeof(int32));
kb->phn_heur_list=(int32*)ckd_calloc(mdef_n_ciphone (mdef),sizeof(int32));
if ((kb->feat = feat_array_alloc(kbcore_fcb(kbcore),S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
kb->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
ptmr_init (&(kb->tm_sen));
ptmr_init (&(kb->tm_srch));
ptmr_init (&(kb->tm_ovrhd));
kb->tot_fr = 0;
kb->tot_sen_eval = 0.0;
kb->tot_gau_eval = 0.0;
kb->tot_hmm_eval = 0.0;
kb->tot_wd_exit = 0.0;
kb->hmm_hist_binsize = cmd_ln_int32("-hmmhistbinsize");
if(lmset)
n = ((kb->ugtreeMulti[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
else
n = ((kb->ugtree[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
n /= kb->hmm_hist_binsize;
kb->hmm_hist_bins = n+1;
kb->hmm_hist = (int32 *) ckd_calloc (n+1, sizeof(int32)); /* Really no need for +1 */
/* Open hypseg file if specified */
str = cmd_ln_str("-hypseg");
kb->matchsegfp = NULL;
if (str) {
#ifdef SPEC_CPU_WINDOWS
if ((kb->matchsegfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchsegfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
str = cmd_ln_str("-hyp");
kb->matchfp = NULL;
if (str) {
#ifdef SPEC_CPU_WINDOWS
if ((kb->matchfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
}
void kb_init (kb_t *kb)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
s3cipid_t sil, ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
char *str;
/* Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = kbcore_init (cmd_ln_float32 ("-logbase"),
"1s_c_d_dd", /* Hack!! Hardwired constant
for -feat argument */
cmd_ln_str("-cmn"),
cmd_ln_str("-varnorm"),
cmd_ln_str("-agc"),
cmd_ln_str("-mdef"),
cmd_ln_str("-dict"),
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant
for -compsep argument */
cmd_ln_str("-lm"),
cmd_ln_str("-fillpen"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"),
cmd_ln_str("-mean"),
cmd_ln_str("-var"),
cmd_ln_float32("-varfloor"),
cmd_ln_str("-mixw"),
cmd_ln_float32("-mixwfloor"),
cmd_ln_str("-subvq"),
cmd_ln_str("-tmat"),
cmd_ln_float32("-tmatfloor"));
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
lm = kbcore_lm(kbcore);
d2p = kbcore_dict2pid(kbcore);
if (NOT_S3WID(dict_startwid(dict)) || NOT_S3WID(dict_finishwid(dict)))
E_FATAL("%s or %s not in dictionary\n", S3_START_WORD, S3_FINISH_WORD);
if (NOT_S3LMWID(lm_startwid(lm)) || NOT_S3LMWID(lm_finishwid(lm)))
E_FATAL("%s or %s not in LM\n", S3_START_WORD, S3_FINISH_WORD);
/* Check that HMM topology restrictions are not violated */
if (tmat_chk_1skip (kbcore->tmat) < 0)
E_FATAL("Tmat contains arcs skipping more than 1 state\n");
/*
* Unlink <s> and </s> between dictionary and LM, to prevent their
* recognition. They are merely dummy words (anchors) at the beginning
* and end of each utterance.
*/
lm_lmwid2dictwid(lm, lm_startwid(lm)) = BAD_S3WID;
lm_lmwid2dictwid(lm, lm_finishwid(lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
sil = mdef_silphone (kbcore_mdef (kbcore));
if (NOT_S3CIPID(sil))
E_FATAL("Silence phone '%s' not in mdef\n", S3_SILENCE_CIPHONE);
E_INFO("Building lextrees\n");
kb->sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->ssid_active = (int32 *) ckd_calloc (mdef_n_sseq(mdef), sizeof(int32));
kb->comssid_active = (int32 *) ckd_calloc (dict2pid_n_comsseq(d2p),
sizeof(int32));
/* Build active word list */
wp = (wordprob_t *) ckd_calloc (dict_size(dict), sizeof(wordprob_t));
n = lm_ug_wordprob (lm, MAX_NEG_INT32, wp);
if (n < 1)
E_FATAL("%d active words\n", n);
n = wid_wordprob2alt (dict, wp, n); /* Add alternative pronunciations */
/* Retain or remove unigram probs from lextree, depending on option */
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
/* Build set of all possible left contexts */
lc = (s3cipid_t *) ckd_calloc (mdef_n_ciphone(mdef) + 1, sizeof(s3cipid_t));
lc_active = bitvec_alloc (mdef_n_ciphone (mdef));
for (w = 0; w < dict_size (dict); w++) {
ci = dict_pron (dict, w, dict_pronlen(dict, w) - 1);
if (! mdef_is_fillerphone (mdef, (int)ci))
bitvec_set (lc_active, ci);
}
ci = mdef_silphone(mdef);
bitvec_set (lc_active, ci);
for (ci = 0, n_lc = 0; ci < mdef_n_ciphone(mdef); ci++) {
if (bitvec_is_set (lc_active, ci))
lc[n_lc++] = ci;
}
lc[n_lc] = BAD_S3CIPID;
/* Create the desired no. of unigram lextrees */
kb->n_lextree = cmd_ln_int32 ("-Nlextree");
if (kb->n_lextree < 1) {
E_ERROR("No. of ugtrees specified: %d; will instantiate 1 ugtree\n",
kb->n_lextree);
kb->n_lextree = 1;
}
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for (i = 0; i < kb->n_lextree; i++) {
kb->ugtree[i] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtree[i]) = 0;
}
bitvec_free (lc_active);
ckd_free ((void *) lc);
/* Create filler lextrees */
n = 0;
for (i = dict_filler_start(dict); i <= dict_filler_end(dict); i++) {
if (dict_filler_word(dict, i)) {
wp[n].wid = i;
wp[n].prob = fillpen (kbcore->fillpen, i);
n++;
}
}
kb->fillertree = (lextree_t **)ckd_calloc(kb->n_lextree,sizeof(lextree_t*));
for (i = 0; i < kb->n_lextree; i++) {
kb->fillertree[i] = lextree_build (kbcore, wp, n, NULL);
lextree_type (kb->fillertree[i]) = -1;
}
ckd_free ((void *) wp);
E_INFO("Lextrees(%d), %d nodes(ug), %d nodes(filler)\n",
kb->n_lextree, lextree_n_node(kb->ugtree[0]),
lextree_n_node(kb->fillertree[0]));
if (cmd_ln_int32("-lextreedump")) {
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "UGTREE %d\n", i);
lextree_dump (kb->ugtree[i], dict, stderr);
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "FILLERTREE %d\n", i);
lextree_dump (kb->fillertree[i], dict, stderr);
}
fflush (stderr);
}
kb->ascr = ascr_init (mgau_n_mgau(kbcore_mgau(kbcore)),
kbcore->dict2pid->n_comstate);
kb->beam = beam_init (cmd_ln_float64("-subvqbeam"),
cmd_ln_float64("-beam"),
cmd_ln_float64("-pbeam"),
cmd_ln_float64("-wbeam"));
E_INFO("Beam= %d, PBeam= %d, WBeam= %d, SVQBeam= %d\n",
kb->beam->hmm, kb->beam->ptrans, kb->beam->word, kb->beam->subvq);
if ((kb->feat = feat_array_alloc(kbcore_fcb(kbcore),S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
kb->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
ptmr_init (&(kb->tm_sen));
ptmr_init (&(kb->tm_srch));
kb->tot_fr = 0;
kb->tot_sen_eval = 0.0;
kb->tot_gau_eval = 0.0;
kb->tot_hmm_eval = 0.0;
kb->tot_wd_exit = 0.0;
kb->hmm_hist_binsize = cmd_ln_int32("-hmmhistbinsize");
n = ((kb->ugtree[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
n /= kb->hmm_hist_binsize;
kb->hmm_hist_bins = n+1;
kb->hmm_hist = (int32 *) ckd_calloc (n+1, sizeof(int32)); /* Really no need for +1 */
/* Open hypseg file if specified */
str = cmd_ln_str("-hypseg");
kb->matchsegfp = NULL;
if (str) {
#ifdef WIN32
if ((kb->matchsegfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchsegfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
}
int32 live_utt_decode_block (int16 *samples, int32 nsamples,
int32 live_endutt, partialhyp_t **ohyp)
{
static int32 live_begin_new_utt = 1;
static int32 frmno;
float32 **live_feat;
int32 live_nfr, live_nfeatvec;
int32 nwds;
/* int32 id; */ /* unreferenced variable */
/* glist_t hyp; */ /* unreferenced variable */
/* gnode_t *gn; */ /* unreferenced variable */
/* hyp_t *h; */ /* unreferenced variable */
/* dict_t *dict; */ /* unreferenced variable */
float32 **mfcbuf;
if (live_begin_new_utt){
fe_start_utt(fe);
utt_begin (kb);
frmno = 0;
kb->nfr = 0;
kb->utt_hmm_eval = 0;
kb->utt_sen_eval = 0;
kb->utt_gau_eval = 0;
live_begin_new_utt = 0;
}
sample_blk++;
/* 10.jan.01 RAH, fe_process_utt now requires ***mfcbuf and it allocates the memory internally) */
mfcbuf = NULL;
live_nfr = fe_process_utt(fe, samples, nsamples, &mfcbuf); /* */
if (live_endutt) /* RAH, It seems that we shouldn't throw out this data */
fe_end_utt(fe,dummyframe); /* Flush out the fe */
/* Compute feature vectors */
live_nfeatvec = feat_s2mfc2feat_block(kbcore_fcb(kbcore), mfcbuf,
live_nfr, live_begin_new_utt,
live_endutt, &live_feat);
E_INFO ("live_nfeatvec: %ld\n",live_nfeatvec);
/* decode the block */
if (sample_blk<=START_BLOCK)
single_utt_decode_block (live_feat, live_nfeatvec, &frmno, kb,
maxwpf, maxhistpf, maxhmmpf, ptranskip, hmmdumpfp);
else
utt_decode_block (live_feat, live_nfeatvec, &frmno, kb,
maxwpf, maxhistpf, maxhmmpf, ptranskip, hmmdumpfp);
/* Pull out partial hypothesis */
nwds = live_get_partialhyp(live_endutt);
*ohyp = parthyp;
/* Clean up */
if (live_endutt) {
live_begin_new_utt = 1;
kb->tot_fr += kb->nfr;
utt_end(kb);
}
else {
live_begin_new_utt = 0;
}
/* I'm starting to think that fe_process_utt should not be allocating its memory,
that or it should allocate some max and just keep on going, this idea of constantly allocating freeing
memory seems dangerous to me.*/
ckd_free_2d((void **) mfcbuf); /* RAH, this must be freed since fe_process_utt allocates it */
return(nwds);
}
static int
ld_init_impl(live_decoder_t * _decoder, int32 _internal_cmdln)
{
param_t fe_param;
int rv = LD_SUCCESS;
assert(_decoder != NULL);
unlimit();
/* ARCHAN 20050708: This part should be factored with fe_parse_option */
/* allocate and initialize front-end */
fe_init_params(&fe_param);
fe_param.SAMPLING_RATE = cmd_ln_float32("-samprate");
fe_param.FRAME_RATE = cmd_ln_int32("-frate");
fe_param.WINDOW_LENGTH = cmd_ln_float32("-wlen");
fe_param.FB_TYPE = strcmp("mel_scale", cmd_ln_str("-fbtype")) == 0 ?
MEL_SCALE : LOG_LINEAR;
fe_param.NUM_CEPSTRA = cmd_ln_int32("-ncep");
fe_param.NUM_FILTERS = cmd_ln_int32("-nfilt");
fe_param.FFT_SIZE = cmd_ln_int32("-nfft");
fe_param.LOWER_FILT_FREQ = cmd_ln_float32("-lowerf");
fe_param.UPPER_FILT_FREQ = cmd_ln_float32("-upperf");
fe_param.PRE_EMPHASIS_ALPHA = cmd_ln_float32("-alpha");
fe_param.dither = strcmp("no", cmd_ln_str("-dither"));
fe_param.warp_type = cmd_ln_str("-warp_type");
fe_param.warp_params = cmd_ln_str("-warp_params");
if ((_decoder->fe = fe_init(&fe_param)) == NULL) {
E_WARN("Failed to initialize front-end.\n");
rv = LD_ERROR_OUT_OF_MEMORY;
goto ld_init_impl_cleanup;
}
/* capture decoder parameters */
kb_init(&_decoder->kb);
/* initialize decoder variables */
_decoder->kbcore = _decoder->kb.kbcore;
_decoder->hyp_frame_num = -1;
_decoder->uttid = NULL;
_decoder->ld_state = LD_STATE_IDLE;
_decoder->hyp_str = NULL;
_decoder->hyp_segs = NULL;
/*
_decoder->swap= (cmd_ln_int32("-machine_endian") != cmd_ln_int32("-input_endian"));
*/
_decoder->swap =
(strcmp(cmd_ln_str("-machine_endian"), cmd_ln_str("-input_endian"))
!= 0);
_decoder->phypdump = (cmd_ln_int32("-phypdump"));
_decoder->rawext = (cmd_ln_str("-rawext"));
if (_decoder->phypdump)
E_INFO("Partial hypothesis WILL be dumped\n");
else
E_INFO("Partial hypothesis will NOT be dumped\n");
if (_decoder->swap)
E_INFO("Input data WILL be byte swapped\n");
else
E_INFO("Input data will NOT be byte swapped\n");
_decoder->internal_cmdln = _internal_cmdln;
_decoder->features =
feat_array_alloc(kbcore_fcb(_decoder->kbcore), LIVEBUFBLOCKSIZE);
if (_decoder->features == NULL) {
E_WARN("Failed to allocate internal feature buffer.\n");
rv = LD_ERROR_OUT_OF_MEMORY;
goto ld_init_impl_cleanup;
}
return LD_SUCCESS;
ld_init_impl_cleanup:
if (_decoder->fe != NULL) {
fe_close(_decoder->fe);
}
if (_decoder->features != NULL) {
/* consult the implementation of feat_array_alloc() for how to free our
* internal feature vector buffer */
ckd_free((void *) **_decoder->features);
ckd_free_2d((void **) _decoder->features);
}
if (_internal_cmdln == TRUE) {
cmd_ln_free();
}
_decoder->ld_state = LD_STATE_FINISHED;
return rv;
}
static void
utt_align(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
int32 nfr;
int k, i;
const char *cepdir;
const char *cepext;
char sent[16384];
cmd_ln_t *config = (cmd_ln_t*) data;
cepdir = cmd_ln_str_r(kbc->config, "-cepdir");
cepext = cmd_ln_str_r(kbc->config, "-cepext");
/* UGLY! */
/* Read utterance transcript and match it with the control file. */
if (fgets(sent, sizeof(sent), sentfp) == NULL) {
E_FATAL("EOF(%s) of the transcription\n", sentfile);
}
/* E_INFO("SENT %s\n",sent); */
/* Strip utterance id from the end of the transcript */
for (k = strlen(sent) - 1;
(k > 0) && ((sent[k] == '\n') || (sent[k] == '\t')
|| (sent[k] == ' ')); --k);
if ((k > 0) && (sent[k] == ')')) {
for (--k; (k >= 0) && (sent[k] != '('); --k);
if ((k >= 0) && (sent[k] == '(')) {
sent[k] = '\0';
/* Check that uttid in transcript and control file match */
for (i = ++k;
sent[i] && (sent[i] != ')') &&
(sent[i] != '\n') && (sent[i] != '\t')
&& (sent[i] != ' '); i++);
sent[i] = '\0';
if (id_cmp(sent + k, uttid) != 0)
E_ERROR
("Uttid mismatch: ctlfile = \"%s\"; transcript = \"%s\"\n",
uttid, sent + k);
}
}
/* Convert input file to cepstra if waveform input is selected */
if (cmd_ln_boolean_r(config, "-adcin")) {
int16 *adcdata;
int32 nsamps = 0;
mfcc_t **mfcc;
if ((adcdata = bio_read_wavfile(cmd_ln_str_r(config, "-cepdir"),
ur->uttfile,
cmd_ln_str_r(config, "-cepext"),
cmd_ln_int32_r(config, "-adchdr"),
strcmp(cmd_ln_str_r(config, "-input_endian"), "big"),
&nsamps)) == NULL) {
E_FATAL("Cannot read file %s\n", ur->uttfile);
}
fe_start_utt(fe);
if (fe_process_utt(fe, adcdata, nsamps, &mfcc, &nfr) < 0) {
E_FATAL("MFCC calculation failed\n", ur->uttfile);
}
ckd_free(adcdata);
if (nfr > S3_MAX_FRAMES) {
E_FATAL("Maximum number of frames (%d) exceeded\n", S3_MAX_FRAMES);
}
if ((nfr = feat_s2mfc2feat_live(kbcore_fcb(kbc),
mfcc,
&nfr,
TRUE, TRUE,
feat)) < 0) {
E_FATAL("Feature computation failed\n");
}
if (mfcc)
ckd_free_2d((void **)mfcc);
}
else {
nfr =
feat_s2mfc2feat(kbcore_fcb(kbc), ur->uttfile, cepdir, cepext, sf, ef, feat,
S3_MAX_FRAMES);
}
if (ur->regmatname) {
if (kbc->mgau)
adapt_set_mllr(adapt_am, kbc->mgau, ur->regmatname,
ur->cb2mllrname, kbc->mdef, kbc->config);
else if (kbc->ms_mgau)
model_set_mllr(kbc->ms_mgau, ur->regmatname, ur->cb2mllrname,
kbcore_fcb(kbc), kbc->mdef, kbc->config);
else
E_WARN("Can't use MLLR matrices with .s2semi. yet\n");
}
if (nfr <= 0) {
if (cepdir != NULL) {
E_ERROR
("Utt %s: Input file read (%s) with dir (%s) and extension (%s) failed \n",
uttid, ur->uttfile, cepdir, cepext);
}
else {
E_ERROR
("Utt %s: Input file read (%s) with extension (%s) failed \n",
uttid, ur->uttfile, cepext);
}
}
else {
E_INFO("%s: %d input frames\n", uttid, nfr);
align_utt(sent, nfr, ur->uttfile, uttid);
}
}
/*
* Find Viterbi alignment.
*/
static void
align_utt(char *sent, /* In: Reference transcript */
int32 nfr, /* In: #frames of input */
char *ctlspec, /* In: Utt specifiction from control file */
char *uttid)
{ /* In: Utterance id, for logging and other use */
int32 i;
align_stseg_t *stseg;
align_phseg_t *phseg;
align_wdseg_t *wdseg;
int32 w;
w = feat_window_size(kbcore_fcb(kbc)); /* #MFC vectors needed on either side of current
frame to compute one feature vector */
if (nfr <= (w << 1)) {
E_ERROR("Utterance %s < %d frames (%d); ignored\n", uttid,
(w << 1) + 1, nfr);
return;
}
ptmr_reset_all(timers);
ptmr_reset(&tm_utt);
ptmr_start(&tm_utt);
ptmr_reset(&tm_ovrhd);
ptmr_start(&tm_ovrhd);
ptmr_start(timers + tmr_utt);
if (align_build_sent_hmm(sent, cmd_ln_int32_r(kbc->config, "-insert_sil")) != 0) {
align_destroy_sent_hmm();
ptmr_stop(timers + tmr_utt);
E_ERROR("No sentence HMM; no alignment for %s\n", uttid);
return;
}
align_start_utt(uttid);
for (i = 0; i < nfr; i++) {
ptmr_start(timers + tmr_utt);
/* Obtain active senone flags */
ptmr_start(timers + tmr_gauden);
ptmr_start(timers + tmr_senone);
align_sen_active(ascr->sen_active, ascr->n_sen);
/* Bah, there ought to be a function for this. */
if (kbc->ms_mgau) {
ms_cont_mgau_frame_eval(ascr,
kbc->ms_mgau,
kbc->mdef, feat[i], i);
}
else if (kbc->s2_mgau) {
s2_semi_mgau_frame_eval(kbc->s2_mgau,
ascr, fastgmm, feat[i],
i);
}
else if (kbc->mgau) {
approx_cont_mgau_ci_eval(kbcore_svq(kbc),
kbcore_gs(kbc),
kbcore_mgau(kbc),
fastgmm,
kbc->mdef,
feat[i][0],
ascr->cache_ci_senscr[0],
&(ascr->cache_best_list[0]), i,
kbcore_logmath(kbc));
approx_cont_mgau_frame_eval(kbcore_mdef(kbc),
kbcore_svq(kbc),
kbcore_gs(kbc),
kbcore_mgau(kbc),
fastgmm, ascr,
feat[i][0], i,
ascr->
cache_ci_senscr[0],
&tm_ovrhd,
kbcore_logmath(kbc));
}
ptmr_stop(timers + tmr_gauden);
ptmr_stop(timers + tmr_senone);
/* Step alignment one frame forward */
ptmr_start(timers + tmr_align);
align_frame(ascr->senscr);
ptmr_stop(timers + tmr_align);
ptmr_stop(timers + tmr_utt);
}
ptmr_stop(&tm_utt);
ptmr_stop(&tm_ovrhd);
printf("\n");
/* Wind up alignment for this utterance */
if (align_end_utt(&stseg, &phseg, &wdseg) < 0)
E_ERROR("Final state not reached; no alignment for %s\n\n", uttid);
else {
if (s2stsegdir)
write_s2stseg(s2stsegdir, stseg, uttid, ctlspec, cmd_ln_boolean_r(kbc->config, "-s2cdsen"));
if (stsegdir)
write_stseg(stsegdir, stseg, uttid, ctlspec);
if (phsegdir)
write_phseg(phsegdir, phseg, uttid, ctlspec);
if (phlabdir)
write_phlab(phlabdir, phseg, uttid, ctlspec, cmd_ln_int32_r(kbc->config, "-frate"));
if (wdsegdir)
write_wdseg(wdsegdir, wdseg, uttid, ctlspec);
if (outsentfp)
write_outsent(outsentfp, wdseg, uttid);
if (outctlfp)
write_outctl(outctlfp, ctlspec);
}
align_destroy_sent_hmm();
ptmr_print_all(stdout, timers, nfr * 0.1);
printf
("EXECTIME: %5d frames, %7.2f sec CPU, %6.2f xRT; %7.2f sec elapsed, %6.2f xRT\n",
nfr, tm_utt.t_cpu, tm_utt.t_cpu * 100.0 / nfr, tm_utt.t_elapsed,
tm_utt.t_elapsed * 100.0 / nfr);
tot_nfr += nfr;
}
void
utt_decode(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
kb_t *kb;
kbcore_t *kbcore;
cmd_ln_t *config;
int32 num_decode_frame;
int32 total_frame;
stat_t *st;
srch_t *s;
num_decode_frame = 0;
E_INFO("Processing: %s\n", uttid);
kb = (kb_t *) data;
kbcore = kb->kbcore;
config = kbcore_config(kbcore);
kb_set_uttid(uttid, ur->uttfile, kb);
st = kb->stat;
/* Convert input file to cepstra if waveform input is selected */
if (cmd_ln_boolean_r(config, "-adcin")) {
int16 *adcdata;
int32 nsamps = 0;
if ((adcdata = bio_read_wavfile(cmd_ln_str_r(config, "-cepdir"),
ur->uttfile,
cmd_ln_str_r(config, "-cepext"),
cmd_ln_int32_r(config, "-adchdr"),
strcmp(cmd_ln_str_r(config, "-input_endian"), "big"),
&nsamps)) == NULL) {
E_FATAL("Cannot read file %s\n", ur->uttfile);
}
if (kb->mfcc) {
ckd_free_2d((void **)kb->mfcc);
}
fe_start_utt(kb->fe);
if (fe_process_utt(kb->fe, adcdata, nsamps, &kb->mfcc, &total_frame) < 0) {
E_FATAL("MFCC calculation failed\n", ur->uttfile);
}
ckd_free(adcdata);
if (total_frame > S3_MAX_FRAMES) {
E_FATAL("Maximum number of frames (%d) exceeded\n", S3_MAX_FRAMES);
}
if ((total_frame = feat_s2mfc2feat_live(kbcore_fcb(kbcore),
kb->mfcc,
&total_frame,
TRUE, TRUE,
kb->feat)) < 0) {
E_FATAL("Feature computation failed\n");
}
}
else {
/* Read mfc file and build feature vectors for entire utterance */
if ((total_frame = feat_s2mfc2feat(kbcore_fcb(kbcore), ur->uttfile,
cmd_ln_str_r(config, "-cepdir"),
cmd_ln_str_r(config, "-cepext"), sf, ef,
kb->feat, S3_MAX_FRAMES)) < 0) {
E_FATAL("Cannot read file %s. Forced exit\n", ur->uttfile);
}
}
/* Also need to make sure we don't set resource if it is the same. Well, this mechanism
could be provided inside the following function.
*/
s = kb->srch;
if (ur->lmname != NULL)
srch_set_lm(s, ur->lmname);
if (ur->regmatname != NULL)
kb_setmllr(ur->regmatname, ur->cb2mllrname, kb);
/* These are necessary! */
s->uttid = kb->uttid;
s->uttfile = kb->uttfile;
utt_begin(kb);
utt_decode_block(kb->feat, total_frame, &num_decode_frame, kb);
utt_end(kb);
st->tot_fr += st->nfr;
}
int32 live_utt_decode_block (int16 *samples, int32 nsamples,
int32 live_endutt, partialhyp_t **ohyp)
{
static int32 live_begin_new_utt = 1;
static int32 frmno;
static float32 ***live_feat = NULL;
int32 live_nfr, live_nfeatvec;
int32 nwds =0;
float32 **mfcbuf;
/* int i,j;*/
/* 2004/08/27 L Galescu <*****@*****.**> -- added raw audio file saving */
static char uttfn[1024];
static FILE *rawfp = NULL;
int16 block_peak_amplitude;
if(live_feat==NULL)
live_feat = feat_array_alloc (kbcore_fcb(kbcore), LIVEBUFBLOCKSIZE);
if (live_begin_new_utt){
fe_start_utt(fe);
utt_begin (kb);
frmno = 0;
kb->nfr = 0;
kb->utt_hmm_eval = 0;
kb->utt_sen_eval = 0;
kb->utt_gau_eval = 0;
live_begin_new_utt = 0;
sprintf(uttfn, "%s/%s.raw", cmd_ln_str("-outrawdir"), kb->uttid);
rawfp = fopen(uttfn, "wb");
}
/* 10.jan.01 RAH, fe_process_utt now requires ***mfcbuf and it allocates the memory internally) */
mfcbuf = NULL;
/* LG 20080613 */
block_peak_amplitude = get_peak_amplitude(samples, nsamples);
if (block_peak_amplitude > peak_amplitude)
peak_amplitude = block_peak_amplitude;
E_INFO("segment peak %d\n",peak_amplitude);
live_nfr = fe_process_utt(fe, samples, nsamples, &mfcbuf); /**/
if (rawfp != NULL) {
fwrite(samples, sizeof(int16), nsamples, rawfp);
if (live_endutt)
fclose(rawfp);
}
if (live_endutt) {
/* RAH, It seems that we shouldn't throw out this data */
fe_end_utt(fe,dummyframe); /* Flush out the fe */
}
#if 0
E_INFO("Number frame after fe_process_utt %d\n",live_nfr);
for(i=0;i<live_nfr;i++){
printf("%d ",i);
for(j=0;j<13;j++){
printf("%f ",mfcbuf[i][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
}
#endif
/* lgalescu 2004/08/22 -- i am under the impression that
* feat_s2mfc2feat_block() needs to be called at the end of utt
* even if no frames need processing
*/
/* lgalescu 2004/10/13 -- rescinded the above */
if(live_nfr>0){
/* Compute feature vectors */
live_nfeatvec = feat_s2mfc2feat_block(kbcore_fcb(kbcore), mfcbuf,
live_nfr, live_begin_new_utt,
live_endutt, live_feat);
#if 0
E_INFO ("live_nfeatvec: %ld\n",live_nfeatvec);
#endif
#if 0
E_INFO("Current frame number %d, Number of frames %d, Number frame after feat_s2mfcfeat_block %d\n",frmno,live_nfr,live_nfeatvec);
for(i=0;i<live_nfeatvec;i++){
printf("%d\n",i);
printf("Cep: ");
fflush(stdout);
for(j=0;j<13;j++){
printf("%f ",live_feat[i][0][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
printf("Del: ");
fflush(stdout);
for(j=13;j<26;j++){
printf("%f ",live_feat[i][0][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
printf("Acc: ");
fflush(stdout);
for(j=26;j<39;j++){
printf("%f ",live_feat[i][0][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
}
#endif
/* decode the block */
utt_decode_block (live_feat, live_nfeatvec, &frmno, kb,
maxwpf, maxhistpf, maxhmmpf, ptranskip, hmmdumpfp);
/* lgalescu 2004/08/21
* moved the following block out of the previous if(){} because we need
* the output even when no feature computation has to be done.
*/
/* lgalescu 2004/10/13 -- rescinded */
/* Pull out partial hypothesis */
nwds = live_get_partialhyp(live_endutt);
*ohyp = parthyp;
parthyplen = nwds;
}
/* Clean up */
if (live_endutt) {
live_begin_new_utt = 1;
kb->tot_fr += kb->nfr;
utt_end(kb);
}
else {
live_begin_new_utt = 0;
}
/* I'm starting to think that fe_process_utt should not be allocating its
* memory, that or it should allocate some max and just keep on going,
* this idea of constantly allocating freeing memory seems dangerous to me.
*/
/* 20040318 ARCHAN : It sounds extremely dangerous to me and I will
* eliminate it sometime.
*/
/* lgalescu: i second that! the memory issue needs to be investigated: after a run on linux, i noticed some 1.6M of memory having "disappeared"! */
if(live_nfr>0){
ckd_free_2d((void **) mfcbuf); /* RAH, this must be freed since fe_process_utt allocates it */
}
return(parthyplen);
}
void
ld_process_raw_impl(live_decoder_t * _decoder,
int16 * samples, int32 num_samples, int32 end_utt)
{
float32 dummy_frame[MAX_CEP_LEN];
float32 **frames = 0;
int32 num_frames = 0;
int32 num_features = 0;
int32 begin_utt = _decoder->num_frames_entered == 0;
int32 return_value;
int i;
assert(_decoder != NULL);
if (begin_utt) {
fe_start_utt(_decoder->fe);
}
if (_decoder->swap) {
for (i = 0; i < num_samples; i++) {
SWAP_INT16(samples + i);
}
}
return_value =
fe_process_utt(_decoder->fe, samples, num_samples, &frames,
&num_frames);
if (end_utt) {
return_value = fe_end_utt(_decoder->fe, dummy_frame, &num_frames);
if (num_frames != 0) {
/* ARCHAN: If num_frames !=0, assign this last ending frame to
frames again. The computation will then be correct. Should
clean up the finite state logic in fe_interface layer.
*/
frames =
(float32 **) ckd_calloc_2d(1, _decoder->fe->NUM_CEPSTRA,
sizeof(float32));
memcpy(frames[0], dummy_frame,
_decoder->fe->NUM_CEPSTRA * sizeof(float32));
}
}
if (FE_ZERO_ENERGY_ERROR == return_value) {
E_WARN("Zero energy frame(s). Consider using dither\n");
}
if (num_frames > 0) {
num_features = feat_s2mfc2feat_block(kbcore_fcb(_decoder->kbcore),
frames,
num_frames,
begin_utt,
end_utt, _decoder->features);
_decoder->num_frames_entered += num_frames;
}
if (num_features > 0) {
utt_decode_block(_decoder->features,
num_features,
&_decoder->num_frames_decoded, &_decoder->kb);
}
if (frames != NULL) {
ckd_free_2d((void **) frames);
}
}
int
main(int32 argc, char *argv[])
{
char sent[16384];
cmd_ln_t *config;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
unlimit();
config = cmd_ln_get();
ctloffset = cmd_ln_int32_r(config, "-ctloffset");
sentfile = cmd_ln_str_r(config, "-insent");
if ((sentfp = fopen(sentfile, "r")) == NULL)
E_FATAL_SYSTEM("Failed to open file %s for reading", sentfile);
/* Note various output directories */
if (cmd_ln_str_r(config, "-s2stsegdir") != NULL)
s2stsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-s2stsegdir"));
if (cmd_ln_str_r(config, "-stsegdir") != NULL)
stsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-stsegdir"));
if (cmd_ln_str_r(config, "-phsegdir") != NULL)
phsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-phsegdir"));
if (cmd_ln_str_r(config, "-phlabdir") != NULL)
phlabdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-phlabdir"));
if (cmd_ln_str_r(config, "-wdsegdir") != NULL)
wdsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-wdsegdir"));
/* HACK! Pre-read insent without checking whether ctl could also
be read. In general, this is caused by the fact that we used
multiple files to specify resource in sphinx III. This is easy
to solve but currently I just to remove process_ctl because it
duplicates badly with ctl_process.
The call back function will take care of matching the uttfile
names. We don't need to worry too much about inconsistency.
*/
while (ctloffset > 0) {
if (fgets(sent, sizeof(sent), sentfp) == NULL) {
E_ERROR("EOF(%s)\n", sentfile);
break;
}
--ctloffset;
}
if ((outsentfile = cmd_ln_str_r(config, "-outsent")) != NULL) {
if ((outsentfp = fopen(outsentfile, "w")) == NULL)
E_FATAL_SYSTEM("Failed to open file %s for writing", outsentfile);
}
if ((outctlfile = cmd_ln_str_r(config, "-outctl")) != NULL) {
if ((outctlfp = fopen(outctlfile, "w")) == NULL)
E_FATAL_SYSTEM("Failed top open file %s for writing", outctlfile);
}
if ((cmd_ln_str_r(config, "-s2stsegdir") == NULL) &&
(cmd_ln_str_r(config, "-stsegdir") == NULL) &&
(cmd_ln_str_r(config, "-phlabdir") == NULL) &&
(cmd_ln_str_r(config, "-phsegdir") == NULL) &&
(cmd_ln_str_r(config, "-wdsegdir") == NULL) &&
(cmd_ln_str_r(config, "-outsent") == NULL))
E_FATAL("Missing output file/directory argument(s)\n");
/* Read in input databases */
models_init(config);
if (!feat)
feat = feat_array_alloc(kbcore_fcb(kbc), S3_MAX_FRAMES);
timers[tmr_utt].name = "U";
timers[tmr_gauden].name = "G";
timers[tmr_senone].name = "S";
timers[tmr_align].name = "A";
/* Initialize align module */
align_init(kbc->mdef, kbc->tmat, dict, config, kbc->logmath);
printf("\n");
if (cmd_ln_str_r(config, "-mllr") != NULL) {
if (kbc->mgau)
adapt_set_mllr(adapt_am, kbc->mgau, cmd_ln_str_r(config, "-mllr"), NULL,
kbc->mdef, config);
else if (kbc->ms_mgau)
model_set_mllr(kbc->ms_mgau, cmd_ln_str_r(config, "-mllr"), NULL, kbcore_fcb(kbc),
kbc->mdef, config);
else
E_WARN("Can't use MLLR matrices with .s2semi. yet\n");
}
tot_nfr = 0;
/* process_ctlfile (); */
if (cmd_ln_str_r(config, "-ctl")) {
/* When -ctlfile is speicified, corpus.c will look at -ctl_mllr to get
the corresponding MLLR for the utterance */
ctl_process(cmd_ln_str_r(config, "-ctl"),
NULL,
cmd_ln_str_r(config, "-ctl_mllr"),
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"),
utt_align, config);
}
else {
E_FATAL(" -ctl are not specified.\n");
}
if (tot_nfr > 0) {
printf("\n");
printf("TOTAL FRAMES: %8d\n", tot_nfr);
printf("TOTAL CPU TIME: %11.2f sec, %7.2f xRT\n",
tm_utt.t_tot_cpu, tm_utt.t_tot_cpu / (tot_nfr * 0.01));
printf("TOTAL ELAPSED TIME: %11.2f sec, %7.2f xRT\n",
tm_utt.t_tot_elapsed,
tm_utt.t_tot_elapsed / (tot_nfr * 0.01));
}
if (outsentfp)
fclose(outsentfp);
if (outctlfp)
fclose(outctlfp);
if (sentfp)
fclose(sentfp);
ckd_free(s2stsegdir);
ckd_free(stsegdir);
ckd_free(phsegdir);
ckd_free(wdsegdir);
feat_array_free(feat);
align_free();
models_free();
#if (! WIN32)
system("ps aguxwww | grep s3align");
#endif
cmd_ln_free_r(config);
return 0;
}
void
gmm_compute(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
kb_t *kb;
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
mgau_model_t *mgau;
subvq_t *svq;
gs_t *gs;
int32 ptranskip;
int32 s, f, t;
int32 single_el_list[2];
stats_t cur_ci_st;
stats_t cur_cd_st;
stats_t cur_cd_Nbest_st;
stats_t *stptr;
char str[100];
int32 *idx;
int32 *cur_bstidx;
int32 *last_bstidx;
int32 *cur_scr;
int32 *last_scr;
int32 tmpint;
s3senid_t *cd2cisen;
int32 pheurtype;
E_INFO("Processing: %s\n", uttid);
kb = (kb_t *) data;
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
d2p = kbcore_dict2pid(kbcore);
mgau = kbcore_mgau(kbcore);
svq = kbcore_svq(kbcore);
gs = kbcore_gs(kbcore);
kb->uttid = uttid;
ptranskip = kb->beam->ptranskip;
pheurtype = kb->pl->pheurtype;
single_el_list[0] = -1;
single_el_list[1] = -1;
/* Read mfc file and build feature vectors for entire utterance */
kb->stat->nfr =
feat_s2mfc2feat(kbcore_fcb(kbcore), ur->uttfile,
cmd_ln_str("-cepdir"), ".mfc", sf, ef, kb->feat,
S3_MAX_FRAMES);
cd2cisen = mdef_cd2cisen(mdef);
/*This should be a procedure instead of just logic */
init_stat(&cur_cd_st, "Current CD Senone");
init_stat(&cur_ci_st, "Current CI Senone");
init_stat(&cur_cd_Nbest_st, "Current CD NBest Senone");
for (s = 0; s < mdef->n_ci_sen; s++) {
sprintf(str, "Cur Senone %d", s);
init_stat(&cur_sen_st[s], str);
}
for (t = 0; t < (int32) (mdef->n_sen - mdef->n_ci_sen) / NBEST_STEP;
t++) {
sprintf(str, " %d -Cur Best Senone", t * NBEST_STEP);
init_stat(&cur_sen_Nbest_st[t], str);
}
idx = ckd_calloc(mdef->n_sen - mdef->n_ci_sen, sizeof(int32));
/* Allocate temporary array for CurScr and Curbst indx and Lat index */
cur_bstidx = ckd_calloc(mdef->n_sen, sizeof(int32));
last_bstidx = ckd_calloc(mdef->n_sen, sizeof(int32));
cur_scr = ckd_calloc(mdef->n_sen, sizeof(int32));
last_scr = ckd_calloc(mdef->n_sen, sizeof(int32));
for (f = 0; f < kb->stat->nfr; f++) {
for (s = 0; s < mgau->n_mgau; s++) {
/*1, Compute the approximate scores with the last best index. */
if (mgau->mgau[s].bstidx != NO_BSTIDX) {
single_el_list[0] = mgau->mgau[s].bstidx;
last_bstidx[s] = mgau->mgau[s].bstidx;
last_scr[s] =
mgau_eval(mgau, s, single_el_list, kb->feat[f][0], f,
0);
}
else {
last_bstidx[s] = NO_BSTIDX;
}
/*2, Compute the exact scores and sort them and get the ranking. */
kb->ascr->senscr[s] =
mgau_eval(mgau, s, NULL, kb->feat[f][0], f, 1);
/*3, Compute the approximate scores with the current best index */
if (mgau->mgau[s].bstidx != NO_BSTIDX) {
single_el_list[0] = mgau->mgau[s].bstidx;
cur_bstidx[s] = mgau->mgau[s].bstidx;
cur_scr[s] =
mgau_eval(mgau, s, single_el_list, kb->feat[f][0], f,
0);
}
else {
cur_bstidx[s] = NO_BSTIDX;
}
/* Only test for CD senones, test for best index hit */
/*Update either CI senone and CD senone) */
if (!mdef_is_cisenone(mdef, s))
stptr = &cur_cd_st;
else
stptr = &cur_ci_st;
increment_stat(stptr,
abs(last_scr[s] - kb->ascr->senscr[s]),
abs(cur_scr[s] - kb->ascr->senscr[s]),
abs(kb->ascr->senscr[cd2cisen[s]] -
kb->ascr->senscr[s]),
(cur_bstidx[s] == last_bstidx[s]));
if (!mdef_is_cisenone(mdef, s)) {
stptr = &cur_sen_st[cd2cisen[s]];
increment_stat(stptr,
abs(last_scr[s] - kb->ascr->senscr[s]),
abs(cur_scr[s] - kb->ascr->senscr[s]),
abs(kb->ascr->senscr[cd2cisen[s]] -
kb->ascr->senscr[s]),
(cur_bstidx[s] == last_bstidx[s]));
stptr->total_senone += 1;
}
}
cur_cd_st.total_fr++;
cur_cd_st.total_senone += mdef->n_sen - mdef->n_ci_sen;
cur_ci_st.total_fr++;
cur_ci_st.total_senone += mdef->n_ci_sen;
for (s = 0; s < mdef->n_ci_sen; s++) {
cur_sen_st[s].total_fr++;
}
/*This is the part we need to do sorting */
/*1, sort the scores in the current frames */
/*E_INFO("At frame %d\n",f); */
/*Pointer trick at here. */
for (s = 0; s < mdef->n_sen - mdef->n_ci_sen; s++) {
idx[s] = s;
}
cd = &(kb->ascr->senscr[mdef->n_ci_sen]);
qsort(idx, mdef->n_sen - mdef->n_ci_sen, sizeof(int32),
intcmp_gmm_compute);
/*This loop is stupid and it is just a hack. */
for (s = 0; s < mdef->n_sen - mdef->n_ci_sen; s++) {
tmpint = idx[s] + mdef->n_ci_sen;
for (t = 0;
t <
(int32) ((float) (mdef->n_sen - mdef->n_ci_sen) /
(float) NBEST_STEP); t++) {
if (s < t * NBEST_STEP) {
increment_stat(&cur_sen_Nbest_st[t],
abs(last_scr[tmpint] -
kb->ascr->senscr[tmpint]),
abs(cur_scr[tmpint] -
kb->ascr->senscr[tmpint]),
abs(kb->ascr->senscr[cd2cisen[tmpint]] -
kb->ascr->senscr[tmpint]),
(cur_bstidx[tmpint] ==
last_bstidx[tmpint]));
cur_sen_Nbest_st[t].total_senone += 1;
}
}
}
for (t = 0;
t <
(int32) ((float) (mdef->n_sen - mdef->n_ci_sen) /
(float) NBEST_STEP); t++) {
cur_sen_Nbest_st[t].total_fr++;
}
}
print_stat(&cur_cd_st);
print_stat(&cur_ci_st);
print_stat(&cur_sen_Nbest_st[1]); /*Only show the first NBEST_STEP best */
add_stat(&cd_st, &cur_cd_st);
add_stat(&ci_st, &cur_ci_st);
for (s = 0; s < mdef->n_ci_sen; s++) {
add_stat(&sen_st[s], &cur_sen_st[s]);
}
for (s = 0; s < (int32) (mdef->n_sen - mdef->n_ci_sen) / NBEST_STEP;
s++) {
add_stat(&sen_Nbest_st[s], &cur_sen_Nbest_st[s]);
}
ckd_free(idx);
ckd_free(cur_bstidx);
ckd_free(last_bstidx);
ckd_free(cur_scr);
ckd_free(last_scr);
}
