static void
utt_livepretend(void *data, utt_res_t * ur, int32 sf, int32 ef,
char *uttid)
{
char fullrawfn[FILENAME_LENGTH];
char *hypstr;
short samples[SAMPLE_BUFFER_LENGTH];
float32 **frames;
kb_t *kb;
FILE *rawfd;
int len, n_frames;
kb = (kb_t *) data;
/* report_utt_res(ur); */
sprintf(fullrawfn, "%s/%s%s", rawdirfn, ur->uttfile, decoder.rawext);
if ((rawfd = fopen(fullrawfn, "rb")) == NULL) {
E_FATAL("Cannnot open raw file %s.\n", fullrawfn);
}
/* temporary hack */
/* fread(waveheader, 1, 44, rawfd); */
if (ur->lmname != NULL)
srch_set_lm((srch_t *) kb->srch, ur->lmname);
if (ur->regmatname != NULL)
kb_setmllr(ur->regmatname, ur->cb2mllrname, kb);
if (s3_decode_begin_utt(&decoder, ur->uttfile) != S3_DECODE_SUCCESS)
E_FATAL("Cannot begin utterance decoding.\n");
len = fread(samples, sizeof(short), SAMPLE_BUFFER_LENGTH, rawfd);
while (len > 0) {
ptmr_start(&(st->tm));
fe_process_utt(fe, samples, len, &frames, &n_frames);
if (frames != NULL) {
s3_decode_process(&decoder, frames, n_frames);
ckd_free_2d((void **)frames);
}
ptmr_stop(&(st->tm));
if (S3_DECODE_SUCCESS ==
s3_decode_hypothesis(&decoder, NULL, &hypstr, NULL))
if (decoder.phypdump)
E_INFO("PARTIAL_HYP: %s\n", hypstr);
len = fread(samples, sizeof(short), SAMPLE_BUFFER_LENGTH, rawfd);
}
fclose(rawfd);
s3_decode_end_utt(&decoder);
}
int ofxSphinxASR::engineSentAudio(short *audioBuf, int audioSize)
{
float32 **frames;
int n_frames;
if (!bEngineInitialed)
return OFXASR_HAVE_NOT_INIT;
if (!bEngineOpened)
return OFXASR_HAVE_NOT_START;
fe_process_utt(fe, audioBuf, audioSize, &frames, &n_frames);
if (frames != NULL) {
s3_decode_process(decoder, frames, n_frames);
ckd_free_2d((void **)frames);
}
return OFXASR_SUCCESS;
}
int
ld_utt_proc_raw_impl(live_decoder_t *decoder,
int16 *samples,
int32 num_samples,
int32 begin_utt,
int32 end_utt)
{
float32 dummy_frame[MAX_CEP_LEN];
float32 **frames = 0;
int32 num_frames = 0;
int32 num_features = 0;
num_frames = fe_process_utt(decoder->fe, samples, num_samples, &frames);
if (end_utt) {
fe_end_utt(decoder->fe, dummy_frame);
}
if (num_frames > 0) {
num_features = feat_s2mfc2feat_block(kbcore_fcb(decoder->kbcore),
frames,
num_frames,
begin_utt,
end_utt,
decoder->features);
}
if (num_features > 0) {
utt_decode_block(decoder->features,
num_features,
&decoder->frame_num,
&decoder->kb,
decoder->max_wpf,
decoder->max_histpf,
decoder->max_hmmpf,
decoder->phones_skip,
decoder->hmm_log);
}
if (frames) {
ckd_free_2d((void **)frames);
}
return 0;
}
static int
process(sbthread_t *th)
{
FILE *raw;
int16 *buf;
mfcc_t **cepbuf;
size_t nsamps;
fe_t *fe;
long fsize;
int32 nfr;
char outfile[16];
FILE *logfile;
sprintf(outfile, "%03ld.log", (long) sbthread_arg(th));
logfile = fopen(outfile, "w");
pthread_setspecific(logfp_index, (void *)logfile);
if ((fe = fe_init_auto_r(sbthread_config(th))) == NULL)
return -1;
if ((raw = fopen(TESTDATADIR "/chan3.raw", "rb")) == NULL)
return -1;
fseek(raw, 0, SEEK_END);
fsize = ftell(raw);
fseek(raw, 0, SEEK_SET);
buf = ckd_malloc(fsize);
fread(buf, 1, fsize, raw);
nsamps = fsize / 2;
fe_process_utt(fe, buf, nsamps, &cepbuf, &nfr);
E_INFO("nfr = %d\n", nfr);
fe_free_2d(cepbuf);
ckd_free(buf);
fclose(raw);
fe_free(fe);
fclose(logfile);
return 0;
}
static void
utt_livepretend(void *data, utt_res_t * ur, int32 sf, int32 ef,
char *uttid)
{
char fullrawfn[FILENAME_LENGTH];
char *hypstr;
cont_ad_t *cont_ad;
ad_rec_t bogus_ad;
short samples[SAMPLE_BUFFER_LENGTH];
float32 **frames;
kb_t *kb;
int nread, n_frames, seg_n_frames;
int ts, listening;
kb = (kb_t *) data;
/* report_utt_res(ur); */
sprintf(fullrawfn, "%s/%s%s", rawdirfn, ur->uttfile, decoder.rawext);
if ((rawfd = fopen(fullrawfn, "rb")) == NULL) {
E_FATAL("Cannnot open raw file %s.\n", fullrawfn);
}
if (ur->lmname != NULL)
srch_set_lm((srch_t *) kb->srch, ur->lmname);
if (ur->regmatname != NULL)
kb_setmllr(ur->regmatname, ur->cb2mllrname, kb);
bogus_ad.sps = (int32) cmd_ln_float32_r(kb->kbcore->config, "-samprate");
if ((cont_ad = cont_ad_init(&bogus_ad, ad_file_read)) == NULL) {
E_FATAL("Failed to initialize energy-based endpointer");
}
listening = 0;
ts = 0;
seg_n_frames = 0;
while ((nread = cont_ad_read(cont_ad, samples, SAMPLE_BUFFER_LENGTH))
>= 0) {
if (nread) {
ts = cont_ad->read_ts;
if (!listening) {
char uttid[FILENAME_LENGTH];
sprintf(uttid, "%s_%.3f", ur->uttfile,
(double) ts / bogus_ad.sps);
if (s3_decode_begin_utt(&decoder, uttid) != S3_DECODE_SUCCESS)
E_FATAL("Cannot begin utterance decoding.\n");
listening = 1;
}
ptmr_start(&(st->tm));
fe_process_utt(fe, samples, nread, &frames, &n_frames);
seg_n_frames += n_frames;
if (frames != NULL) {
s3_decode_process(&decoder, frames, n_frames);
ckd_free_2d((void **)frames);
}
ptmr_stop(&(st->tm));
if (s3_decode_hypothesis(&decoder, NULL, &hypstr, NULL) ==
S3_DECODE_SUCCESS) {
if (decoder.phypdump) {
E_INFO("PARTIAL_HYP: %s\n", hypstr);
}
}
/* If the segment is too long, break it. */
if (seg_n_frames > 15000) {
s3_decode_end_utt(&decoder);
listening = 0;
}
}
else {
if (listening && cont_ad->read_ts - ts > 8000) { /* HACK */
s3_decode_end_utt(&decoder);
listening = 0;
}
}
}
fclose(rawfd);
cont_ad_close(cont_ad);
if (listening)
s3_decode_end_utt(&decoder);
}
int
main(int argc, char *argv[])
{
static const arg_t fe_args[] = {
waveform_to_cepstral_command_line_macro(),
{ NULL, 0, NULL, NULL }
};
FILE *raw;
cmd_ln_t *config;
fe_t *fe;
int16 buf[1024];
int16 const *inptr;
int32 frame_shift, frame_size;
mfcc_t **cepbuf1, **cepbuf2, **cptr;
int32 nfr, i;
size_t nsamp;
TEST_ASSERT(config = cmd_ln_parse_r(NULL, fe_args, argc, argv, FALSE));
TEST_ASSERT(fe = fe_init_auto_r(config));
TEST_EQUAL(fe_get_output_size(fe), DEFAULT_NUM_CEPSTRA);
fe_get_input_size(fe, &frame_shift, &frame_size);
TEST_EQUAL(frame_shift, DEFAULT_FRAME_SHIFT);
TEST_EQUAL(frame_size, (int)(DEFAULT_WINDOW_LENGTH*DEFAULT_SAMPLING_RATE));
TEST_ASSERT(raw = fopen(TESTDATADIR "/chan3.raw", "rb"));
TEST_EQUAL(0, fe_start_utt(fe));
TEST_EQUAL(1024, fread(buf, sizeof(int16), 1024, raw));
nsamp = 1024;
TEST_ASSERT(fe_process_frames(fe, NULL, &nsamp, NULL, &nfr) >= 0);
TEST_EQUAL(1024, nsamp);
TEST_EQUAL(4, nfr);
cepbuf1 = ckd_calloc_2d(5, DEFAULT_NUM_CEPSTRA, sizeof(**cepbuf1));
inptr = &buf[0];
nfr = 1;
printf("frame_size %d frame_shift %d\n", frame_size, frame_shift);
/* Process the first frame. */
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[0], &nfr) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, nfr);
TEST_EQUAL(nfr, 1);
/* Note that this next one won't actually consume any frames
* of input, because it already got sufficient overflow
* samples last time around. This is implementation-dependent
* so we shouldn't actually test for it. */
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[1], &nfr) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, nfr);
TEST_EQUAL(nfr, 1);
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[2], &nfr) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, nfr);
TEST_EQUAL(nfr, 1);
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[3], &nfr) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, nfr);
TEST_EQUAL(nfr, 1);
TEST_ASSERT(fe_end_utt(fe, cepbuf1[4], &nfr) >= 0);
printf("nfr %d\n", nfr);
TEST_EQUAL(nfr, 1);
/* What we *should* test is that the output we get by
* processing one frame at a time is exactly the same as what
* we get from doing them all at once. So let's do that */
cepbuf2 = ckd_calloc_2d(5, DEFAULT_NUM_CEPSTRA, sizeof(**cepbuf2));
inptr = &buf[0];
nfr = 5;
nsamp = 1024;
TEST_EQUAL(0, fe_start_utt(fe));
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cepbuf2, &nfr) >= 0);
printf("nfr %d\n", nfr);
TEST_EQUAL(nfr, 4);
nfr = 1;
TEST_ASSERT(fe_end_utt(fe, cepbuf2[4], &nfr) >= 0);
printf("nfr %d\n", nfr);
TEST_EQUAL(nfr, 1);
for (i = 0; i < 5; ++i) {
int j;
printf("%d: ", i);
for (j = 0; j < DEFAULT_NUM_CEPSTRA; ++j) {
printf("%.2f,%.2f ",
MFCC2FLOAT(cepbuf1[i][j]),
MFCC2FLOAT(cepbuf2[i][j]));
TEST_EQUAL_FLOAT(cepbuf1[i][j], cepbuf2[i][j]);
}
printf("\n");
}
/* Now, also test to make sure that even if we feed data in
* little tiny bits we can still make things work. */
memset(cepbuf2[0], 0, 5 * DEFAULT_NUM_CEPSTRA * sizeof(**cepbuf2));
inptr = &buf[0];
cptr = &cepbuf2[0];
nfr = 5;
i = 5;
nsamp = 256;
TEST_EQUAL(0, fe_start_utt(fe));
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, i);
cptr += i;
nfr -= i;
i = nfr;
nsamp = 256;
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, i);
cptr += i;
nfr -= i;
i = nfr;
nsamp = 256;
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, i);
cptr += i;
nfr -= i;
i = nfr;
nsamp = 256;
TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
printf("inptr %d nsamp %d nfr %d\n", inptr - buf, nsamp, i);
cptr += i;
nfr -= i;
TEST_ASSERT(fe_end_utt(fe, *cptr, &nfr) >= 0);
printf("nfr %d\n", nfr);
TEST_EQUAL(nfr, 1);
for (i = 0; i < 5; ++i) {
int j;
printf("%d: ", i);
for (j = 0; j < DEFAULT_NUM_CEPSTRA; ++j) {
printf("%.2f,%.2f ",
MFCC2FLOAT(cepbuf1[i][j]),
MFCC2FLOAT(cepbuf2[i][j]));
TEST_EQUAL_FLOAT(cepbuf1[i][j], cepbuf2[i][j]);
}
printf("\n");
}
/* And now, finally, test fe_process_utt() */
inptr = &buf[0];
i = 0;
TEST_EQUAL(0, fe_start_utt(fe));
TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
printf("i %d nfr %d\n", i, nfr);
if (nfr)
memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
ckd_free_2d(cptr);
i += nfr;
inptr += 256;
TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
printf("i %d nfr %d\n", i, nfr);
if (nfr)
memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
ckd_free_2d(cptr);
i += nfr;
inptr += 256;
TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
printf("i %d nfr %d\n", i, nfr);
if (nfr)
memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
ckd_free_2d(cptr);
i += nfr;
inptr += 256;
TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
printf("i %d nfr %d\n", i, nfr);
if (nfr)
memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
ckd_free_2d(cptr);
i += nfr;
inptr += 256;
TEST_ASSERT(fe_end_utt(fe, cepbuf2[i], &nfr) >= 0);
printf("i %d nfr %d\n", i, nfr);
TEST_EQUAL(nfr, 1);
for (i = 0; i < 5; ++i) {
int j;
printf("%d: ", i);
for (j = 0; j < DEFAULT_NUM_CEPSTRA; ++j) {
printf("%.2f,%.2f ",
MFCC2FLOAT(cepbuf1[i][j]),
MFCC2FLOAT(cepbuf2[i][j]));
TEST_EQUAL_FLOAT(cepbuf1[i][j], cepbuf2[i][j]);
}
printf("\n");
}
ckd_free_2d(cepbuf1);
ckd_free_2d(cepbuf2);
fclose(raw);
fe_free(fe);
return 0;
}
int32 live_utt_decode_block (int16 *samples, int32 nsamples,
int32 live_endutt, partialhyp_t **ohyp)
{
static int32 live_begin_new_utt = 1;
static int32 frmno;
float32 **live_feat;
int32 live_nfr, live_nfeatvec;
int32 nwds;
/* int32 id; */ /* unreferenced variable */
/* glist_t hyp; */ /* unreferenced variable */
/* gnode_t *gn; */ /* unreferenced variable */
/* hyp_t *h; */ /* unreferenced variable */
/* dict_t *dict; */ /* unreferenced variable */
float32 **mfcbuf;
if (live_begin_new_utt){
fe_start_utt(fe);
utt_begin (kb);
frmno = 0;
kb->nfr = 0;
kb->utt_hmm_eval = 0;
kb->utt_sen_eval = 0;
kb->utt_gau_eval = 0;
live_begin_new_utt = 0;
}
sample_blk++;
/* 10.jan.01 RAH, fe_process_utt now requires ***mfcbuf and it allocates the memory internally) */
mfcbuf = NULL;
live_nfr = fe_process_utt(fe, samples, nsamples, &mfcbuf); /* */
if (live_endutt) /* RAH, It seems that we shouldn't throw out this data */
fe_end_utt(fe,dummyframe); /* Flush out the fe */
/* Compute feature vectors */
live_nfeatvec = feat_s2mfc2feat_block(kbcore_fcb(kbcore), mfcbuf,
live_nfr, live_begin_new_utt,
live_endutt, &live_feat);
E_INFO ("live_nfeatvec: %ld\n",live_nfeatvec);
/* decode the block */
if (sample_blk<=START_BLOCK)
single_utt_decode_block (live_feat, live_nfeatvec, &frmno, kb,
maxwpf, maxhistpf, maxhmmpf, ptranskip, hmmdumpfp);
else
utt_decode_block (live_feat, live_nfeatvec, &frmno, kb,
maxwpf, maxhistpf, maxhmmpf, ptranskip, hmmdumpfp);
/* Pull out partial hypothesis */
nwds = live_get_partialhyp(live_endutt);
*ohyp = parthyp;
/* Clean up */
if (live_endutt) {
live_begin_new_utt = 1;
kb->tot_fr += kb->nfr;
utt_end(kb);
}
else {
live_begin_new_utt = 0;
}
/* I'm starting to think that fe_process_utt should not be allocating its memory,
that or it should allocate some max and just keep on going, this idea of constantly allocating freeing
memory seems dangerous to me.*/
ckd_free_2d((void **) mfcbuf); /* RAH, this must be freed since fe_process_utt allocates it */
return(nwds);
}
static void
utt_align(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
int32 nfr;
int k, i;
const char *cepdir;
const char *cepext;
char sent[16384];
cmd_ln_t *config = (cmd_ln_t*) data;
cepdir = cmd_ln_str_r(kbc->config, "-cepdir");
cepext = cmd_ln_str_r(kbc->config, "-cepext");
/* UGLY! */
/* Read utterance transcript and match it with the control file. */
if (fgets(sent, sizeof(sent), sentfp) == NULL) {
E_FATAL("EOF(%s) of the transcription\n", sentfile);
}
/* E_INFO("SENT %s\n",sent); */
/* Strip utterance id from the end of the transcript */
for (k = strlen(sent) - 1;
(k > 0) && ((sent[k] == '\n') || (sent[k] == '\t')
|| (sent[k] == ' ')); --k);
if ((k > 0) && (sent[k] == ')')) {
for (--k; (k >= 0) && (sent[k] != '('); --k);
if ((k >= 0) && (sent[k] == '(')) {
sent[k] = '\0';
/* Check that uttid in transcript and control file match */
for (i = ++k;
sent[i] && (sent[i] != ')') &&
(sent[i] != '\n') && (sent[i] != '\t')
&& (sent[i] != ' '); i++);
sent[i] = '\0';
if (id_cmp(sent + k, uttid) != 0)
E_ERROR
("Uttid mismatch: ctlfile = \"%s\"; transcript = \"%s\"\n",
uttid, sent + k);
}
}
/* Convert input file to cepstra if waveform input is selected */
if (cmd_ln_boolean_r(config, "-adcin")) {
int16 *adcdata;
int32 nsamps = 0;
mfcc_t **mfcc;
if ((adcdata = bio_read_wavfile(cmd_ln_str_r(config, "-cepdir"),
ur->uttfile,
cmd_ln_str_r(config, "-cepext"),
cmd_ln_int32_r(config, "-adchdr"),
strcmp(cmd_ln_str_r(config, "-input_endian"), "big"),
&nsamps)) == NULL) {
E_FATAL("Cannot read file %s\n", ur->uttfile);
}
fe_start_utt(fe);
if (fe_process_utt(fe, adcdata, nsamps, &mfcc, &nfr) < 0) {
E_FATAL("MFCC calculation failed\n", ur->uttfile);
}
ckd_free(adcdata);
if (nfr > S3_MAX_FRAMES) {
E_FATAL("Maximum number of frames (%d) exceeded\n", S3_MAX_FRAMES);
}
if ((nfr = feat_s2mfc2feat_live(kbcore_fcb(kbc),
mfcc,
&nfr,
TRUE, TRUE,
feat)) < 0) {
E_FATAL("Feature computation failed\n");
}
if (mfcc)
ckd_free_2d((void **)mfcc);
}
else {
nfr =
feat_s2mfc2feat(kbcore_fcb(kbc), ur->uttfile, cepdir, cepext, sf, ef, feat,
S3_MAX_FRAMES);
}
if (ur->regmatname) {
if (kbc->mgau)
adapt_set_mllr(adapt_am, kbc->mgau, ur->regmatname,
ur->cb2mllrname, kbc->mdef, kbc->config);
else if (kbc->ms_mgau)
model_set_mllr(kbc->ms_mgau, ur->regmatname, ur->cb2mllrname,
kbcore_fcb(kbc), kbc->mdef, kbc->config);
else
E_WARN("Can't use MLLR matrices with .s2semi. yet\n");
}
if (nfr <= 0) {
if (cepdir != NULL) {
E_ERROR
("Utt %s: Input file read (%s) with dir (%s) and extension (%s) failed \n",
uttid, ur->uttfile, cepdir, cepext);
}
else {
E_ERROR
("Utt %s: Input file read (%s) with extension (%s) failed \n",
uttid, ur->uttfile, cepext);
}
}
else {
E_INFO("%s: %d input frames\n", uttid, nfr);
align_utt(sent, nfr, ur->uttfile, uttid);
}
}
void
utt_decode(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
kb_t *kb;
kbcore_t *kbcore;
cmd_ln_t *config;
int32 num_decode_frame;
int32 total_frame;
stat_t *st;
srch_t *s;
num_decode_frame = 0;
E_INFO("Processing: %s\n", uttid);
kb = (kb_t *) data;
kbcore = kb->kbcore;
config = kbcore_config(kbcore);
kb_set_uttid(uttid, ur->uttfile, kb);
st = kb->stat;
/* Convert input file to cepstra if waveform input is selected */
if (cmd_ln_boolean_r(config, "-adcin")) {
int16 *adcdata;
int32 nsamps = 0;
if ((adcdata = bio_read_wavfile(cmd_ln_str_r(config, "-cepdir"),
ur->uttfile,
cmd_ln_str_r(config, "-cepext"),
cmd_ln_int32_r(config, "-adchdr"),
strcmp(cmd_ln_str_r(config, "-input_endian"), "big"),
&nsamps)) == NULL) {
E_FATAL("Cannot read file %s\n", ur->uttfile);
}
if (kb->mfcc) {
ckd_free_2d((void **)kb->mfcc);
}
fe_start_utt(kb->fe);
if (fe_process_utt(kb->fe, adcdata, nsamps, &kb->mfcc, &total_frame) < 0) {
E_FATAL("MFCC calculation failed\n", ur->uttfile);
}
ckd_free(adcdata);
if (total_frame > S3_MAX_FRAMES) {
E_FATAL("Maximum number of frames (%d) exceeded\n", S3_MAX_FRAMES);
}
if ((total_frame = feat_s2mfc2feat_live(kbcore_fcb(kbcore),
kb->mfcc,
&total_frame,
TRUE, TRUE,
kb->feat)) < 0) {
E_FATAL("Feature computation failed\n");
}
}
else {
/* Read mfc file and build feature vectors for entire utterance */
if ((total_frame = feat_s2mfc2feat(kbcore_fcb(kbcore), ur->uttfile,
cmd_ln_str_r(config, "-cepdir"),
cmd_ln_str_r(config, "-cepext"), sf, ef,
kb->feat, S3_MAX_FRAMES)) < 0) {
E_FATAL("Cannot read file %s. Forced exit\n", ur->uttfile);
}
}
/* Also need to make sure we don't set resource if it is the same. Well, this mechanism
could be provided inside the following function.
*/
s = kb->srch;
if (ur->lmname != NULL)
srch_set_lm(s, ur->lmname);
if (ur->regmatname != NULL)
kb_setmllr(ur->regmatname, ur->cb2mllrname, kb);
/* These are necessary! */
s->uttid = kb->uttid;
s->uttfile = kb->uttfile;
utt_begin(kb);
utt_decode_block(kb->feat, total_frame, &num_decode_frame, kb);
utt_end(kb);
st->tot_fr += st->nfr;
}
int32 live_utt_decode_block (int16 *samples, int32 nsamples,
int32 live_endutt, partialhyp_t **ohyp)
{
static int32 live_begin_new_utt = 1;
static int32 frmno;
static float32 ***live_feat = NULL;
int32 live_nfr, live_nfeatvec;
int32 nwds =0;
float32 **mfcbuf;
/* int i,j;*/
/* 2004/08/27 L Galescu <*****@*****.**> -- added raw audio file saving */
static char uttfn[1024];
static FILE *rawfp = NULL;
int16 block_peak_amplitude;
if(live_feat==NULL)
live_feat = feat_array_alloc (kbcore_fcb(kbcore), LIVEBUFBLOCKSIZE);
if (live_begin_new_utt){
fe_start_utt(fe);
utt_begin (kb);
frmno = 0;
kb->nfr = 0;
kb->utt_hmm_eval = 0;
kb->utt_sen_eval = 0;
kb->utt_gau_eval = 0;
live_begin_new_utt = 0;
sprintf(uttfn, "%s/%s.raw", cmd_ln_str("-outrawdir"), kb->uttid);
rawfp = fopen(uttfn, "wb");
}
/* 10.jan.01 RAH, fe_process_utt now requires ***mfcbuf and it allocates the memory internally) */
mfcbuf = NULL;
/* LG 20080613 */
block_peak_amplitude = get_peak_amplitude(samples, nsamples);
if (block_peak_amplitude > peak_amplitude)
peak_amplitude = block_peak_amplitude;
E_INFO("segment peak %d\n",peak_amplitude);
live_nfr = fe_process_utt(fe, samples, nsamples, &mfcbuf); /**/
if (rawfp != NULL) {
fwrite(samples, sizeof(int16), nsamples, rawfp);
if (live_endutt)
fclose(rawfp);
}
if (live_endutt) {
/* RAH, It seems that we shouldn't throw out this data */
fe_end_utt(fe,dummyframe); /* Flush out the fe */
}
#if 0
E_INFO("Number frame after fe_process_utt %d\n",live_nfr);
for(i=0;i<live_nfr;i++){
printf("%d ",i);
for(j=0;j<13;j++){
printf("%f ",mfcbuf[i][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
}
#endif
/* lgalescu 2004/08/22 -- i am under the impression that
* feat_s2mfc2feat_block() needs to be called at the end of utt
* even if no frames need processing
*/
/* lgalescu 2004/10/13 -- rescinded the above */
if(live_nfr>0){
/* Compute feature vectors */
live_nfeatvec = feat_s2mfc2feat_block(kbcore_fcb(kbcore), mfcbuf,
live_nfr, live_begin_new_utt,
live_endutt, live_feat);
#if 0
E_INFO ("live_nfeatvec: %ld\n",live_nfeatvec);
#endif
#if 0
E_INFO("Current frame number %d, Number of frames %d, Number frame after feat_s2mfcfeat_block %d\n",frmno,live_nfr,live_nfeatvec);
for(i=0;i<live_nfeatvec;i++){
printf("%d\n",i);
printf("Cep: ");
fflush(stdout);
for(j=0;j<13;j++){
printf("%f ",live_feat[i][0][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
printf("Del: ");
fflush(stdout);
for(j=13;j<26;j++){
printf("%f ",live_feat[i][0][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
printf("Acc: ");
fflush(stdout);
for(j=26;j<39;j++){
printf("%f ",live_feat[i][0][j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
}
#endif
/* decode the block */
utt_decode_block (live_feat, live_nfeatvec, &frmno, kb,
maxwpf, maxhistpf, maxhmmpf, ptranskip, hmmdumpfp);
/* lgalescu 2004/08/21
* moved the following block out of the previous if(){} because we need
* the output even when no feature computation has to be done.
*/
/* lgalescu 2004/10/13 -- rescinded */
/* Pull out partial hypothesis */
nwds = live_get_partialhyp(live_endutt);
*ohyp = parthyp;
parthyplen = nwds;
}
/* Clean up */
if (live_endutt) {
live_begin_new_utt = 1;
kb->tot_fr += kb->nfr;
utt_end(kb);
}
else {
live_begin_new_utt = 0;
}
/* I'm starting to think that fe_process_utt should not be allocating its
* memory, that or it should allocate some max and just keep on going,
* this idea of constantly allocating freeing memory seems dangerous to me.
*/
/* 20040318 ARCHAN : It sounds extremely dangerous to me and I will
* eliminate it sometime.
*/
/* lgalescu: i second that! the memory issue needs to be investigated: after a run on linux, i noticed some 1.6M of memory having "disappeared"! */
if(live_nfr>0){
ckd_free_2d((void **) mfcbuf); /* RAH, this must be freed since fe_process_utt allocates it */
}
return(parthyplen);
}
void
ld_process_raw_impl(live_decoder_t * _decoder,
int16 * samples, int32 num_samples, int32 end_utt)
{
float32 dummy_frame[MAX_CEP_LEN];
float32 **frames = 0;
int32 num_frames = 0;
int32 num_features = 0;
int32 begin_utt = _decoder->num_frames_entered == 0;
int32 return_value;
int i;
assert(_decoder != NULL);
if (begin_utt) {
fe_start_utt(_decoder->fe);
}
if (_decoder->swap) {
for (i = 0; i < num_samples; i++) {
SWAP_INT16(samples + i);
}
}
return_value =
fe_process_utt(_decoder->fe, samples, num_samples, &frames,
&num_frames);
if (end_utt) {
return_value = fe_end_utt(_decoder->fe, dummy_frame, &num_frames);
if (num_frames != 0) {
/* ARCHAN: If num_frames !=0, assign this last ending frame to
frames again. The computation will then be correct. Should
clean up the finite state logic in fe_interface layer.
*/
frames =
(float32 **) ckd_calloc_2d(1, _decoder->fe->NUM_CEPSTRA,
sizeof(float32));
memcpy(frames[0], dummy_frame,
_decoder->fe->NUM_CEPSTRA * sizeof(float32));
}
}
if (FE_ZERO_ENERGY_ERROR == return_value) {
E_WARN("Zero energy frame(s). Consider using dither\n");
}
if (num_frames > 0) {
num_features = feat_s2mfc2feat_block(kbcore_fcb(_decoder->kbcore),
frames,
num_frames,
begin_utt,
end_utt, _decoder->features);
_decoder->num_frames_entered += num_frames;
}
if (num_features > 0) {
utt_decode_block(_decoder->features,
num_features,
&_decoder->num_frames_decoded, &_decoder->kb);
}
if (frames != NULL) {
ckd_free_2d((void **) frames);
}
}
int main (int32 argc, char *argv[])
{
char line[4096], filename[4096], idspec[4096], *uttid, *result;
int32 sf, ef, sps, adcin, nf;
int16 adbuf[4096];
int32 i, k;
float32 **mfcbuf;
CDCN_type *cdcn;
param_t param;
fe_t *fe = NULL;
fbs_init (argc, argv);
/* Assume that cdcn_init is part of the above fbs_init() */
cdcn = uttproc_get_cdcn_ptr();
adcin = query_adc_input();
assert (adcin); /* Limited to processing audio input files (not cep) */
sps = query_sampling_rate();
fe_init_params(¶m);
param.SAMPLING_RATE = (float)sps;
if ((fe = fe_init (¶m)) == NULL)
{
E_ERROR("fe_init() failed to initialize\n");
exit (-1);
}
mfcbuf = (float32 **) ckd_calloc_2d (8192, 13, sizeof(float32));
/* Process "control file" input through stdin */
while (fgets (line, sizeof(line), stdin) != NULL) {
if (uttproc_parse_ctlfile_entry (line, filename, &sf, &ef, idspec) < 0)
continue;
assert ((sf < 0) && (ef < 0)); /* Processing entire input file */
uttid = build_uttid (idspec);
uttproc_begin_utt (uttid);
/* Convert raw data file to cepstra */
if (uttfile_open (filename) < 0) {
E_ERROR("uttfile_open(%s) failed\n", filename);
continue;
}
fe_start_utt(fe);
nf = 0;
while ((k = adc_file_read (adbuf, 4096)) >= 0) {
if (fe_process_utt (fe, adbuf, k, mfcbuf+nf, &k) == FE_ZERO_ENERGY_ERROR) {
E_WARN("Frames with zero energy. Consider using dither\n");
}
nf += k;
/* WARNING!! No check for mfcbuf overflow */
}
fe_end_utt(fe, mfcbuf[nf], &k);
fe_close(fe);
uttfile_close ();
if (nf <= 0) {
E_ERROR("Empty utterance\n");
continue;
} else
E_INFO("%d frames\n", nf);
/* Update CDCN module */
cdcn_converged_update (mfcbuf, /* cepstra buffer */
nf, /* Number of frames */
cdcn, /* The CDCN wrapper */
1 /* One iteration */
);
/* CDCN */
for (i = 0; i < nf; i++)
cdcn_norm (mfcbuf[i], cdcn);
/* Process normalized cepstra */
uttproc_cepdata (mfcbuf, nf, 1);
uttproc_end_utt ();
uttproc_result (&k, &result, 1);
printf ("\n");
fflush (stdout);
}
ckd_free_2d((void **)mfcbuf);
fbs_end ();
return 0;
}