int
main(int argc, char *argv[])
{
char const *cfg;
if (argc == 2) {
config = cmd_ln_parse_file_r(NULL, cont_args_def, argv[1], TRUE);
} else {
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, FALSE);
}
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)
return 1;
ps = ps_init(config);
if (ps == NULL)
return 1;
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
if (cmd_ln_str_r(config, "-infile") != NULL) {
recognize_from_file();
}
ps_free(ps);
return 0;
}
int
main(int argc, char *argv[])
{
char const *cfg;
if (argc == 2) {
config = cmd_ln_parse_file_r(NULL, cont_args_def, argv[1], TRUE);
}
else {
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, FALSE);
}
/* 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)
return 1;
ps = ps_init(config);
if (ps == NULL)
return 1;
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
/* Make sure we exit cleanly (needed for profiling among other things) */
signal(SIGINT, &sighandler);
if (setjmp(jbuf) == 0) {
recognize_from_microphone();
}
ps_free(ps);
return 0;
}
int
main(int argc, char *argv[])
{
char const *cfg;
int i;
argc = 7;
argv[1] = "-dict";
argv[2] = "../../../../../../home/pi/guggug/speech/knowledgebase/3/dictionary";
argv[3] = "-lm";
argv[4] = "../../../../../../home/pi/guggug/speech/knowledgebase/3/langmodel";
argv[5] = "-adcdev";
argv[6] = "hw:1,0";
if (argc == 2) {
config = cmd_ln_parse_file_r(NULL, cont_args_def, argv[1], TRUE);
}
else {
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, FALSE);
}
/* 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)
return 1;
ps = ps_init(config);
if (ps == NULL)
return 1;
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
if (cmd_ln_str_r(config, "-infile") != NULL) {
recognize_from_file();
} else {
/* Make sure we exit cleanly (needed for profiling among other things) */
/* Signals seem to be broken in arm-wince-pe. */
#if !defined(GNUWINCE) && !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
signal(SIGINT, &sighandler);
#endif
if (setjmp(jbuf) == 0) {
recognize_from_microphone();
}
}
ps_free(ps);
return 0;
}
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
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
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[])
{
cmd_ln_t *config;
char const *cfg;
/* Make sure we exit cleanly (needed for profiling among other things) */
/* Signals seem to be broken in arm-wince-pe. */
#if !defined(GNUWINCE) && !defined(_WIN32_WCE)
signal(SIGINT, &sighandler);
#endif
if (argc == 2) {
config = cmd_ln_parse_file_r(NULL, cont_args_def, argv[1], TRUE);
}
else {
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, FALSE);
}
/* 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)
return 1;
ps = ps_init(config);
if (ps == NULL)
return 1;
if ((ad = ad_open_dev(cmd_ln_str_r(config, "-adcdev"),
(int)cmd_ln_float32_r(config, "-samprate"))) == NULL)
E_FATAL("ad_open_dev failed\n");
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
if (setjmp(jbuf) == 0) {
utterance_loop();
}
ps_free(ps);
ad_close(ad);
return 0;
}
int
main(int _argc, char **_argv)
{
char *ctrlfn;
char *cfgfn;
cmd_ln_t *config = NULL;
print_appl_info(_argv[0]);
if (_argc != 4) {
printf("\nUSAGE: %s <ctrlfile> <rawdir> <cfgfile>\n", _argv[0]);
return -1;
}
ctrlfn = _argv[1];
rawdirfn = _argv[2];
cfgfn = _argv[3];
if ((config = cmd_ln_parse_file_r(config, S3_DECODE_ARG_DEFS, cfgfn, TRUE)) == NULL)
E_FATAL("Bad configuration file %s.\n", cfgfn);
if (s3_decode_init(&decoder, config) != S3_DECODE_SUCCESS)
E_FATAL("Failed to initialize live-decoder.\n");
fe = fe_init_auto_r(config);
st = decoder.kb.stat;
ptmr_init(&(st->tm));
if (ctrlfn) {
/* 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(ctrlfn,
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_livepretend, &(decoder.kb));
}
else {
E_FATAL("control file is not specified.\n");
}
stat_report_corpus(decoder.kb.stat);
s3_decode_close(&decoder);
fe_free(fe);
return 0;
}
int
cmd_ln_parse_file(const arg_t * defn, const char *filename, int32 strict)
{
cmd_ln_t *cmdln;
cmdln = cmd_ln_parse_file_r(global_cmdln, defn, filename, strict);
if (cmdln == NULL) {
return -1;
}
/* Initialize global_cmdln if not present. */
if (global_cmdln == NULL) {
global_cmdln = cmdln;
}
return 0;
}
void listen::run(char *application){
//Init manually for now
int argcnt = 5;
char *arguments[argcnt];
arguments[0] = new char[strlen(application)];
strcpy(arguments[0], application);
arguments[1] = new char[c.getValue("[General]", "Argument1").size()];
strcpy(arguments[1], c.getValue("[General]", "Argument1").c_str());
arguments[2] = new char[c.getValue("[General]", "Argument2").size()];
strcpy(arguments[2], c.getValue("[General]", "Argument2").c_str());
arguments[3] = new char[c.getValue("[General]", "Argument3").size()];
strcpy(arguments[3], c.getValue("[General]", "Argument3").c_str());
arguments[4] = new char[c.getValue("[General]", "Argument4").size()];
strcpy(arguments[4], c.getValue("[General]", "Argument4").c_str());
if (argcnt == 2) {
config = cmd_ln_parse_file_r(NULL, cont_args_def, arguments[1], TRUE);
}
else {
config = cmd_ln_parse_r(NULL, cont_args_def, argcnt, arguments, FALSE);
}
ps = ps_init(config);
//E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
/* Make sure we exit cleanly (needed for profiling among other things) */
/* Signals seem to be broken in arm-wince-pe. */
#if !defined(GNUWINCE) && !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
signal(SIGINT, &sighandler);
#endif
if(setjmp(jbuf) == 0){
recognize_from_microphone();
}
ps_free(ps);
}
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
ps_expand_model_config(ps_decoder_t *ps)
{
char const *hmmdir, *featparams;
/* Disable memory mapping on Blackfin (FIXME: should be uClinux in general). */
#ifdef __ADSPBLACKFIN__
E_INFO("Will not use mmap() on uClinux/Blackfin.");
cmd_ln_set_boolean_r(ps->config, "-mmap", FALSE);
#endif
/* Get acoustic model filenames and add them to the command-line */
if ((hmmdir = cmd_ln_str_r(ps->config, "-hmm")) != NULL) {
ps_add_file(ps, "-mdef", hmmdir, "mdef");
ps_add_file(ps, "-mean", hmmdir, "means");
ps_add_file(ps, "-var", hmmdir, "variances");
ps_add_file(ps, "-tmat", hmmdir, "transition_matrices");
ps_add_file(ps, "-mixw", hmmdir, "mixture_weights");
ps_add_file(ps, "-sendump", hmmdir, "sendump");
ps_add_file(ps, "-fdict", hmmdir, "noisedict");
ps_add_file(ps, "-lda", hmmdir, "feature_transform");
ps_add_file(ps, "-featparams", hmmdir, "feat.params");
ps_add_file(ps, "-senmgau", hmmdir, "senmgau");
}
/* Look for feat.params in acoustic model dir. */
if ((featparams = cmd_ln_str_r(ps->config, "-featparams"))) {
if (NULL !=
cmd_ln_parse_file_r(ps->config, feat_defn, featparams, FALSE))
E_INFO("Parsed model-specific feature parameters from %s\n",
featparams);
}
/* Print here because acmod_init might load feat.params file */
if (err_get_logfp() != NULL) {
cmd_ln_print_values_r(ps->config, err_get_logfp(), ps_args());
}
}
int
main(int argc, char *argv[])
{
char const *cfg;
int i;
int16 buf[2048];
if (argc == 2) {
config = cmd_ln_parse_file_r(NULL, cont_args_def, argv[1], TRUE);
}
else {
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, FALSE);
}
/* 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)
return 1;
singlefile = cmd_ln_boolean_r(config, "-singlefile");
if ((infile_path = cmd_ln_str_r(config, "-infile")) != NULL) {
if ((infile = fopen(infile_path, "rb")) == NULL) {
E_FATAL_SYSTEM("Failed to read audio from '%s'", infile_path);
return 1;
}
read_audio = &read_audio_file;
/* skip wav header */
read_audio(buf, 44);
}
else {
if ((ad = ad_open_dev(cmd_ln_str_r(config, "-adcdev"),
(int) cmd_ln_float32_r(config,
"-samprate"))) ==
NULL) {
E_FATAL("Failed to open audio device\n");
return 1;
}
read_audio = &read_audio_adev;
printf("Start recording ...\n");
fflush(stdout);
if (ad_start_rec(ad) < 0)
E_FATAL("Failed to start recording\n");
/* TODO remove this thing */
for (i = 0; i < 5; i++) {
sleep_msec(200);
read_audio(buf, 2048);
}
printf("You may speak now\n");
fflush(stdout);
}
fe = fe_init_auto_r(config);
if (fe == NULL)
return 1;
segment_audio();
if (ad)
ad_close(ad);
if (infile)
fclose(infile);
fe_free(fe);
cmd_ln_free_r(config);
return 0;
}
acmod_t *
acmod_init(cmd_ln_t *config, logmath_t *lmath, fe_t *fe, feat_t *fcb)
{
acmod_t *acmod;
char const *featparams;
acmod = ckd_calloc(1, sizeof(*acmod));
acmod->config = cmd_ln_retain(config);
acmod->lmath = lmath;
acmod->state = ACMOD_IDLE;
/* Look for feat.params in acoustic model dir. */
if ((featparams = cmd_ln_str_r(acmod->config, "-featparams"))) {
if (NULL !=
cmd_ln_parse_file_r(acmod->config, feat_defn, featparams, FALSE))
E_INFO("Parsed model-specific feature parameters from %s\n",
featparams);
}
/* Initialize feature computation. */
if (fe) {
if (acmod_fe_mismatch(acmod, fe))
goto error_out;
fe_retain(fe);
acmod->fe = fe;
}
else {
/* Initialize a new front end. */
acmod->fe = fe_init_auto_r(config);
if (acmod->fe == NULL)
goto error_out;
if (acmod_fe_mismatch(acmod, acmod->fe))
goto error_out;
}
if (fcb) {
if (acmod_feat_mismatch(acmod, fcb))
goto error_out;
feat_retain(fcb);
acmod->fcb = fcb;
}
else {
/* Initialize a new fcb. */
if (acmod_init_feat(acmod) < 0)
goto error_out;
}
/* Load acoustic model parameters. */
if (acmod_init_am(acmod) < 0)
goto error_out;
/* The MFCC buffer needs to be at least as large as the dynamic
* feature window. */
acmod->n_mfc_alloc = acmod->fcb->window_size * 2 + 1;
acmod->mfc_buf = (mfcc_t **)
ckd_calloc_2d(acmod->n_mfc_alloc, acmod->fcb->cepsize,
sizeof(**acmod->mfc_buf));
/* Feature buffer has to be at least as large as MFCC buffer. */
acmod->n_feat_alloc = acmod->n_mfc_alloc + cmd_ln_int32_r(config, "-pl_window");
acmod->feat_buf = feat_array_alloc(acmod->fcb, acmod->n_feat_alloc);
acmod->framepos = ckd_calloc(acmod->n_feat_alloc, sizeof(*acmod->framepos));
acmod->utt_start_frame = 0;
/* Senone computation stuff. */
acmod->senone_scores = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_scores));
acmod->senone_active_vec = bitvec_alloc(bin_mdef_n_sen(acmod->mdef));
acmod->senone_active = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_active));
acmod->log_zero = logmath_get_zero(acmod->lmath);
acmod->compallsen = cmd_ln_boolean_r(config, "-compallsen");
return acmod;
error_out:
acmod_free(acmod);
return NULL;
}
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
main(int argc, char *argv[])
{
cmd_ln_t *config;
ps_decoder_t *ps;
int32 out_score;
const char *input_file_path;
const char *cfg;
const char *utt_id;
const char *hyp;
FILE *input_file;
int16 buf[PCM_BUF_LEN];
int k;
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)
return 1;
if (cmd_ln_str_r(config, "-kws") == NULL && cmd_ln_str_r(config, "-keyphrase") == NULL) {
E_ERROR("Keyword is missing. Use -keyphrase <keyphrase> or -kws <kws_file> to specify the phrase to look for.");
return 1;
}
input_file_path = cmd_ln_str_r(config, "-infile");
if (input_file_path == NULL) {
E_ERROR("Input file is missing. Use -infile <input_file> to specify the file to look in.\n");
return 1;
}
ps_default_search_args(config);
ps = ps_init(config);
if (ps == NULL) {
E_ERROR("Failed to create the decoder\n");
return 1;
}
input_file = fopen(input_file_path, "rb");
if (input_file == NULL) {
E_FATAL_SYSTEM("Failed to open input file '%s'", input_file_path);
}
ps_start_utt(ps, NULL);
if (cmd_ln_boolean_r(config, "-adcin")) {
fread(buf, 1, 44, input_file);
while ((k = fread(buf, sizeof(int16), PCM_BUF_LEN, input_file)) > 0) {
ps_process_raw(ps, buf, k, FALSE, FALSE);
}
} else {
mfcc_t **mfcs;
int nfr;
if (NULL == (mfcs = read_mfc_file(input_file, &nfr, cmd_ln_int32_r(config, "-ceplen")))) {
E_ERROR("Failed to read MFCC from the file '%s'\n", input_file_path);
fclose(input_file);
return -1;
}
ps_process_cep(ps, mfcs, nfr, FALSE, TRUE);
ckd_free_2d(mfcs);
}
ps_end_utt(ps);
hyp = ps_get_hyp(ps, &out_score, &utt_id);
printf("hypothesis: %s\n", hyp);
fflush(stdout);
fclose(input_file);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
SWIGINTERN Config *new_Config__SWIG_1(char const *file){
Config *c = cmd_ln_parse_file_r(NULL, ps_args(), file, FALSE);
return c;
}
int
main(int argc, char *argv[])
{
acmod_t *acmod;
logmath_t *lmath;
cmd_ln_t *config;
FILE *rawfh;
int16 *buf;
int16 const *bptr;
mfcc_t **cepbuf, **cptr;
size_t nread, nsamps;
int nfr;
int frame_counter;
int bestsen1[270];
lmath = logmath_init(1.0001, 0, 0);
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-compallsen", "true",
"-cmn", "live",
"-tmatfloor", "0.0001",
"-mixwfloor", "0.001",
"-varfloor", "0.0001",
"-mmap", "no",
"-topn", "4",
"-ds", "1",
"-samprate", "16000", NULL);
TEST_ASSERT(config);
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);
TEST_ASSERT(acmod = acmod_init(config, lmath, NULL, NULL));
cmn_live_set(acmod->fcb->cmn_struct, cmninit);
nsamps = 2048;
frame_counter = 0;
buf = ckd_calloc(nsamps, sizeof(*buf));
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
E_INFO("Incremental(2048):\n");
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), nsamps, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0 || nread > 0) {
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
TEST_EQUAL(frame_counter, frame_idx);
if (frame_counter < 190)
bestsen1[frame_counter] = best_score;
++frame_counter;
frame_idx = -1;
}
}
}
TEST_EQUAL(0, acmod_end_utt(acmod));
nread = 0;
{
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
bestsen1[frame_counter] = best_score;
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
/* Now try to process the whole thing at once. */
E_INFO("Whole utterance:\n");
cmn_live_set(acmod->fcb->cmn_struct, cmninit);
nsamps = ftell(rawfh) / sizeof(*buf);
clearerr(rawfh);
fseek(rawfh, 0, SEEK_SET);
buf = ckd_realloc(buf, nsamps * sizeof(*buf));
TEST_EQUAL(nsamps, fread(buf, sizeof(*buf), nsamps, rawfh));
bptr = buf;
TEST_EQUAL(0, acmod_start_utt(acmod));
acmod_process_raw(acmod, &bptr, &nsamps, TRUE);
TEST_EQUAL(0, acmod_end_utt(acmod));
{
int16 best_score;
int frame_idx = -1, best_senid;
frame_counter = 0;
while (acmod->n_feat_frame > 0) {
acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
/* Now process MFCCs and make sure we get the same results. */
cepbuf = ckd_calloc_2d(frame_counter,
fe_get_output_size(acmod->fe),
sizeof(**cepbuf));
fe_start_utt(acmod->fe);
nsamps = ftell(rawfh) / sizeof(*buf);
bptr = buf;
nfr = frame_counter;
fe_process_frames(acmod->fe, &bptr, &nsamps, cepbuf, &nfr, NULL);
fe_end_utt(acmod->fe, cepbuf[frame_counter-1], &nfr);
E_INFO("Incremental(MFCC):\n");
cmn_live_set(acmod->fcb->cmn_struct, cmninit);
TEST_EQUAL(0, acmod_start_utt(acmod));
cptr = cepbuf;
nfr = frame_counter;
frame_counter = 0;
while ((acmod_process_cep(acmod, &cptr, &nfr, FALSE)) > 0) {
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
TEST_EQUAL(frame_counter, frame_idx);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
++frame_counter;
frame_idx = -1;
}
}
TEST_EQUAL(0, acmod_end_utt(acmod));
nfr = 0;
acmod_process_cep(acmod, &cptr, &nfr, FALSE);
{
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
TEST_EQUAL(frame_counter, frame_idx);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
++frame_counter;
frame_idx = -1;
}
}
/* Note that we have to process the whole thing again because
* !#@$@ s2mfc2feat modifies its argument (not for long) */
fe_start_utt(acmod->fe);
nsamps = ftell(rawfh) / sizeof(*buf);
bptr = buf;
nfr = frame_counter;
fe_process_frames(acmod->fe, &bptr, &nsamps, cepbuf, &nfr, NULL);
fe_end_utt(acmod->fe, cepbuf[frame_counter-1], &nfr);
E_INFO("Whole utterance (MFCC):\n");
cmn_live_set(acmod->fcb->cmn_struct, cmninit);
TEST_EQUAL(0, acmod_start_utt(acmod));
cptr = cepbuf;
nfr = frame_counter;
acmod_process_cep(acmod, &cptr, &nfr, TRUE);
TEST_EQUAL(0, acmod_end_utt(acmod));
{
int16 best_score;
int frame_idx = -1, best_senid;
frame_counter = 0;
while (acmod->n_feat_frame > 0) {
acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
E_INFO("Rewound (MFCC):\n");
TEST_EQUAL(0, acmod_rewind(acmod));
{
int16 best_score;
int frame_idx = -1, best_senid;
frame_counter = 0;
while (acmod->n_feat_frame > 0) {
acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
/* Clean up, go home. */
ckd_free_2d(cepbuf);
fclose(rawfh);
ckd_free(buf);
acmod_free(acmod);
logmath_free(lmath);
cmd_ln_free_r(config);
return 0;
}
int main(int argc, char* argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
FILE *fh;
int rv;
char const *hyp, *uttid;
int32 score;
int16 buf[512];
/*
*config = cmd_ln_init(NULL, ps_args(), TRUE,
* "-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
* "-lm", MODELDIR "/lm/en/turtle.DMP",
* "-dict", MODELDIR "/lm/en/turtle.dic",
* NULL);
*/
config = cmd_ln_parse_file_r(NULL, ps_args(), "commands.gram", FALSE);
if ( config == NULL )
return 1;
ps = ps_init(config);
if ( ps == NULL )
return 1;
// Audio file for test
fh = fopen("goforward.raw", "rb");
if ( fh == NULL ) {
perror("Failed to open file");
return 1;
}
// Decoding
rv = ps_decode_raw(ps, fh, "goforward", -1);
if ( rv < 0 )
return 1;
// Hypothesis
hyp = ps_get_hyp(ps, &score, &uttid);
if ( hyp == NULL )
return 1;
printf("Recognized: %s (%d %s)\n", hyp, score, uttid);
/* Do it again, from block memory
fseek(fh, 0, SEEK_SET);
while ( !feof(fh) ) {
size_t nsamp;
nsamp = fread(buf, 2, 512, fh);
rv = ps_process_raw(ps, buf, nsamp, FALSE, FALSE);
}
// End of the utterance
rv = ps_end_utt(ps);
if ( rv < 0 )
return 1;
// Retrieving hypothesis
hyp = ps_get_hyp(ps, &score, &uttid);
if ( hyp == NULL )
return 1;
printf("Recognized: %s (%d %s)\n", hyp, score, uttid);*/
// Cleaning up
fclose(fh);
ps_free(ps);
return 0;
}
