static int
write_hypseg(FILE *fh, ps_decoder_t *ps, char const *uttid)
{
int32 score, lscr, sf, ef;
ps_seg_t *itor = ps_seg_iter(ps, &score);
/* Accumulate language model scores. */
lscr = 0;
while (itor) {
int32 ascr, wlscr;
ps_seg_prob(itor, &ascr, &wlscr, NULL);
lscr += wlscr;
itor = ps_seg_next(itor);
}
fprintf(fh, "%s S %d T %d A %d L %d", uttid,
0, /* "scaling factor" which is mostly useless anyway */
score, score - lscr, lscr);
/* Now print out words. */
itor = ps_seg_iter(ps, &score);
while (itor) {
char const *w = ps_seg_word(itor);
int32 ascr, wlscr;
ps_seg_prob(itor, &ascr, &wlscr, NULL);
ps_seg_frames(itor, &sf, &ef);
fprintf(fh, " %d %d %d %s", sf, ascr, wlscr, w);
itor = ps_seg_next(itor);
}
fprintf(fh, " %d\n", ef);
return 0;
}
int
ps_end_utt(ps_decoder_t *ps)
{
int rv, i;
acmod_end_utt(ps->acmod);
/* Search any remaining frames. */
if ((rv = ps_search_forward(ps)) < 0) {
ptmr_stop(&ps->perf);
return rv;
}
/* Finish phone loop search. */
if (ps->phone_loop) {
if ((rv = ps_search_finish(ps->phone_loop)) < 0) {
ptmr_stop(&ps->perf);
return rv;
}
}
/* Search any frames remaining in the lookahead window. */
for (i = ps->acmod->output_frame - ps->pl_window;
i < ps->acmod->output_frame; ++i)
ps_search_step(ps->search, i);
/* Finish main search. */
if ((rv = ps_search_finish(ps->search)) < 0) {
ptmr_stop(&ps->perf);
return rv;
}
ptmr_stop(&ps->perf);
/* Log a backtrace if requested. */
if (cmd_ln_boolean_r(ps->config, "-backtrace")) {
char const *uttid, *hyp;
ps_seg_t *seg;
int32 score;
hyp = ps_get_hyp(ps, &score, &uttid);
if (hyp != NULL) {
E_INFO("%s: %s (%d)\n", uttid, hyp, score);
E_INFO_NOFN("%-20s %-5s %-5s %-5s %-10s %-10s %-3s\n",
"word", "start", "end", "pprob", "ascr", "lscr", "lback");
for (seg = ps_seg_iter(ps, &score); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
int32 post, lscr, ascr, lback;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
post = ps_seg_prob(seg, &ascr, &lscr, &lback);
E_INFO_NOFN("%-20s %-5d %-5d %-1.3f %-10d %-10d %-3d\n",
word, sf, ef, logmath_exp(ps_get_logmath(ps), post),
ascr, lscr, lback);
}
}
}
return rv;
}
void EventHandlerSegment::event(ps_decoder_t* decoder)
{
std::vector<std::string> segments;
ps_seg_t* iter = ps_seg_iter( decoder, NULL );
while( iter != NULL ) {
segments.push_back( std::string( ps_seg_word( iter ) ) );
iter = ps_seg_next( iter );
}
if( ! segments.empty() )
mCb( segments );
}
/*
* Continuous recognition from mic
*/
int
recognize_from_mic()
{
ad_rec_t *ad;
int16 adbuf[2048];
const char *fname;
const char* seg;
int32 k;
char str[1000]="";
uint8 utt_started, in_speech;
if ((ad = ad_open_dev(cmd_ln_str_r(config, "-adcdev"),16000)) == NULL)
perror("Failed to open audio device\n");
if (ad_start_rec(ad) < 0)
perror("Failed to start recording\n");
ps_start_utt(ps);
utt_started = FALSE;
ps_seg_t *psegt;
while (!finished) {
if ((k = ad_read(ad, adbuf, 2048)) < 0)
perror("Failed to read audio\n");
ps_process_raw(ps, adbuf, k, FALSE, FALSE);
in_speech = ps_get_in_speech(ps);
if (in_speech && !utt_started) {
utt_started = TRUE;
}
if (!in_speech && utt_started) {
ps_end_utt(ps);
psegt = ps_seg_iter(ps, NULL);
while (psegt!=NULL){
seg = ps_seg_word(psegt);
strncpy_s( str, seg, strlen(seg));
listenCallback(str);
printf("%s\n", seg);
int prob = ps_seg_prob(psegt,NULL,NULL,NULL);
printf("%d\n", prob);
psegt = ps_seg_next(psegt);
}
ps_start_utt(ps);
utt_started = FALSE;
}
Sleep(100);
}
ps_end_utt(ps);
fclose(rawfd);
return 0;
}
static void
print_word_times(int32 start)
{
ps_seg_t *iter = ps_seg_iter(ps, NULL);
while (iter != NULL) {
int32 sf, ef, pprob;
float conf;
ps_seg_frames (iter, &sf, &ef);
pprob = ps_seg_prob (iter, NULL, NULL, NULL);
conf = logmath_exp(ps_get_logmath(ps), pprob);
fprintf (stderr, "%s %f %f %f\n", ps_seg_word (iter), (sf + start) / 100.0, (ef + start) / 100.0, conf);
iter = ps_seg_next (iter);
}
}
void EventHandlerSegmentConfidence::event(ps_decoder_t *decoder)
{
std::vector<std::pair<std::string,float> > segments;
ps_seg_t* iter = ps_seg_iter( decoder, NULL );
while( iter != NULL ) {
int32 prob = ps_seg_prob( iter, NULL, NULL, NULL );
segments.push_back( { std::string( ps_seg_word( iter ) ), logmath_exp( ps_get_logmath( decoder ), prob ) } );
iter = ps_seg_next( iter );
}
if( ! segments.empty() )
mCb( segments );
}
static void
print_word_times()
{
int frame_rate = cmd_ln_int32_r(config, "-frate");
ps_seg_t *iter = ps_seg_iter(ps);
while (iter != NULL) {
int32 sf, ef, pprob;
float conf;
ps_seg_frames(iter, &sf, &ef);
pprob = ps_seg_prob(iter, NULL, NULL, NULL);
conf = logmath_exp(ps_get_logmath(ps), pprob);
printf("%s %.3f %.3f %f\n", ps_seg_word(iter), ((float)sf / frame_rate),
((float) ef / frame_rate), conf);
iter = ps_seg_next(iter);
}
}
ReturnType Recognizer::getHypseg(Segmentation& seg) {
if ((decoder == NULL) || (is_recording)) return BAD_STATE;
seg.clear();
int32 scoreh=0, sfh=0, efh=0;
std::string hseg;
ps_seg_t *itor = ps_seg_iter(decoder, &scoreh);
while (itor) {
SegItem segItem;
segItem.word = ps_seg_word(itor);
ps_seg_frames(itor, &sfh, &efh);
segItem.start = sfh;
segItem.end = efh;
seg.push_back(segItem);
itor = ps_seg_next(itor);
}
return SUCCESS;
}
void ofApp::process_result()
{
int frame_rate = cmd_ln_int32_r(config, "-frate");
ps_seg_t *iter = ps_seg_iter(ps, NULL);
printf("\n\n");
while (iter != NULL)
{
int32 sf, ef, pprob;
float conf;
ps_seg_frames(iter, &sf, &ef);
pprob = ps_seg_prob(iter, NULL, NULL, NULL);
conf = logmath_exp(ps_get_logmath(ps), pprob);
//here is where we process the word
new_utterance new_utt;
new_utt.conf = conf;
new_utt.sf = sf;
new_utt.st = (float)sf / frame_rate;
new_utt.ef = ef;
new_utt.et = (float) ef / frame_rate;
new_utt.utt = ps_seg_word(iter);
printf("Recognised: %s %.3f %.3f %f\n", ps_seg_word(iter), new_utt.st,
new_utt.et, new_utt.conf);
std::string word = ps_seg_word(iter);
result.push_back(new_utt);
iter = ps_seg_next(iter);
}
printf("\n\n");
engineExit();
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
fsg_search_t *fsgs;
ps_lattice_t *dag;
ps_seg_t *seg;
int32 score;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", DATADIR "/tidigits/hmm",
"-fsg", DATADIR "/tidigits/lm/tidigits.fsg",
"-dict", DATADIR "/tidigits/lm/tidigits.dic",
"-bestpath", "no",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
fsgs = (fsg_search_t *)ps->search;
acmod = ps->acmod;
setbuf(stdout, NULL);
{
FILE *rawfh;
int16 buf[2048];
size_t nread;
int16 const *bptr;
char const *hyp;
int nfr;
TEST_ASSERT(rawfh = fopen(DATADIR "/numbers.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
fsg_search_start(ps_search_base(fsgs));
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);
}
}
}
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);
}
for (seg = ps_seg_iter(ps); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
int32 post, lscr, ascr, lback;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
post = ps_seg_prob(seg, &ascr, &lscr, &lback);
printf("%s (%d:%d) P(w|o) = %f ascr = %d lscr = %d lback = %d\n", word, sf, ef,
logmath_exp(ps_get_logmath(ps), post), ascr, lscr, lback);
}
/* Now get the DAG and play with it. */
dag = ps_get_lattice(ps);
ps_lattice_write(dag, "test_fsg3.lat");
printf("BESTPATH: %s\n",
ps_lattice_hyp(dag, ps_lattice_bestpath(dag, NULL, 1.0, 15.0)));
ps_lattice_posterior(dag, NULL, 15.0);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
ps_decoder_test(cmd_ln_t *config, char const *sname, char const *expected)
{
ps_decoder_t *ps;
mfcc_t **cepbuf;
FILE *rawfh;
int16 *buf;
int16 const *bptr;
size_t nread;
size_t nsamps;
int32 nfr, i, score, prob;
char const *hyp;
char const *uttid;
double n_speech, n_cpu, n_wall;
ps_seg_t *seg;
TEST_ASSERT(ps = ps_init(config));
/* Test it first with pocketsphinx_decode_raw() */
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): %s (%d, %d)\n", sname, uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp(hyp, expected));
TEST_ASSERT(prob <= 0);
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
printf("%.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("%.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
/* Test it with ps_process_raw() */
clearerr(rawfh);
fseek(rawfh, 0, SEEK_END);
nsamps = ftell(rawfh) / sizeof(*buf);
fseek(rawfh, 0, SEEK_SET);
TEST_EQUAL(0, ps_start_utt(ps, NULL));
nsamps = 2048;
buf = ckd_calloc(nsamps, sizeof(*buf));
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), nsamps, rawfh);
ps_process_raw(ps, buf, nread, FALSE, FALSE);
}
TEST_EQUAL(0, ps_end_utt(ps));
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s (%s): %s (%d, %d)\n", sname, uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp(uttid, "000000000"));
TEST_EQUAL(0, strcmp(hyp, expected));
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
printf("%.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("%.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
/* Now read the whole file and produce an MFCC buffer. */
clearerr(rawfh);
fseek(rawfh, 0, SEEK_END);
nsamps = ftell(rawfh) / sizeof(*buf);
fseek(rawfh, 0, SEEK_SET);
bptr = buf = ckd_realloc(buf, nsamps * sizeof(*buf));
TEST_EQUAL(nsamps, fread(buf, sizeof(*buf), nsamps, rawfh));
fe_process_frames(ps->acmod->fe, &bptr, &nsamps, NULL, &nfr);
cepbuf = ckd_calloc_2d(nfr + 1,
fe_get_output_size(ps->acmod->fe),
sizeof(**cepbuf));
fe_start_utt(ps->acmod->fe);
fe_process_frames(ps->acmod->fe, &bptr, &nsamps, cepbuf, &nfr);
fe_end_utt(ps->acmod->fe, cepbuf[nfr], &i);
/* Decode it with process_cep() */
TEST_EQUAL(0, ps_start_utt(ps, NULL));
for (i = 0; i < nfr; ++i) {
ps_process_cep(ps, cepbuf + i, 1, FALSE, FALSE);
}
TEST_EQUAL(0, ps_end_utt(ps));
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s (%s): %s (%d, %d)\n", sname, uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp(uttid, "000000001"));
TEST_EQUAL(0, strcmp(hyp, expected));
TEST_ASSERT(prob <= 0);
for (seg = ps_seg_iter(ps, &score); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
int32 post, lscr, ascr, lback;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
post = ps_seg_prob(seg, &ascr, &lscr, &lback);
printf("%s (%d:%d) P(w|o) = %f ascr = %d lscr = %d lback = %d\n", word, sf, ef,
logmath_exp(ps_get_logmath(ps), post), ascr, lscr, lback);
TEST_ASSERT(post <= 2); // Due to numerical errors with float it sometimes could go out of 0
}
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
printf("%.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("%.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
ps_get_all_time(ps, &n_speech, &n_cpu, &n_wall);
printf("TOTAL: %.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("TOTAL: %.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
fclose(rawfh);
ps_free(ps);
cmd_ln_free_r(config);
ckd_free_2d(cepbuf);
ckd_free(buf);
return 0;
}
static void
process_ctl(ps_decoder_t *ps, cmd_ln_t *config, FILE *ctlfh)
{
int32 ctloffset, ctlcount, ctlincr;
int32 i;
char *line;
size_t len;
FILE *hypfh = NULL, *hypsegfh = NULL, *ctmfh = NULL;
FILE *mllrfh = NULL, *lmfh = NULL, *fsgfh = NULL;
double n_speech, n_cpu, n_wall;
char const *outlatdir;
char const *nbestdir;
char const *str;
int frate;
ctloffset = cmd_ln_int32_r(config, "-ctloffset");
ctlcount = cmd_ln_int32_r(config, "-ctlcount");
ctlincr = cmd_ln_int32_r(config, "-ctlincr");
outlatdir = cmd_ln_str_r(config, "-outlatdir");
nbestdir = cmd_ln_str_r(config, "-nbestdir");
frate = cmd_ln_int32_r(config, "-frate");
if ((str = cmd_ln_str_r(config, "-mllrctl"))) {
mllrfh = fopen(str, "r");
if (mllrfh == NULL) {
E_ERROR_SYSTEM("Failed to open MLLR control file file %s", str);
goto done;
}
}
if ((str = cmd_ln_str_r(config, "-fsgctl"))) {
fsgfh = fopen(str, "r");
if (fsgfh == NULL) {
E_ERROR_SYSTEM("Failed to open FSG control file file %s", str);
goto done;
}
}
if ((str = cmd_ln_str_r(config, "-lmnamectl"))) {
lmfh = fopen(str, "r");
if (lmfh == NULL) {
E_ERROR_SYSTEM("Failed to open LM name control file file %s", str);
goto done;
}
}
if ((str = cmd_ln_str_r(config, "-hyp"))) {
hypfh = fopen(str, "w");
if (hypfh == NULL) {
E_ERROR_SYSTEM("Failed to open hypothesis file %s for writing", str);
goto done;
}
setbuf(hypfh, NULL);
}
if ((str = cmd_ln_str_r(config, "-hypseg"))) {
hypsegfh = fopen(str, "w");
if (hypsegfh == NULL) {
E_ERROR_SYSTEM("Failed to open hypothesis file %s for writing", str);
goto done;
}
setbuf(hypsegfh, NULL);
}
if ((str = cmd_ln_str_r(config, "-ctm"))) {
ctmfh = fopen(str, "w");
if (ctmfh == NULL) {
E_ERROR_SYSTEM("Failed to open hypothesis file %s for writing", str);
goto done;
}
setbuf(ctmfh, NULL);
}
i = 0;
while ((line = fread_line(ctlfh, &len))) {
char *wptr[4];
int32 nf, sf, ef;
char *mllrline = NULL, *lmline = NULL, *fsgline = NULL;
char *fsgfile = NULL, *lmname = NULL, *mllrfile = NULL;
if (mllrfh) {
mllrline = fread_line(mllrfh, &len);
if (mllrline == NULL) {
E_ERROR("File size mismatch between control and MLLR control\n");
ckd_free(line);
ckd_free(mllrline);
goto done;
}
mllrfile = string_trim(mllrline, STRING_BOTH);
}
if (lmfh) {
lmline = fread_line(lmfh, &len);
if (lmline == NULL) {
E_ERROR("File size mismatch between control and LM control\n");
ckd_free(line);
ckd_free(lmline);
goto done;
}
lmname = string_trim(lmline, STRING_BOTH);
}
if (fsgfh) {
fsgline = fread_line(fsgfh, &len);
if (fsgline == NULL) {
E_ERROR("File size mismatch between control and FSG control\n");
ckd_free(line);
ckd_free(fsgline);
goto done;
}
fsgfile = string_trim(fsgline, STRING_BOTH);
}
if (i < ctloffset) {
i += ctlincr;
goto nextline;
}
if (ctlcount != -1 && i >= ctloffset + ctlcount) {
goto nextline;
}
sf = 0;
ef = -1;
nf = str2words(line, wptr, 4);
if (nf == 0) {
/* Do nothing. */
}
else if (nf < 0) {
E_ERROR("Unexpected extra data in control file at line %d\n", i);
}
else {
char const *hyp, *file, *uttid;
int32 score;
file = wptr[0];
uttid = NULL;
if (nf > 1)
sf = atoi(wptr[1]);
if (nf > 2)
ef = atoi(wptr[2]);
if (nf > 3)
uttid = wptr[3];
E_INFO("Decoding '%s'\n", uttid ? uttid : file);
/* Do actual decoding. */
if(process_mllrctl_line(ps, config, mllrfile) < 0)
continue;
if(process_lmnamectl_line(ps, config, lmname) < 0)
continue;
if(process_fsgctl_line(ps, config, fsgfile) < 0)
continue;
if(process_ctl_line(ps, config, file, uttid, sf, ef) < 0)
continue;
hyp = ps_get_hyp(ps, &score, &uttid);
/* Write out results and such. */
if (hypfh) {
fprintf(hypfh, "%s (%s %d)\n", hyp ? hyp : "", uttid, score);
}
if (hypsegfh) {
write_hypseg(hypsegfh, ps, uttid);
}
if (ctmfh) {
ps_seg_t *itor = ps_seg_iter(ps, &score);
write_ctm(ctmfh, ps, itor, uttid, frate);
}
if (outlatdir) {
write_lattice(ps, outlatdir, uttid);
}
if (nbestdir) {
write_nbest(ps, nbestdir, uttid);
}
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
E_INFO("%s: %.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
uttid, n_speech, n_cpu, n_wall);
E_INFO("%s: %.2f xRT (CPU), %.2f xRT (elapsed)\n",
uttid, n_cpu / n_speech, n_wall / n_speech);
E_INFO_NOFN("%s (%s %d)\n", hyp ? hyp : "", uttid, score);
}
i += ctlincr;
nextline:
ckd_free(mllrline);
ckd_free(fsgline);
ckd_free(lmline);
ckd_free(line);
}
ps_get_all_time(ps, &n_speech, &n_cpu, &n_wall);
E_INFO("TOTAL %.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
E_INFO("AVERAGE %.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
done:
if (hypfh)
fclose(hypfh);
if (hypsegfh)
fclose(hypsegfh);
if (ctmfh)
fclose(ctmfh);
}
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;
}