static int
acmod_init_feat(acmod_t *acmod)
{
acmod->fcb =
feat_init(cmd_ln_str_r(acmod->config, "-feat"),
cmn_type_from_str(cmd_ln_str_r(acmod->config,"-cmn")),
cmd_ln_boolean_r(acmod->config, "-varnorm"),
agc_type_from_str(cmd_ln_str_r(acmod->config, "-agc")),
1, cmd_ln_int32_r(acmod->config, "-ceplen"));
if (acmod->fcb == NULL)
return -1;
if (cmd_ln_str_r(acmod->config, "-lda")) {
E_INFO("Reading linear feature transformation from %s\n",
cmd_ln_str_r(acmod->config, "-lda"));
if (feat_read_lda(acmod->fcb,
cmd_ln_str_r(acmod->config, "-lda"),
cmd_ln_int32_r(acmod->config, "-ldadim")) < 0)
return -1;
}
if (cmd_ln_str_r(acmod->config, "-svspec")) {
int32 **subvecs;
E_INFO("Using subvector specification %s\n",
cmd_ln_str_r(acmod->config, "-svspec"));
if ((subvecs = parse_subvecs(cmd_ln_str_r(acmod->config, "-svspec"))) == NULL)
return -1;
if ((feat_set_subvecs(acmod->fcb, subvecs)) < 0)
return -1;
}
if (cmd_ln_exists_r(acmod->config, "-agcthresh")
&& 0 != strcmp(cmd_ln_str_r(acmod->config, "-agc"), "none")) {
agc_set_threshold(acmod->fcb->agc_struct,
cmd_ln_float32_r(acmod->config, "-agcthresh"));
}
if (acmod->fcb->cmn_struct
&& cmd_ln_exists_r(acmod->config, "-cmninit")) {
char *c, *cc, *vallist;
int32 nvals;
vallist = ckd_salloc(cmd_ln_str_r(acmod->config, "-cmninit"));
c = vallist;
nvals = 0;
while (nvals < acmod->fcb->cmn_struct->veclen
&& (cc = strchr(c, ',')) != NULL) {
*cc = '\0';
acmod->fcb->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof_c(c));
c = cc + 1;
++nvals;
}
if (nvals < acmod->fcb->cmn_struct->veclen && *c != '\0') {
acmod->fcb->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof_c(c));
}
ckd_free(vallist);
}
return 0;
}
ngram_model_t *
ngram_model_read(cmd_ln_t * config,
const char *file_name,
ngram_file_type_t file_type, logmath_t * lmath)
{
ngram_model_t *model = NULL;
switch (file_type) {
case NGRAM_AUTO:{
if ((model =
ngram_model_trie_read_bin(config, file_name,
lmath)) != NULL)
break;
if ((model =
ngram_model_trie_read_arpa(config, file_name,
lmath)) != NULL)
break;
if ((model =
ngram_model_trie_read_dmp(config, file_name,
lmath)) != NULL)
break;
return NULL;
}
case NGRAM_ARPA:
model = ngram_model_trie_read_arpa(config, file_name, lmath);
break;
case NGRAM_BIN:
if ((model =
ngram_model_trie_read_bin(config, file_name, lmath)) != NULL)
break;
if ((model =
ngram_model_trie_read_dmp(config, file_name, lmath)) != NULL)
break;
return NULL;
default:
E_ERROR("language model file type not supported\n");
return NULL;
}
/* Now set weights based on config if present. */
if (config) {
float32 lw = 1.0;
float32 wip = 1.0;
if (cmd_ln_exists_r(config, "-lw"))
lw = cmd_ln_float32_r(config, "-lw");
if (cmd_ln_exists_r(config, "-wip"))
wip = cmd_ln_float32_r(config, "-wip");
ngram_model_apply_weights(model, lw, wip);
}
return model;
}
glist_t
srch_FLAT_FWD_nbest_impl(void *srch, /**< A void pointer to a search structure */
dag_t * dag)
{
srch_t *s;
srch_FLAT_FWD_graph_t *fwg;
float32 bestpathlw;
float64 lwf;
char str[2000];
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
assert(fwg->lathist);
if (!(cmd_ln_exists_r(kbcore_config(fwg->kbcore), "-nbestdir")
&& cmd_ln_str_r(kbcore_config(fwg->kbcore), "-nbestdir")))
return NULL;
ctl_outfile(str, cmd_ln_str_r(kbcore_config(fwg->kbcore), "-nbestdir"),
cmd_ln_str_r(kbcore_config(fwg->kbcore), "-nbestext"),
(s->uttfile ? s->uttfile : s->uttid), s->uttid,
cmd_ln_boolean_r(kbcore_config(fwg->kbcore), "-build_outdirs"));
bestpathlw = cmd_ln_float32_r(kbcore_config(fwg->kbcore), "-bestpathlw");
lwf = bestpathlw ? (bestpathlw / cmd_ln_float32_r(kbcore_config(fwg->kbcore), "-lw")) : 1.0;
flat_fwd_dag_add_fudge_edges(fwg,
dag,
cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-dagfudge"),
cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-min_endfr"),
(void *) fwg->lathist, s->kbc->dict);
/* Bypass filler nodes */
if (!dag->filler_removed) {
/* If Viterbi search terminated in filler word coerce final DAG node to FINISH_WORD */
if (dict_filler_word(s->kbc->dict, dag->end->wid))
dag->end->wid = s->kbc->dict->finishwid;
dag_remove_unreachable(dag);
if (dag_bypass_filler_nodes(dag, lwf, s->kbc->dict, s->kbc->fillpen) < 0)
E_ERROR("maxedge limit (%d) exceeded\n", dag->maxedge);
}
dag_compute_hscr(dag, kbcore_dict(s->kbc), kbcore_lm(s->kbc), lwf);
dag_remove_bypass_links(dag);
dag->filler_removed = 0;
nbest_search(dag, str, s->uttid, lwf,
kbcore_dict(s->kbc),
kbcore_lm(s->kbc), kbcore_fillpen(s->kbc)
);
return NULL;
}
SWIGINTERN bool Config_exists(Config *self,char const *key){
return cmd_ln_exists_r(self, key);
}
cmd_ln_t *
cmd_ln_parse_r(cmd_ln_t *inout_cmdln, const arg_t * defn, int32 argc, char *argv[], int strict)
{
int32 i, j, n, argstart;
hash_table_t *defidx = NULL;
cmd_ln_t *cmdln;
/* Construct command-line object */
if (inout_cmdln == NULL) {
cmdln = ckd_calloc(1, sizeof(*cmdln));
cmdln->refcount = 1;
}
else
cmdln = inout_cmdln;
/* Build a hash table for argument definitions */
defidx = hash_table_new(50, 0);
if (defn) {
for (n = 0; defn[n].name; n++) {
void *v;
v = hash_table_enter(defidx, defn[n].name, (void *)&defn[n]);
if (strict && (v != &defn[n])) {
E_ERROR("Duplicate argument name in definition: %s\n", defn[n].name);
goto error;
}
}
}
else {
/* No definitions. */
n = 0;
}
/* Allocate memory for argument values */
if (cmdln->ht == NULL)
cmdln->ht = hash_table_new(n, 0 /* argument names are case-sensitive */ );
/* skip argv[0] if it doesn't start with dash */
argstart = 0;
if (argc > 0 && argv[0][0] != '-') {
argstart = 1;
}
/* Parse command line arguments (name-value pairs) */
for (j = argstart; j < argc; j += 2) {
arg_t *argdef;
cmd_ln_val_t *val;
void *v;
if (hash_table_lookup(defidx, argv[j], &v) < 0) {
if (strict) {
E_ERROR("Unknown argument name '%s'\n", argv[j]);
goto error;
}
else if (defn == NULL)
v = NULL;
else
continue;
}
argdef = v;
/* Enter argument value */
if (j + 1 >= argc) {
cmd_ln_print_help_r(cmdln, stderr, defn);
E_ERROR("Argument value for '%s' missing\n", argv[j]);
goto error;
}
if (argdef == NULL)
val = cmd_ln_val_init(ARG_STRING, argv[j + 1]);
else {
if ((val = cmd_ln_val_init(argdef->type, argv[j + 1])) == NULL) {
cmd_ln_print_help_r(cmdln, stderr, defn);
E_ERROR("Bad argument value for %s: %s\n", argv[j],
argv[j + 1]);
goto error;
}
}
#import "OpenEarsStaticAnalysisToggle.h"
#ifdef STATICANALYZEDEPENDENCIES
#define __clang_analyzer__ 1
#endif
#if !defined(__clang_analyzer__) || defined(STATICANALYZEDEPENDENCIES)
#undef __clang_analyzer__
if ((v = hash_table_enter(cmdln->ht, argv[j], (void *)val)) != (void *)val) {
if (strict) {
cmd_ln_val_free(val);
E_ERROR("Duplicate argument name in arguments: %s\n",
argdef->name);
goto error;
}
else {
v = hash_table_replace(cmdln->ht, argv[j], (void *)val);
cmd_ln_val_free((cmd_ln_val_t *)v);
}
}
}
#endif
/* Fill in default values, if any, for unspecified arguments */
for (i = 0; i < n; i++) {
cmd_ln_val_t *val;
void *v;
if (hash_table_lookup(cmdln->ht, defn[i].name, &v) < 0) {
if ((val = cmd_ln_val_init(defn[i].type, defn[i].deflt)) == NULL) {
E_ERROR
("Bad default argument value for %s: %s\n",
defn[i].name, defn[i].deflt);
goto error;
}
hash_table_enter(cmdln->ht, defn[i].name, (void *)val);
}
}
/* Check for required arguments; exit if any missing */
j = 0;
for (i = 0; i < n; i++) {
if (defn[i].type & ARG_REQUIRED) {
void *v;
if (hash_table_lookup(cmdln->ht, defn[i].name, &v) != 0)
E_ERROR("Missing required argument %s\n", defn[i].name);
}
}
if (j > 0) {
cmd_ln_print_help_r(cmdln, stderr, defn);
goto error;
}
if (strict && argc == 1) {
E_ERROR("No arguments given, available options are:\n");
cmd_ln_print_help_r(cmdln, stderr, defn);
if (defidx)
hash_table_free(defidx);
if (inout_cmdln == NULL)
cmd_ln_free_r(cmdln);
return NULL;
}
#ifndef _WIN32_WCE
if(verbose_cmuclmtk == 1 || verbose_pocketsphinx == 1) {
/* Set up logging. We need to do this earlier because we want to dump
* the information to the configured log, not to the stderr. */
if (cmd_ln_exists_r(cmdln, "-logfn") && cmd_ln_str_r(cmdln, "-logfn"))
err_set_logfile(cmd_ln_str_r(cmdln, "-logfn"));
/* Echo command line */
E_INFO("Parsing command line:\n");
for (i = 0; i < argc; i++) {
if (argv[i][0] == '-')
E_INFOCONT("\\\n\t");
E_INFOCONT("%s ", argv[i]);
}
E_INFOCONT("\n\n");
fflush(stderr);
/* Print configuration */
E_INFOCONT("Current configuration:\n");
arg_dump_r(cmdln, err_get_logfp(), defn, 0);
}
#endif
hash_table_free(defidx);
return cmdln;
error:
if (defidx)
hash_table_free(defidx);
if (inout_cmdln == NULL)
cmd_ln_free_r(cmdln);
E_ERROR("Failed to parse arguments list\n");
return NULL;
}
dict_t *
dict_init(cmd_ln_t *config, bin_mdef_t * mdef)
{
FILE *fp, *fp2;
int32 n;
lineiter_t *li;
dict_t *d;
s3cipid_t sil;
char const *dictfile = NULL, *fillerfile = NULL;
if (config) {
dictfile = cmd_ln_str_r(config, "-dict");
fillerfile = cmd_ln_str_r(config, "-fdict");
}
/*
* First obtain #words in dictionary (for hash table allocation).
* Reason: The PC NT system doesn't like to grow memory gradually. Better to allocate
* all the required memory in one go.
*/
fp = NULL;
n = 0;
if (dictfile) {
if ((fp = fopen(dictfile, "r")) == NULL)
E_FATAL_SYSTEM("Failed to open dictionary file '%s' for reading", dictfile);
for (li = lineiter_start(fp); li; li = lineiter_next(li)) {
if (li->buf[0] != '#')
n++;
}
rewind(fp);
}
fp2 = NULL;
if (fillerfile) {
if ((fp2 = fopen(fillerfile, "r")) == NULL)
E_FATAL_SYSTEM("Failed to open filler dictionary file '%s' for reading", fillerfile);
for (li = lineiter_start(fp2); li; li = lineiter_next(li)) {
if (li->buf[0] != '#')
n++;
}
rewind(fp2);
}
/*
* Allocate dict entries. HACK!! Allow some extra entries for words not in file.
* Also check for type size restrictions.
*/
d = (dict_t *) ckd_calloc(1, sizeof(dict_t)); /* freed in dict_free() */
d->refcnt = 1;
d->max_words =
(n + S3DICT_INC_SZ < MAX_S3WID) ? n + S3DICT_INC_SZ : MAX_S3WID;
if (n >= MAX_S3WID)
E_FATAL("#Words in dictionaries (%d) exceeds limit (%d)\n", n,
MAX_S3WID);
E_INFO("Allocating %d * %d bytes (%d KiB) for word entries\n",
d->max_words, sizeof(dictword_t),
d->max_words * sizeof(dictword_t) / 1024);
d->word = (dictword_t *) ckd_calloc(d->max_words, sizeof(dictword_t)); /* freed in dict_free() */
d->n_word = 0;
if (mdef)
d->mdef = bin_mdef_retain(mdef);
/* Create new hash table for word strings; case-insensitive word strings */
if (config && cmd_ln_exists_r(config, "-dictcase"))
d->nocase = cmd_ln_boolean_r(config, "-dictcase");
d->ht = hash_table_new(d->max_words, d->nocase);
/* Digest main dictionary file */
if (fp) {
E_INFO("Reading main dictionary: %s\n", dictfile);
dict_read(fp, d);
fclose(fp);
E_INFO("%d words read\n", d->n_word);
}
/* Now the filler dictionary file, if it exists */
d->filler_start = d->n_word;
if (fillerfile) {
E_INFO("Reading filler dictionary: %s\n", fillerfile);
dict_read(fp2, d);
fclose(fp2);
E_INFO("%d words read\n", d->n_word - d->filler_start);
}
if (mdef)
sil = bin_mdef_silphone(mdef);
else
sil = 0;
if (dict_wordid(d, S3_START_WORD) == BAD_S3WID) {
dict_add_word(d, S3_START_WORD, &sil, 1);
}
if (dict_wordid(d, S3_FINISH_WORD) == BAD_S3WID) {
dict_add_word(d, S3_FINISH_WORD, &sil, 1);
}
if (dict_wordid(d, S3_SILENCE_WORD) == BAD_S3WID) {
dict_add_word(d, S3_SILENCE_WORD, &sil, 1);
}
d->filler_end = d->n_word - 1;
/* Initialize distinguished word-ids */
d->startwid = dict_wordid(d, S3_START_WORD);
d->finishwid = dict_wordid(d, S3_FINISH_WORD);
d->silwid = dict_wordid(d, S3_SILENCE_WORD);
if ((d->filler_start > d->filler_end)
|| (!dict_filler_word(d, d->silwid)))
E_FATAL("%s must occur (only) in filler dictionary\n",
S3_SILENCE_WORD);
/* No check that alternative pronunciations for filler words are in filler range!! */
return d;
}
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);
}
}
}
static void
models_init(cmd_ln_t *config)
{
int32 cisencnt;
kbc = New_kbcore(config);
kbc->logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1,
cmd_ln_int32_r(config, "-log3table"));
/* Initialize feaure stream type */
kbc->fcb = feat_init(cmd_ln_str_r(config, "-feat"),
cmn_type_from_str(cmd_ln_str_r(config, "-cmn")),
cmd_ln_boolean_r(config, "-varnorm"),
agc_type_from_str(cmd_ln_str_r(config, "-agc")), 1,
cmd_ln_int32_r(config, "-ceplen"));
s3_am_init(kbc);
/* Initialize the front end if -adcin is specified */
if (cmd_ln_exists_r(config, "-adcin") && cmd_ln_boolean_r(config, "-adcin")) {
if ((fe = fe_init_auto_r(config)) == NULL) {
E_FATAL("fe_init_auto_r() failed\n");
}
}
assert(kbc);
assert(kbc->mdef);
assert(kbc->tmat);
/* Dictionary */
dict = dict_init(kbc->mdef, cmd_ln_str_r(config, "-dict"),
cmd_ln_str_r(config, "-fdict"),
cmd_ln_int32_r(config, "-lts_mismatch"),
cmd_ln_boolean_r(config, "-mdef_fillers"),
/* Never do mdef filler phones. */
FALSE,
TRUE);
for (cisencnt = 0; cisencnt == kbc->mdef->cd2cisen[cisencnt];
cisencnt++);
ascr = ascr_init(kbc->mdef->n_sen, 0, /* No composite senone */
mdef_n_sseq(kbc->mdef), 0, /* No composite senone sequence */
1, /* Phoneme lookahead window =1. Not enabled phoneme lookahead at this moment */
cisencnt);
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"),
kbc->mdef->n_ci_sen,
kbc->logmath);
adapt_am = adapt_am_init();
}
SWIGINTERN bool cmd_ln_s_exists(struct cmd_ln_s *self,char const *key){
return cmd_ln_exists_r(self, key);
}
