int
main(int argc, char *argv[])
{
logmath_t *lmath;
fsg_model_t *fsg;
jsgf_t *jsgf;
jsgf_rule_t *rule;
lmath = logmath_init(1.0001, 0, 0);
/* Test loading */
jsgf = jsgf_parse_file(LMDIR "/polite.gram", NULL);
TEST_ASSERT(jsgf);
rule = jsgf_get_rule(jsgf, "polite.startPolite");
TEST_ASSERT(rule);
fsg = jsgf_build_fsg(jsgf, rule, lmath, 7.5);
TEST_ASSERT(fsg);
TEST_EQUAL_STRING("polite", jsgf_grammar_name(jsgf));
TEST_ASSERT(fsg_model_add_silence(fsg, "<sil>", -1, 0.3));
TEST_ASSERT(fsg_model_add_silence(fsg, "++NOISE++", -1, 0.3));
TEST_ASSERT(fsg_model_add_alt(fsg, "please", "please(2)"));
jsgf_grammar_free(jsgf);
fsg_model_write(fsg, stdout);
fsg_model_free(fsg);
/* Or do everything at once */
fsg = jsgf_read_file(LMDIR "/public.gram", lmath, 1.0);
fsg_model_free(fsg);
/* Test grammar with keywords inside */
jsgf = jsgf_parse_file(LMDIR "/public.gram", NULL);
TEST_ASSERT(jsgf);
jsgf_grammar_free(jsgf);
jsgf = jsgf_parse_string("#JSGF V1.0; grammar test; public <choice> = yes | no;", NULL);
TEST_ASSERT(jsgf);
rule = jsgf_get_rule(jsgf, "test.choice");
TEST_ASSERT(rule);
fsg = jsgf_build_fsg(jsgf, rule, lmath, 7.5);
fsg_model_write(fsg, stdout);
fsg_model_free(fsg);
jsgf_grammar_free(jsgf);
logmath_free(lmath);
return 0;
}
int
ps_set_jsgf_file(ps_decoder_t *ps, const char *name, const char *path)
{
fsg_model_t *fsg;
jsgf_rule_t *rule;
char const *toprule;
jsgf_t *jsgf = jsgf_parse_file(path, NULL);
float lw;
int result;
if (!jsgf)
return -1;
rule = NULL;
/* Take the -toprule if specified. */
if ((toprule = cmd_ln_str_r(ps->config, "-toprule"))) {
rule = jsgf_get_rule(jsgf, toprule);
if (rule == NULL) {
E_ERROR("Start rule %s not found\n", toprule);
return -1;
}
} else {
rule = jsgf_get_public_rule(jsgf);
if (rule == NULL) {
E_ERROR("No public rules found in %s\n", path);
return -1;
}
}
lw = cmd_ln_float32_r(ps->config, "-lw");
fsg = jsgf_build_fsg(jsgf, rule, ps->lmath, lw);
result = ps_set_fsg(ps, name, fsg);
fsg_model_free(fsg);
return result;
}
fsg_model_t *
jsgf_read_file(const char *file, logmath_t * lmath, float32 lw)
{
fsg_model_t *fsg;
jsgf_rule_t *rule;
jsgf_t *jsgf;
jsgf_rule_iter_t *itor;
if ((jsgf = jsgf_parse_file(file, NULL)) == NULL) {
E_ERROR("Error parsing file: %s\n", file);
return NULL;
}
rule = NULL;
for (itor = jsgf_rule_iter(jsgf); itor;
itor = jsgf_rule_iter_next(itor)) {
rule = jsgf_rule_iter_rule(itor);
if (jsgf_rule_public(rule)) {
jsgf_rule_iter_free(itor);
break;
}
}
if (rule == NULL) {
E_ERROR("No public rules found in %s\n", file);
return NULL;
}
fsg = jsgf_build_fsg(jsgf, rule, lmath, lw);
jsgf_grammar_free(jsgf);
return fsg;
}
int
main(int argc, char *argv[])
{
jsgf_t *jsgf;
fsg_model_t *fsg;
cmd_ln_t *config;
const char *rule;
if ((config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE)) == NULL)
return 1;
if (cmd_ln_boolean_r(config, "-help")) {
usagemsg(argv[0]);
}
jsgf = jsgf_parse_file(cmd_ln_str_r(config, "-jsgf"), NULL);
if (jsgf == NULL) {
return 1;
}
rule = cmd_ln_str_r(config, "-toprule") ? cmd_ln_str_r(config, "-toprule") : NULL;
if (!(fsg = get_fsg(jsgf, rule))) {
E_ERROR("No fsg was built for the given rule '%s'.\n"
"Check rule name; it should be qualified (with grammar name)\n"
"and not enclosed in angle brackets (e.g. 'grammar.rulename').",
rule);
return 1;
}
if (cmd_ln_boolean_r(config, "-compile")) {
fsg_model_null_trans_closure(fsg, NULL);
}
if (cmd_ln_str_r(config, "-fsm")) {
const char* outfile = cmd_ln_str_r(config, "-fsm");
const char* symfile = cmd_ln_str_r(config, "-symtab");
if (outfile)
fsg_model_writefile_fsm(fsg, outfile);
else
fsg_model_write_fsm(fsg, stdout);
if (symfile)
fsg_model_writefile_symtab(fsg, symfile);
}
else {
const char *outfile = cmd_ln_str_r(config, "-fsg");
if (outfile)
fsg_model_writefile(fsg, outfile);
else
fsg_model_write(fsg, stdout);
}
fsg_model_free(fsg);
jsgf_grammar_free(jsgf);
return 0;
}
int
main(int argc, char *argv[])
{
jsgf_t *jsgf;
fsg_model_t *fsg;
cmd_ln_t *config;
if ((config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE)) == NULL)
return 1;
if (cmd_ln_boolean_r(config, "-help")) {
usagemsg(argv[0]);
}
jsgf = jsgf_parse_file(cmd_ln_str_r(config, "-jsgf"), NULL);
if (jsgf == NULL) {
return 1;
}
fsg = get_fsg(jsgf, cmd_ln_str_r(config, "-rule") ? cmd_ln_str_r(config, "-rule") : NULL);
if (cmd_ln_boolean_r(config, "-compile")) {
fsg_model_null_trans_closure(fsg, NULL);
}
if (cmd_ln_str_r(config, "-fsm")) {
const char* outfile = cmd_ln_str_r(config, "-fsm");
const char* symfile = cmd_ln_str_r(config, "-symtab");
if (outfile)
fsg_model_writefile_fsm(fsg, outfile);
else
fsg_model_write_fsm(fsg, stdout);
if (symfile)
fsg_model_writefile_symtab(fsg, symfile);
}
else {
const char *outfile = cmd_ln_str_r(config, "-fsg");
if (outfile)
fsg_model_writefile(fsg, outfile);
else
fsg_model_write(fsg, stdout);
}
fsg_model_free(fsg);
jsgf_grammar_free(jsgf);
return 0;
}
int ps_set_jsgf_file(ps_decoder_t *ps, const char *name, const char *path)
{
fsg_model_t *fsg;
jsgf_rule_t *rule;
char const *toprule;
jsgf_t *jsgf = jsgf_parse_file(path, NULL);
float lw;
int result;
if (!jsgf)
return -1;
rule = NULL;
/* Take the -toprule if specified. */
if ((toprule = cmd_ln_str_r(ps->config, "-toprule"))) {
char *ruletok;
ruletok = string_join("<", toprule, ">", NULL);
rule = jsgf_get_rule(jsgf, ruletok);
ckd_free(ruletok);
if (rule == NULL) {
E_ERROR("Start rule %s not found\n", toprule);
return -1;
}
} else {
/* Otherwise, take the first public rule. */
jsgf_rule_iter_t *itor;
for (itor = jsgf_rule_iter(jsgf); itor;
itor = jsgf_rule_iter_next(itor)) {
rule = jsgf_rule_iter_rule(itor);
if (jsgf_rule_public(rule)) {
jsgf_rule_iter_free(itor);
break;
}
}
if (rule == NULL) {
E_ERROR("No public rules found in %s\n", path);
return -1;
}
}
lw = cmd_ln_float32_r(ps->config, "-lw");
fsg = jsgf_build_fsg(jsgf, rule, ps->lmath, lw);
result = ps_set_fsg(ps, name, fsg);
fsg_model_free(fsg);
return result;
}
static void
test_set_search()
{
cmd_ln_t *config = default_config();
ps_decoder_t *ps = ps_init(config);
ps_search_iter_t *itor;
jsgf_t *jsgf = jsgf_parse_file(DATADIR "/goforward.gram", NULL);
fsg_model_t *fsg = jsgf_build_fsg(jsgf,
jsgf_get_rule(jsgf, "goforward.move"),
ps->lmath, cmd_ln_int32_r(config, "-lw"));
TEST_ASSERT(!ps_set_fsg(ps, "goforward", fsg));
fsg_model_free(fsg);
TEST_ASSERT(!ps_set_jsgf_file(ps, "goforward_other", DATADIR "/goforward.gram"));
ngram_model_t *lm = ngram_model_read(config, DATADIR "/tidigits/lm/tidigits.lm.dmp",
NGRAM_AUTO, ps->lmath);
TEST_ASSERT(!ps_set_lm(ps, "tidigits", lm));
ngram_model_free(lm);
TEST_ASSERT(!ps_set_search(ps, "tidigits"));
TEST_ASSERT(!ps_set_search(ps, "goforward"));
itor = ps_search_iter(ps);
TEST_EQUAL(0, strcmp("goforward_other", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(0, strcmp("tidigits", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(0, strcmp("goforward", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(0, strcmp("phone_loop", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(NULL, itor);
TEST_ASSERT(!ps_start_utt(ps));
TEST_ASSERT(!ps_end_utt(ps));
ps_free(ps);
cmd_ln_free_r(config);
}
int ofxSphinxASR::engineInit(ofAsrEngineArgs *e)
{
#if defined TARGET_WIN32
char cfg_filename[] = "sphinx.cfg";
char grammarJSGF_filename[] = "grammar.jsgf";
char grammarFSG_filename[] = "grammar.fsg";
#else
char cfg_filename[] = "/tmp/sphinx.cfg";
char grammarJSGF_filename[] = "/tmp/grammar.jsgf";
char grammarFSG_filename[] = "/tmp/grammar.fsg";
#endif
FILE *cfg_fp = fopen(cfg_filename, "wt");
if (cfg_fp==NULL)
return OFXASR_FAIL_WRITE_CONFIG;
if ( access(e->sphinxmodel_am.c_str(), 0) != 0 )
return OFXASR_FAIL_READ_FILES;
if ( access(e->sphinxmodel_lm.c_str(), 0) != 0 )
return OFXASR_FAIL_READ_FILES;
if ( access(e->sphinxmodel_dict.c_str(), 0) != 0 )
return OFXASR_FAIL_READ_FILES;
if ( access(e->sphinxmodel_fdict.c_str(), 0) != 0 )
return OFXASR_FAIL_READ_FILES;
char cur_path[1024];
getcwd(cur_path, 1024);
fprintf(cfg_fp, "-samprate %d\n", e->samplerate);
fprintf(cfg_fp, "-hmm %s/%s\n", cur_path, e->sphinxmodel_am.c_str());
fprintf(cfg_fp, "-dict %s/%s\n", cur_path, e->sphinxmodel_dict.c_str());
fprintf(cfg_fp, "-fdict %s/%s\n", cur_path, e->sphinxmodel_fdict.c_str());
fprintf(cfg_fp, "-lm %s/%s\n", cur_path, e->sphinxmodel_lm.c_str());
if (e->sphinx_mode == 2) {
if(e->sphinx_candidate_sentences.size() < 1) {
printf("Warning: The word list is empty! Use mode 4.\n");
e->sphinx_mode = 4;
}
else {
FILE *gram_fp = fopen(grammarJSGF_filename, "wt");
if (gram_fp==NULL)
return OFXASR_FAIL_WRITE_CONFIG;
fprintf(gram_fp,
"#JSGF V1.0;\n\ngrammar cca_gram;\n\npublic <cca_gram> = (\n");
for (int i=0; i<e->sphinx_candidate_sentences.size()-1; i++) {
fprintf(gram_fp, "%s |\n",
e->sphinx_candidate_sentences[i].c_str());
}
fprintf(gram_fp, "%s );\n\n",
e->sphinx_candidate_sentences[e->sphinx_candidate_sentences.size()-1].c_str());
fclose(gram_fp);
}
jsgf_t *jsgf = jsgf_parse_file(grammarJSGF_filename, NULL);
if (jsgf == NULL) {
printf("Bad jsgf file %s.\n", grammarJSGF_filename);
return OFXASR_INVALID_JSGF_GRAMMAR;
}
fsg_model_t *fsg = get_fsg(jsgf, NULL);
fsg_model_writefile(fsg, grammarFSG_filename);
fsg_model_free(fsg);
jsgf_grammar_free(jsgf);
fprintf(cfg_fp, "-fsg %s\n", grammarFSG_filename);
}
fprintf(cfg_fp, "-op_mode %d\n", e->sphinx_mode);
fclose(cfg_fp);
err_set_logfp(NULL); // disable logs
cmd_ln_t *config = NULL;
config = cmd_ln_parse_file_r(config, S3_DECODE_ARG_DEFS, cfg_filename, TRUE);
if (config == NULL) {
return OFXASR_INVALID_CONFIG;
}
decoder = new s3_decode_t;
if (s3_decode_init(decoder, config) != S3_DECODE_SUCCESS) {
return OFXASR_FAIL_INIT_DECODER;
}
fe = fe_init_auto_r(config);
if (fe == NULL) {
return OFXASR_FAIL_INIT_FRONTEND;
}
bEngineInitialed = true;
return OFXASR_SUCCESS;
}
int
ps_reinit(ps_decoder_t *ps, cmd_ln_t *config)
{
const char *path;
const char *keyword_list;
int32 lw;
if (config && config != ps->config) {
cmd_ln_free_r(ps->config);
ps->config = cmd_ln_retain(config);
}
err_set_debug_level(cmd_ln_int32_r(ps->config, "-debug"));
ps->mfclogdir = cmd_ln_str_r(ps->config, "-mfclogdir");
ps->rawlogdir = cmd_ln_str_r(ps->config, "-rawlogdir");
ps->senlogdir = cmd_ln_str_r(ps->config, "-senlogdir");
/* Fill in some default arguments. */
ps_init_defaults(ps);
/* Free old searches (do this before other reinit) */
ps_free_searches(ps);
ps->searches = hash_table_new(3, HASH_CASE_YES);
/* Free old acmod. */
acmod_free(ps->acmod);
ps->acmod = NULL;
/* Free old dictionary (must be done after the two things above) */
dict_free(ps->dict);
ps->dict = NULL;
/* Free d2p */
dict2pid_free(ps->d2p);
ps->d2p = NULL;
/* Logmath computation (used in acmod and search) */
if (ps->lmath == NULL
|| (logmath_get_base(ps->lmath) !=
(float64)cmd_ln_float32_r(ps->config, "-logbase"))) {
if (ps->lmath)
logmath_free(ps->lmath);
ps->lmath = logmath_init
((float64)cmd_ln_float32_r(ps->config, "-logbase"), 0,
cmd_ln_boolean_r(ps->config, "-bestpath"));
}
/* Acoustic model (this is basically everything that
* uttproc.c, senscr.c, and others used to do) */
if ((ps->acmod = acmod_init(ps->config, ps->lmath, NULL, NULL)) == NULL)
return -1;
if ((ps->pl_window = cmd_ln_int32_r(ps->config, "-pl_window"))) {
/* Initialize an auxiliary phone loop search, which will run in
* "parallel" with FSG or N-Gram search. */
if ((ps->phone_loop =
phone_loop_search_init(ps->config, ps->acmod, ps->dict)) == NULL)
return -1;
hash_table_enter(ps->searches,
ckd_salloc(ps_search_name(ps->phone_loop)),
ps->phone_loop);
}
/* Dictionary and triphone mappings (depends on acmod). */
/* FIXME: pass config, change arguments, implement LTS, etc. */
if ((ps->dict = dict_init(ps->config, ps->acmod->mdef)) == NULL)
return -1;
if ((ps->d2p = dict2pid_build(ps->acmod->mdef, ps->dict)) == NULL)
return -1;
lw = cmd_ln_float32_r(config, "-lw");
/* Determine whether we are starting out in FSG or N-Gram search mode.
* If neither is used skip search initialization. */
/* Load KWS if one was specified in config */
if ((keyword_list = cmd_ln_str_r(config, "-kws"))) {
if (ps_set_kws(ps, PS_DEFAULT_SEARCH, keyword_list))
return -1;
ps_set_search(ps, PS_DEFAULT_SEARCH);
}
/* Load an FSG if one was specified in config */
if ((path = cmd_ln_str_r(config, "-fsg"))) {
fsg_model_t *fsg = fsg_model_readfile(path, ps->lmath, lw);
if (!fsg)
return -1;
if (ps_set_fsg(ps, PS_DEFAULT_SEARCH, fsg))
return -1;
ps_set_search(ps, PS_DEFAULT_SEARCH);
}
if ((path = cmd_ln_str_r(config, "-jsgf"))) {
/* Or load a JSGF grammar */
fsg_model_t *fsg;
jsgf_rule_t *rule;
char const *toprule;
jsgf_t *jsgf = jsgf_parse_file(path, NULL);
if (!jsgf)
return -1;
rule = NULL;
/* Take the -toprule if specified. */
if ((toprule = cmd_ln_str_r(config, "-toprule"))) {
char *ruletok;
ruletok = string_join("<", toprule, ">", NULL);
rule = jsgf_get_rule(jsgf, ruletok);
ckd_free(ruletok);
if (rule == NULL) {
E_ERROR("Start rule %s not found\n", toprule);
return -1;
}
} else {
/* Otherwise, take the first public rule. */
jsgf_rule_iter_t *itor;
for (itor = jsgf_rule_iter(jsgf); itor;
itor = jsgf_rule_iter_next(itor)) {
rule = jsgf_rule_iter_rule(itor);
if (jsgf_rule_public(rule)) {
jsgf_rule_iter_free(itor);
break;
}
}
if (rule == NULL) {
E_ERROR("No public rules found in %s\n", path);
return -1;
}
}
fsg = jsgf_build_fsg(jsgf, rule, ps->lmath, lw);
ps_set_fsg(ps, PS_DEFAULT_SEARCH, fsg);
fsg_model_free(fsg);
ps_set_search(ps, PS_DEFAULT_SEARCH);
}
if ((path = cmd_ln_str_r(ps->config, "-lm"))) {
ngram_model_t *lm;
lm = ngram_model_read(ps->config, path, NGRAM_AUTO, ps->lmath);
if (!lm)
return -1;
if (ps_set_lm(ps, PS_DEFAULT_SEARCH, lm)) {
ngram_model_free(lm);
return -1;
}
ngram_model_free(lm);
ps_set_search(ps, PS_DEFAULT_SEARCH);
}
if ((path = cmd_ln_str_r(ps->config, "-lmctl"))) {
const char *name;
ngram_model_t *lmset;
ngram_model_set_iter_t *lmset_it;
if (!(lmset = ngram_model_set_read(ps->config, path, ps->lmath))) {
E_ERROR("Failed to read language model control file: %s\n", path);
return -1;
}
for(lmset_it = ngram_model_set_iter(lmset);
lmset_it; lmset_it = ngram_model_set_iter_next(lmset_it)) {
ngram_model_t *lm = ngram_model_set_iter_model(lmset_it, &name);
E_INFO("adding search %s\n", name);
if (ps_set_lm(ps, name, lm)) {
ngram_model_free(lm);
ngram_model_set_iter_free(lmset_it);
return -1;
}
ngram_model_free(lm);
}
name = cmd_ln_str_r(config, "-lmname");
if (name)
ps_set_search(ps, name);
else
E_WARN("No default LM name (-lmname) for `-lmctl'\n");
}
/* Initialize performance timer. */
ps->perf.name = "decode";
ptmr_init(&ps->perf);
return 0;
}
jsgf_rule_t *
jsgf_import_rule(jsgf_t * jsgf, char *name)
{
char *c, *path, *newpath;
size_t namelen, packlen;
void *val;
jsgf_t *imp;
int import_all;
/* Trim the leading and trailing <> */
namelen = strlen(name);
path = ckd_malloc(namelen - 2 + 6); /* room for a trailing .gram */
strcpy(path, name + 1);
/* Split off the first part of the name */
c = strrchr(path, '.');
if (c == NULL) {
E_ERROR("Imported rule is not qualified: %s\n", name);
ckd_free(path);
return NULL;
}
packlen = c - path;
*c = '\0';
/* Look for import foo.* */
import_all = (strlen(name) > 2
&& 0 == strcmp(name + namelen - 3, ".*>"));
/* Construct a filename. */
for (c = path; *c; ++c)
if (*c == '.')
*c = '/';
strcat(path, ".gram");
newpath = path_list_search(jsgf->searchpath, path);
if (newpath == NULL) {
E_ERROR("Failed to find grammar %s\n", path);
ckd_free(path);
return NULL;
}
ckd_free(path);
path = newpath;
E_INFO("Importing %s from %s to %s\n", name, path, jsgf->name);
/* FIXME: Also, we need to make sure that path is fully qualified
* here, by adding any prefixes from jsgf->name to it. */
/* See if we have parsed it already */
if (hash_table_lookup(jsgf->imports, path, &val) == 0) {
E_INFO("Already imported %s\n", path);
imp = val;
ckd_free(path);
}
else {
/* If not, parse it. */
imp = jsgf_parse_file(path, jsgf);
val = hash_table_enter(jsgf->imports, path, imp);
if (val != (void *) imp) {
E_WARN("Multiply imported file: %s\n", path);
}
}
if (imp != NULL) {
hash_iter_t *itor;
/* Look for public rules matching rulename. */
for (itor = hash_table_iter(imp->rules); itor;
itor = hash_table_iter_next(itor)) {
hash_entry_t *he = itor->ent;
jsgf_rule_t *rule = hash_entry_val(he);
int rule_matches;
char *rule_name = importname2rulename(name);
if (import_all) {
/* Match package name (symbol table is shared) */
rule_matches =
!strncmp(rule_name, rule->name, packlen + 1);
}
else {
/* Exact match */
rule_matches = !strcmp(rule_name, rule->name);
}
ckd_free(rule_name);
if (rule->is_public && rule_matches) {
void *val;
char *newname;
/* Link this rule into the current namespace. */
c = strrchr(rule->name, '.');
assert(c != NULL);
newname = jsgf_fullname(jsgf, c);
E_INFO("Imported %s\n", newname);
val = hash_table_enter(jsgf->rules, newname,
jsgf_rule_retain(rule));
if (val != (void *) rule) {
E_WARN("Multiply defined symbol: %s\n", newname);
}
if (!import_all) {
hash_table_iter_free(itor);
return rule;
}
}
}
}
return NULL;
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
fsg_search_t *fsgs;
jsgf_t *jsgf;
jsgf_rule_t *rule;
fsg_model_t *fsg;
ps_seg_t *seg;
ps_lattice_t *dag;
FILE *rawfh;
char const *hyp, *uttid;
int32 score, prob;
clock_t c;
int i;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
jsgf = jsgf_parse_file(DATADIR "/goforward.gram", NULL);
TEST_ASSERT(jsgf);
rule = jsgf_get_rule(jsgf, "<goforward.move2>");
TEST_ASSERT(rule);
fsg = jsgf_build_fsg(jsgf, rule, ps->lmath, 7.5);
TEST_ASSERT(fsg);
fsg_model_write(fsg, stdout);
ps_set_fsg(ps, "<goforward.move2>", fsg);
ps_set_search(ps, "<goforward.move2>");
acmod = ps->acmod;
fsgs = (fsg_search_t *) fsg_search_init(fsg, config, acmod, ps->dict, ps->d2p);
setbuf(stdout, NULL);
c = clock();
for (i = 0; i < 5; ++i) {
int16 buf[2048];
size_t nread;
int16 const *bptr;
int nfr;
int is_final;
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
fsg_search_start(ps_search_base(fsgs));
is_final = FALSE;
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
fsg_search_step(ps_search_base(fsgs),
acmod->output_frame);
acmod_advance(acmod);
}
}
hyp = fsg_search_hyp(ps_search_base(fsgs), &score, &is_final);
printf("FSG: %s (%d) frame %d final %s\n", hyp, score, acmod->output_frame, is_final ? "FINAL" : "");
TEST_EQUAL (is_final, (acmod->output_frame > 170));
}
fsg_search_finish(ps_search_base(fsgs));
hyp = fsg_search_hyp(ps_search_base(fsgs), &score, NULL);
printf("FSG: %s (%d)\n", hyp, score);
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
}
TEST_EQUAL(0, strcmp("go forward ten meters",
fsg_search_hyp(ps_search_base(fsgs), &score, NULL)));
ps->search = (ps_search_t *)fsgs;
for (seg = ps_seg_iter(ps, &score); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
printf("%s %d %d\n", word, sf, ef);
}
c = clock() - c;
printf("5 * fsg search in %.2f sec\n", (double)c / CLOCKS_PER_SEC);
dag = ps_get_lattice(ps);
ps_lattice_write(dag, "test_jsgf.lat");
jsgf_grammar_free(jsgf);
fsg_search_free(ps_search_base(fsgs));
ps_free(ps);
cmd_ln_free_r(config);
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-jsgf", DATADIR "/goforward.gram",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
ps_decode_raw(ps, rawfh, "goforward", -1);
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s: %s (%d, %d)\n", uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp("go forward ten meters", hyp));
ps_free(ps);
fclose(rawfh);
cmd_ln_free_r(config);
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-jsgf", DATADIR "/goforward.gram",
"-toprule", "goforward.move2",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
ps_decode_raw(ps, rawfh, "goforward", -1);
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s: %s (%d, %d)\n", uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp("go forward ten meters", hyp));
ps_free(ps);
cmd_ln_free_r(config);
fclose(rawfh);
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-jsgf", DATADIR "/defective.gram",
NULL));
TEST_ASSERT(NULL == ps_init(config));
cmd_ln_free_r(config);
return 0;
}