int main(int argc, char *argv[])
{
char const *cfg;
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, TRUE);
/* Handle argument file as -argfile. */
if (config && (cfg = cmd_ln_str_r(config, "-argfile")) != NULL) {
config = cmd_ln_parse_file_r(config, cont_args_def, cfg, FALSE);
}
if (config == NULL || (cmd_ln_str_r(config, "-infile") == NULL && cmd_ln_boolean_r(config, "-inmic") == FALSE)) {
E_INFO("Specify '-infile <file.wav>' to recognize from file or '-inmic yes' to recognize from microphone.");
cmd_ln_free_r(config);
return 1;
}
ps_default_search_args(config);
ps = ps_init(config);
if (ps == NULL) {
cmd_ln_free_r(config);
return 1;
}
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
if (cmd_ln_boolean_r(config, "-inmic")) {
recognize_from_microphone();
}
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
ps_load_dict(ps_decoder_t *ps, char const *dictfile,
char const *fdictfile, char const *format)
{
cmd_ln_t *newconfig;
dict2pid_t *d2p;
dict_t *dict;
hash_iter_t *search_it;
/* Create a new scratch config to load this dict (so existing one
* won't be affected if it fails) */
newconfig = cmd_ln_init(NULL, ps_args(), TRUE, NULL);
cmd_ln_set_boolean_r(newconfig, "-dictcase",
cmd_ln_boolean_r(ps->config, "-dictcase"));
cmd_ln_set_str_r(newconfig, "-dict", dictfile);
if (fdictfile)
cmd_ln_set_str_r(newconfig, "-fdict", fdictfile);
else
cmd_ln_set_str_r(newconfig, "-fdict",
cmd_ln_str_r(ps->config, "-fdict"));
/* Try to load it. */
if ((dict = dict_init(newconfig, ps->acmod->mdef, ps->acmod->lmath)) == NULL) {
cmd_ln_free_r(newconfig);
return -1;
}
/* Reinit the dict2pid. */
if ((d2p = dict2pid_build(ps->acmod->mdef, dict)) == NULL) {
cmd_ln_free_r(newconfig);
return -1;
}
/* Success! Update the existing config to reflect new dicts and
* drop everything into place. */
cmd_ln_free_r(newconfig);
cmd_ln_set_str_r(ps->config, "-dict", dictfile);
if (fdictfile)
cmd_ln_set_str_r(ps->config, "-fdict", fdictfile);
dict_free(ps->dict);
ps->dict = dict;
dict2pid_free(ps->d2p);
ps->d2p = d2p;
/* And tell all searches to reconfigure themselves. */
for (search_it = hash_table_iter(ps->searches); search_it;
search_it = hash_table_iter_next(search_it)) {
if (ps_search_reinit(hash_entry_val(search_it->ent), dict, d2p) < 0) {
hash_table_iter_free(search_it);
return -1;
}
}
return 0;
}
int
ps_load_dict(ps_decoder_t *ps, char const *dictfile,
char const *fdictfile, char const *format)
{
cmd_ln_t *newconfig;
dict2pid_t *d2p;
dict_t *dict;
gnode_t *gn;
int rv;
/* Create a new scratch config to load this dict (so existing one
* won't be affected if it fails) */
newconfig = cmd_ln_init(NULL, ps_args(), TRUE, NULL);
cmd_ln_set_boolean_r(newconfig, "-dictcase",
cmd_ln_boolean_r(ps->config, "-dictcase"));
cmd_ln_set_str_r(newconfig, "-dict", dictfile);
if (fdictfile)
cmd_ln_set_str_r(newconfig, "-fdict", fdictfile);
else
cmd_ln_set_str_r(newconfig, "-fdict",
cmd_ln_str_r(ps->config, "-fdict"));
/* Try to load it. */
if ((dict = dict_init(newconfig, ps->acmod->mdef)) == NULL) {
cmd_ln_free_r(newconfig);
return -1;
}
/* Reinit the dict2pid. */
if ((d2p = dict2pid_build(ps->acmod->mdef, dict)) == NULL) {
cmd_ln_free_r(newconfig);
return -1;
}
/* Success! Update the existing config to reflect new dicts and
* drop everything into place. */
cmd_ln_free_r(newconfig);
cmd_ln_set_str_r(ps->config, "-dict", dictfile);
if (fdictfile)
cmd_ln_set_str_r(ps->config, "-fdict", fdictfile);
dict_free(ps->dict);
ps->dict = dict;
dict2pid_free(ps->d2p);
ps->d2p = d2p;
/* And tell all searches to reconfigure themselves. */
for (gn = ps->searches; gn; gn = gnode_next(gn)) {
ps_search_t *search = gnode_ptr(gn);
if ((rv = ps_search_reinit(search, dict, d2p)) < 0)
return rv;
}
return 0;
}
int32
main(int32 argc, char *argv[])
{
kb_t kb;
stat_t *st;
cmd_ln_t *config;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", arg);
unlimit();
config = cmd_ln_get();
kb_init(&kb, config);
st = kb.stat;
fprintf(stdout, "\n");
if (cmd_ln_str_r(config, "-ctl")) {
/* When -ctlfile is speicified, corpus.c will look at -ctl_lm and
-ctl_mllr to get the corresponding LM and MLLR for the utterance */
st->tm = ctl_process(cmd_ln_str_r(config, "-ctl"),
cmd_ln_str_r(config, "-ctl_lm"),
cmd_ln_str_r(config, "-ctl_mllr"),
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"), utt_decode, &kb);
}
else if (cmd_ln_str_r(config, "-utt")) {
/* When -utt is specified, corpus.c will wait for the utterance to
change */
st->tm = ctl_process_utt(cmd_ln_str_r(config, "-utt"),
cmd_ln_int32_r(config, "-ctlcount"),
utt_decode, &kb);
}
else {
/* Is error checking good enough?" */
E_FATAL("Both -utt and -ctl are not specified.\n");
}
if (kb.matchsegfp)
fclose(kb.matchsegfp);
if (kb.matchfp)
fclose(kb.matchfp);
stat_report_corpus(kb.stat);
kb_free(&kb);
#if (! WIN32)
#if defined(_SUN4)
system("ps -el | grep sphinx3_decode");
#else
system("ps aguxwww | grep sphinx3_decode");
#endif
#endif
cmd_ln_free_r(config);
exit(0);
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
int rv;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/en-us/en-us",
"-lm", MODELDIR "/en-us/en-us.lm.dmp",
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
"-fwdtree", "yes",
"-fwdflat", "no",
"-bestpath", "yes",
"-input_endian", "little",
"-cmninit", "37",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
rv = test_decode(ps);
ps_free(ps);
cmd_ln_free_r(config);
return rv;
}
int
acmod_free(acmod_t *acmod)
{
if (acmod == NULL)
return 0;
if (--acmod->refcount > 0)
return acmod->refcount;
ckd_free(acmod->senone_scores);
ckd_free(acmod->senone_active_vec);
ckd_free(acmod->senone_active);
if (acmod->mdef)
bin_mdef_free(acmod->mdef);
if (acmod->tmat)
tmat_free(acmod->tmat);
if (acmod->mgau)
ps_mgau_free(acmod->mgau);
featbuf_free(acmod->fb);
feat_array_free(acmod->feat_buf);
logmath_free(acmod->lmath);
cmd_ln_free_r(acmod->config);
ckd_free(acmod);
return 0;
}
int
fe_free(fe_t * fe)
{
if (fe == NULL)
return 0;
if (--fe->refcount > 0)
return fe->refcount;
/* kill FE instance - free everything... */
if (fe->mel_fb) {
if (fe->mel_fb->mel_cosine)
fe_free_2d((void *) fe->mel_fb->mel_cosine);
ckd_free(fe->mel_fb->lifter);
ckd_free(fe->mel_fb->spec_start);
ckd_free(fe->mel_fb->filt_start);
ckd_free(fe->mel_fb->filt_width);
ckd_free(fe->mel_fb->filt_coeffs);
ckd_free(fe->mel_fb);
}
ckd_free(fe->spch);
ckd_free(fe->frame);
ckd_free(fe->ccc);
ckd_free(fe->sss);
ckd_free(fe->spec);
ckd_free(fe->mfspec);
ckd_free(fe->overflow_samps);
ckd_free(fe->hamming_window);
cmd_ln_free_r(fe->config);
ckd_free(fe);
return 0;
}
int
main(int argc, char *argv[])
{
cmd_ln_t *config;
logmath_t *lmath;
acmod_t *acmod[5];
sbthread_t *thr[5];
featbuf_t *fb;
FILE *raw;
int16 buf[2048];
int nsamp;
int i;
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", TESTDATADIR "/hub4wsj_sc_8k",
"-lm", TESTDATADIR "/bn10000.3g.arpa",
"-dict", TESTDATADIR "/bn10000.dic",
"-compallsen", "yes",
NULL);
ps_init_defaults(config);
fb = featbuf_init(config);
TEST_ASSERT(fb);
lmath = logmath_init(cmd_ln_float32_r(config, "-logbase"),
0, FALSE);
acmod[0] = acmod_init(config, lmath, fb);
TEST_ASSERT(acmod[0]);
/* Create a couple threads to pull features out of it. */
for (i = 0; i < 5; ++i) {
if (i != 0)
acmod[i] = acmod_copy(acmod[0]);
thr[i] = sbthread_start(NULL, consumer, acmod[i]);
}
/* Feed them some data. */
raw = fopen(TESTDATADIR "/chan3.raw", "rb");
featbuf_producer_start_utt(fb, "chan3");
while ((nsamp = fread(buf, 2, 2048, raw)) > 0) {
int rv;
rv = featbuf_producer_process_raw(fb, buf, nsamp, FALSE);
printf("Producer processed %d samples\n", nsamp);
TEST_ASSERT(rv > 0);
}
fclose(raw);
printf("Waiting for consumers\n");
featbuf_producer_end_utt(fb);
printf("Finished waiting\n");
/* Reap those threads. */
for (i = 0; i < 5; ++i) {
sbthread_wait(thr[i]);
sbthread_free(thr[i]);
acmod_free(acmod[i]);
printf("Reaped consumer %p\n", acmod[i]);
}
featbuf_free(fb);
logmath_free(lmath);
cmd_ln_free_r(config);
return 0;
}
int
sphinx_wave2feat_free(sphinx_wave2feat_t *wtf)
{
if (wtf == NULL)
return 0;
if (--wtf->refcount > 0)
return wtf->refcount;
if (wtf->audio)
ckd_free(wtf->audio);
if (wtf->feat)
ckd_free_2d(wtf->feat);
if (wtf->infile)
ckd_free(wtf->infile);
if (wtf->outfile)
ckd_free(wtf->outfile);
if (wtf->infh) {
if (fclose(wtf->infh) == EOF)
E_ERROR_SYSTEM("Failed to close input file");
}
if (wtf->outfh) {
if (fclose(wtf->outfh) == EOF)
E_ERROR_SYSTEM("Failed to close output file");
}
cmd_ln_free_r(wtf->config);
fe_free(wtf->fe);
ckd_free(wtf);
return 0;
}
int
main(int argc, char *argv[])
{
logmath_t *lmath;
cmd_ln_t *config;
acmod_t *acmod;
ps_mgau_t *ps;
ptm_mgau_t *s;
int i, lastcb;
lmath = logmath_init(1.0001, 0, 0);
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-compallsen", "yes",
"-input_endian", "little",
NULL);
cmd_ln_parse_file_r(config, ps_args(), MODELDIR "/en-us/en-us/feat.params", FALSE);
cmd_ln_set_str_extra_r(config, "_mdef", MODELDIR "/en-us/en-us/mdef");
cmd_ln_set_str_extra_r(config, "_mean", MODELDIR "/en-us/en-us/means");
cmd_ln_set_str_extra_r(config, "_var", MODELDIR "/en-us/en-us/variances");
cmd_ln_set_str_extra_r(config, "_tmat", MODELDIR "/en-us/en-us/transition_matrices");
cmd_ln_set_str_extra_r(config, "_sendump", MODELDIR "/en-us/en-us/sendump");
cmd_ln_set_str_extra_r(config, "_mixw", NULL);
cmd_ln_set_str_extra_r(config, "_lda", NULL);
cmd_ln_set_str_extra_r(config, "_senmgau", NULL);
err_set_debug_level(3);
TEST_ASSERT(config);
TEST_ASSERT((acmod = acmod_init(config, lmath, NULL, NULL)));
TEST_ASSERT((ps = acmod->mgau));
TEST_EQUAL(0, strcmp(ps->vt->name, "ptm"));
s = (ptm_mgau_t *)ps;
E_DEBUG(2,("PTM model loaded: %d codebooks, %d senones, %d frames of history\n",
s->g->n_mgau, s->n_sen, s->n_fast_hist));
E_DEBUG(2,("Senone to codebook mappings:\n"));
lastcb = s->sen2cb[0];
E_DEBUG(2,("\t%d: 0", lastcb));
for (i = 0; i < s->n_sen; ++i) {
if (s->sen2cb[i] != lastcb) {
lastcb = s->sen2cb[i];
E_DEBUGCONT(2,("-%d\n", i-1));
E_DEBUGCONT(2,("\t%d: %d", lastcb, i));
}
}
E_INFOCONT("-%d\n", i-1);
run_acmod_test(acmod);
#if 0
/* Replace it with ms_mgau. */
ptm_mgau_free(ps);
cmd_ln_set_str_r(config,
"-mixw",
MODELDIR "/en-us/en-us/mixture_weights");
TEST_ASSERT((acmod->mgau = ms_mgau_init(acmod, lmath, acmod->mdef)));
run_acmod_test(acmod);
cmd_ln_free_r(config);
#endif
return 0;
}
int
main(int argc, char *argv[])
{
sphinx_wave2feat_t *wtf;
cmd_ln_t *config;
int rv;
config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE);
if (config && cmd_ln_str_r(config, "-argfile"))
config = cmd_ln_parse_file_r(config, defn,
cmd_ln_str_r(config, "-argfile"), FALSE);
if (config == NULL) {
E_ERROR("Command line parsing failed\n");
return 1;
}
if ((wtf = sphinx_wave2feat_init(config)) == NULL) {
E_ERROR("Failed to initialize wave2feat object\n");
return 1;
}
/* If there's a control file run through it, otherwise we will do
* a single file (which is what run_control_file will do
* internally too) */
if (cmd_ln_str_r(config, "-c"))
rv = run_control_file(wtf, cmd_ln_str_r(config, "-c"));
else
rv = sphinx_wave2feat_convert_file(wtf, cmd_ln_str_r(config, "-i"),
cmd_ln_str_r(config, "-o"));
sphinx_wave2feat_free(wtf);
cmd_ln_free_r(config);
return rv;
}
int run(CallbackType callback, char* kpath) {
//string path ="C:/Users/Reza/Documents/GitHub/speech_agent/speech/Release/";
listenCallback = callback;
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", "C:/Users/Reza/Documents/GitHub/speech_agent/speech/Release/model/en-us/en-us",
//"-lm","C:/Users/Reza/Documents/GitHub/speech_agent/speech/Release/model/en-us/en-us.lm.dmp",
//"-lm","C:/Users/Reza/Documents/GitHub/speech_agent/speech/Release/cristina.lm",
//"-jsgf", "grammar.gram",
"-vad_threshold","3",
"-kws", kpath,
"-dict", "C:/Users/Reza/Documents/GitHub/speech_agent/speech/Release/model/en-us/cmudict-en-us2.dict",
//"-beam", "1e-20", "-pbeam", "1e-20", "-lw", "2.0",
//"-logfn","model",
NULL);
if (config == NULL)
return -1;
ps = ps_init(config);
if (ps == NULL)
return -1;
recognize_from_mic();
//recognize_from_file();
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
cmd_ln_t *config;
ps_decoder_t *ps;
FILE *rawfh;
char const *hyp;
char const *uttid;
int32 score;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", DATADIR "/an4_ci_cont",
"-lm", MODELDIR "/lm/en/turtle.DMP",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-mllr", DATADIR "/mllr_matrices",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
ps_decode_raw(ps, rawfh, "goforward", -1);
fclose(rawfh);
hyp = ps_get_hyp(ps, &score, &uttid);
printf("FWDFLAT (%s): %s (%d)\n", uttid, hyp, score);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
cmd_ln_t *config;
config = cmd_ln_parse_r(NULL, defs, argc, argv, TRUE);
if (config == NULL)
return 1;
printf("%d %s %d %f\n",
cmd_ln_int32_r(config, "-a"),
cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)",
cmd_ln_boolean_r(config, "-c"),
cmd_ln_float64_r(config, "-d"));
cmd_ln_free_r(config);
config = cmd_ln_init(NULL, NULL, FALSE,
"-b", "foobie", NULL);
if (config == NULL)
return 1;
cmd_ln_free_r(config);
config = cmd_ln_init(NULL, defs, TRUE,
"-b", "foobie", NULL);
if (config == NULL)
return 1;
printf("%d %s %d %f\n",
cmd_ln_int32_r(config, "-a"),
cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)",
cmd_ln_boolean_r(config, "-c"),
cmd_ln_float64_r(config, "-d"));
cmd_ln_free_r(config);
config = cmd_ln_init(NULL, NULL, FALSE,
"-b", "foobie", NULL);
if (config == NULL)
return 1;
printf("%s\n",
cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)");
cmd_ln_set_str_r(config, "-b", "blatz");
printf("%s\n",
cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)");
cmd_ln_free_r(config);
return 0;
}
static void
test_no_search()
{
cmd_ln_t *config = default_config();
ps_decoder_t *ps = ps_init(config);
TEST_ASSERT(ps_start_utt(ps) < 0);
ps_free(ps);
cmd_ln_free_r(config);
}
int main(int argc, char *argv[]) {
ps_decoder_t *ps;
cmd_ln_t *config;
FILE *fh;
char const *hyp, *uttid;
int16 buf[512];
int rv;
int32 score;
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/en-us/en-us",
"-lm", MODELDIR "/en-us/en-us.lm.bin",
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
NULL);
if (config == NULL) {
fprintf(stderr, "Failed to create config object, see log for details\n");
return -1;
}
// Initialize pocketsphinx
ps = ps_init(config);
if (ps == NULL) {
fprintf(stderr, "Failed to create recognizer, see log for details\n");
return -1;
}
// Open the wav file passed from argument
printf("file: %s\n", argv[1]);
fh = fopen(argv[1], "rb");
if (fh == NULL) {
fprintf(stderr, "Unable to open input file %s\n", argv[1]);
return -1;
}
// Start utterance
rv = ps_start_utt(ps);
// Process buffer, 512 samples at a time
while (!feof(fh)) {
size_t nsamp;
nsamp = fread(buf, 2, 512, fh);
rv = ps_process_raw(ps, buf, nsamp, FALSE, FALSE);
}
// Recieve the recognized string
rv = ps_end_utt(ps);
hyp = ps_get_hyp(ps, &score);
printf("Recognized: |%s|\n", hyp);
// free memory
fclose(fh);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
static av_cold void asr_uninit(AVFilterContext *ctx)
{
ASRContext *s = ctx->priv;
ps_free(s->ps);
s->ps = NULL;
cmd_ln_free_r(s->config);
s->config = NULL;
}
int
main(int argc, char *argv[])
{
ngram_trie_t *t;
dict_t *dict;
bin_mdef_t *mdef;
logmath_t *lmath;
cmd_ln_t *config;
FILE *arpafh;
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", TESTDATADIR "/hub4wsj_sc_8k",
"-dict", TESTDATADIR "/bn10000.homos.dic",
NULL);
ps_init_defaults(config);
lmath = logmath_init(cmd_ln_float32_r(config, "-logbase"),
0, FALSE);
mdef = bin_mdef_read(config, cmd_ln_str_r(config, "-mdef"));
dict = dict_init(config, mdef);
t = ngram_trie_init(dict, lmath);
arpafh = fopen(TESTDATADIR "/bn10000.3g.arpa", "r");
ngram_trie_read_arpa(t, arpafh);
fclose(arpafh);
/* Test 1, 2, 3-gram probs without backoff. */
test_lookups(t, lmath);
arpafh = fopen("tmp.bn10000.3g.arpa", "w");
ngram_trie_write_arpa(t, arpafh);
fclose(arpafh);
ngram_trie_free(t);
t = ngram_trie_init(dict, lmath);
arpafh = fopen("tmp.bn10000.3g.arpa", "r");
ngram_trie_read_arpa(t, arpafh);
fclose(arpafh);
/* Test 1, 2, 3-gram probs without backoff. */
test_lookups(t, lmath);
/* Test adding nodes. */
test_add_nodes(t, lmath);
ngram_trie_free(t);
dict_free(dict);
logmath_free(lmath);
bin_mdef_free(mdef);
cmd_ln_free_r(config);
return 0;
}
static void
gst_pocketsphinx_finalize(GObject * gobject)
{
GstPocketSphinx *ps = GST_POCKETSPHINX(gobject);
ps_free(ps->ps);
cmd_ln_free_r(ps->config);
g_free(ps->last_result);
G_OBJECT_CLASS(gst_pocketsphinx_parent_class)->finalize(gobject);
}
int
main(int argc, char *argv[])
{
bin_mdef_t *mdef;
dict_t *dict;
cmd_ln_t *config;
int i;
char buf[100];
TEST_ASSERT(config = cmd_ln_init(NULL, NULL, FALSE,
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
"-fdict", MODELDIR "/en-us/en-us/noisedict",
NULL));
/* Test dictionary in standard fashion. */
TEST_ASSERT(mdef = bin_mdef_read(NULL, MODELDIR "/en-us/en-us/mdef"));
TEST_ASSERT(dict = dict_init(config, mdef, NULL));
printf("Word ID (CARNEGIE) = %d\n",
dict_wordid(dict, "CARNEGIE"));
printf("Word ID (ASDFASFASSD) = %d\n",
dict_wordid(dict, "ASDFASFASSD"));
TEST_EQUAL(0, dict_write(dict, "_cmu07a.dic", NULL));
TEST_EQUAL(0, system("diff -uw " MODELDIR "/en-us/cmudict-en-us.dict _cmu07a.dic"));
dict_free(dict);
bin_mdef_free(mdef);
/* Now test an empty dictionary. */
TEST_ASSERT(dict = dict_init(NULL, NULL, NULL));
printf("Word ID(<s>) = %d\n", dict_wordid(dict, "<s>"));
TEST_ASSERT(BAD_S3WID != dict_add_word(dict, "FOOBIE", NULL, 0));
TEST_ASSERT(BAD_S3WID != dict_add_word(dict, "BLETCH", NULL, 0));
printf("Word ID(FOOBIE) = %d\n", dict_wordid(dict, "FOOBIE"));
printf("Word ID(BLETCH) = %d\n", dict_wordid(dict, "BLETCH"));
TEST_ASSERT(dict_real_word(dict, dict_wordid(dict, "FOOBIE")));
TEST_ASSERT(dict_real_word(dict, dict_wordid(dict, "BLETCH")));
TEST_ASSERT(!dict_real_word(dict, dict_wordid(dict, "</s>")));
dict_free(dict);
/* Test to add 500k words. */
TEST_ASSERT(dict = dict_init(NULL, NULL, NULL));
for (i = 0; i < 500000; i++) {
sprintf(buf, "word_%d", i);
TEST_ASSERT(BAD_S3WID != dict_add_word(dict, buf, NULL, 0));
}
dict_free(dict);
cmd_ln_free_r(config);
return 0;
}
static void
test_default_lm()
{
cmd_ln_t *config = default_config();
cmd_ln_set_str_r(config, "-lm", MODELDIR "/en-us/en-us.lm.dmp");
ps_decoder_t *ps = ps_init(config);
TEST_ASSERT(!ps_get_fsg(ps, PS_DEFAULT_SEARCH));
TEST_ASSERT(ps_get_lm(ps, PS_DEFAULT_SEARCH));
ps_free(ps);
cmd_ln_free_r(config);
}
static void
test_default_jsgf()
{
cmd_ln_t *config = default_config();
cmd_ln_set_str_r(config, "-jsgf", DATADIR "/goforward.gram");
ps_decoder_t *ps = ps_init(config);
TEST_ASSERT(!ps_get_lm(ps, PS_DEFAULT_SEARCH));
TEST_ASSERT(ps_get_fsg(ps, PS_DEFAULT_SEARCH));
ps_free(ps);
cmd_ln_free_r(config);
}
int
main(int32 argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
char const *ctl;
FILE *ctlfh;
config = cmd_ln_parse_r(NULL, ps_args_def, argc, argv, TRUE);
/* Handle argument file as -argfile. */
if (config && (ctl = cmd_ln_str_r(config, "-argfile")) != NULL) {
config = cmd_ln_parse_file_r(config, ps_args_def, ctl, FALSE);
}
if (config == NULL) {
/* This probably just means that we got no arguments. */
return 1;
}
if ((ctl = cmd_ln_str_r(config, "-ctl")) == NULL) {
E_FATAL("-ctl argument not present, nothing to do in batch mode!\n");
}
if ((ctlfh = fopen(ctl, "r")) == NULL) {
E_FATAL_SYSTEM("Failed to open control file '%s'", ctl);
}
ps_default_search_args(config);
if (!(ps = ps_init(config))) {
cmd_ln_free_r(config);
fclose(ctlfh);
E_FATAL("PocketSphinx decoder init failed\n");
}
process_ctl(ps, config, ctlfh);
fclose(ctlfh);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
static void
gst_pocketsphinx_finalize(GObject * gobject)
{
GstPocketSphinx *ps = GST_POCKETSPHINX(gobject);
g_hash_table_foreach(ps->arghash, string_disposal, NULL);
g_hash_table_destroy(ps->arghash);
g_free(ps->last_result);
ps_free(ps->ps);
cmd_ln_free_r(ps->config);
GST_CALL_PARENT(G_OBJECT_CLASS, finalize,(gobject));
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
FILE *fh;
char const *hyp, *uttid;
int16 buf[512];
int rv;
int32 score;
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/en-us/en-us",
"-keyphrase", "marieta",
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
"-kws_threshold", "1e-30",
NULL);
if (config == NULL) {
fprintf(stderr, "Failed to create config object, see log for details\n");
return -1;
}
ps = ps_init(config);
if (ps == NULL) {
fprintf(stderr, "Failed to create recognizer, see log for details\n");
return -1;
}
fh = fopen("data/marieta.raw", "rb");
if (fh == NULL) {
fprintf(stderr, "Unable to open input file goforward.raw\n");
return -1;
}
rv = ps_start_utt(ps);
while (!feof(fh)) {
size_t nsamp;
nsamp = fread(buf, 2, 512, fh);
rv = ps_process_raw(ps, buf, nsamp, FALSE, FALSE);
}
rv = ps_end_utt(ps);
hyp = ps_get_hyp(ps, &score);
printf("Recognized: %s\n", hyp);
fclose(fh);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
static void
test_default_fsg()
{
cmd_ln_t *config = default_config();
cmd_ln_set_str_r(config, "-hmm", DATADIR "/tidigits/hmm");
cmd_ln_set_str_r(config, "-dict", DATADIR "/tidigits/lm/tidigits.dic");
cmd_ln_set_str_r(config, "-fsg", DATADIR "/tidigits/lm/tidigits.fsg");
ps_decoder_t *ps = ps_init(config);
TEST_ASSERT(!ps_get_lm(ps, PS_DEFAULT_SEARCH));
TEST_ASSERT(ps_get_fsg(ps, PS_DEFAULT_SEARCH));
ps_free(ps);
cmd_ln_free_r(config);
}
Recognizer::~Recognizer()
{
// Set stop flag:
mStop = true;
// Join thread:
if( mThread.joinable() ) mThread.join();
// Cleanup decoder:
if( mDecoder ) ps_free( mDecoder );
// Cleanup config:
if( mConfig ) cmd_ln_free_r( mConfig );
// Cleanup models:
mModelMap.clear();
}
int main(int argc, char *argv[]) {
int go = 1;
const char *lang = argv[1];
const char *rawFile = argv[2];
cmd_ln_t *config;
// Configure recognizer for English or Spanish
if (strcmp(lang, "engl") == 0) {
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/en-us/en-us",
"-lm", MODELDIR "/en-us/en-us.lm.bin",
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
NULL);
} else if (strcmp(lang, "span") == 0) {
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", "/home/pi/es_MX_broadcast_cont_2500/model_parameters/hub4_spanish_itesm.cd_cont_2500",
"-lm", "/home/pi/es_MX_broadcast_cont_2500/etc/H4.arpa.Z.DMP",
"-dict", "/home/pi/es_MX_broadcast_cont_2500/etc/h4.dict",
NULL);
}
if (config == NULL) {
fprintf(stderr, "Failed to create config object, see log for details\n");
return -1;
}
// Initialize pocketsphinx
ps = ps_init(config);
if (ps == NULL) {
fprintf(stderr, "Failed to create recognizer, see log for details\n");
return -1;
}
fflush(stdout);
// Wait for signal from stdin
while (1) {
// Waiting for command
scanf("%d", &go);
if (go) {
processRaw(rawFile);
} else break;
}
// free memory
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
unlimit();
config = cmd_ln_get();
logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1,
cmd_ln_int32_r(config, "-log3table"));
E_INFO("Value of base %f \n", cmd_ln_float32_r(config, "-logbase"));
models_init();
ptmr_init(&tm_utt);
if ((inmatchsegfp = fopen(cmd_ln_str_r(config, "-inhypseg"), "r")) == NULL)
E_ERROR("fopen(%s,r) failed\n", cmd_ln_str_r(config, "-inhypseg"));
if ((outconfmatchsegfp = fopen(cmd_ln_str_r(config, "-output"), "w")) == NULL)
E_ERROR("fopen(%s,w) failed\n", cmd_ln_str_r(config, "-output"));
if (cmd_ln_str_r(config, "-ctl")) {
ctl_process(cmd_ln_str_r(config, "-ctl"),
cmd_ln_str_r(config, "-ctl_lm"),
NULL,
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"), utt_confidence, NULL);
}
else {
E_FATAL("-ctl is not specified\n");
}
#if (! WIN32)
system("ps auxwww | grep s3dag");
#endif
fclose(outconfmatchsegfp);
fclose(inmatchsegfp);
models_free();
logmath_free(logmath);
cmd_ln_free_r(config);
return 0;
}
static void
test_default_lmctl()
{
cmd_ln_t *config = default_config();
cmd_ln_set_str_r(config, "-lmctl", DATADIR "/test.lmctl");
cmd_ln_set_str_r(config, "-lmname", "tidigits");
ps_decoder_t *ps = ps_init(config);
TEST_ASSERT(ps_get_lm(ps, "tidigits"));
TEST_ASSERT(ps_get_lm(ps, "turtle"));
TEST_ASSERT(!ps_set_search(ps, "turtle"));
TEST_ASSERT(!ps_set_search(ps, "tidigits"));
ps_free(ps);
cmd_ln_free_r(config);
}
