void
ld_finish(live_decoder_t * _decoder)
{
assert(_decoder != NULL);
if (_decoder->fe != NULL) {
fe_close(_decoder->fe);
}
if (_decoder->features != NULL) {
/* consult the implementation of feat_array_alloc() for how to free our
* internal feature vector buffer */
ckd_free((void *) **_decoder->features);
ckd_free_2d((void **) _decoder->features);
}
if (_decoder->internal_cmdln == TRUE) {
cmd_ln_free();
}
kb_free(&_decoder->kb);
ld_free_hyps(_decoder);
if (_decoder->uttid != NULL) {
ckd_free(_decoder->uttid);
_decoder->uttid = NULL;
}
_decoder->ld_state = LD_STATE_FINISHED;
}
/* RAH Apr.13.2001: Memory was being held, Added Call fe_close to release
* memory held by fe and then release locally allocated memory
*/
int32 live_free_memory ()
{
parse_args_free(); /* Free memory allocated during the argument parseing stage */
fe_close (fe); /* */
ckd_free(kb->uttid); /* Free memory allocated in live_initialize_decoder() */
kb_free (kb); /* */
ckd_free ((void *) dummyframe); /* */
ckd_free ((void *) parthyp); /* */
return (0);
}
/* RAH Apr.13.2001: Memory was being held, Added Call fe_close to release memory held by fe and then release locally allocated memory */
int32 live_free_memory ()
{
parse_args_free(); /* Free memory allocated during the argument parseing stage */
fe_close (fe); /* */
ckd_free(kb->uttid); /* Free memory allocated in live_initialize_decoder() */
kb_free (kb); /* */
ckd_free ((void *) dummyframe); /* */
ckd_free ((void *) parthyp); /* */
#if defined(THRD)
thread_barrier_destroy(score_barrier);
#endif
return (0);
}
static const value_t *
fn_kind(const value_t *this_fn, parser_state_t *state)
{
const value_t *resval = NULL;
value_t *strval = (value_t *)parser_builtin_arg(state, 1);
const char *filename;
size_t filenamelen;
if (value_string_get(strval, &filename, &filenamelen))
{
int fd = fe_open(filename, "rb", 0);
if (fd < 0)
parser_report(state, "couldn't open ELF file to read - %s\n",filename);
else {
Elf *e = elf_begin(fd, ELF_C_READ, NULL);
if (e == NULL)
parser_report(state, "couldn't initialize ELF library - %s\n",
elf_errmsg(-1));
else {
Elf_Kind ek = elf_kind(e);
switch (ek) {
case ELF_K_AR:
resval = value_string_new_measured("archive");
break;
case ELF_K_ELF:
resval = value_string_new_measured("elf");
break;
case ELF_K_NONE:
resval = value_string_new_measured("data");
break;
default:
resval = &value_null;
}
(void)elf_end(e);
}
(void)fe_close(fd);
}
} else
parser_report_help(state, this_fn);
return resval;
}
static const value_t *
genfn_with_elfhdr(const value_t *this_fn, parser_state_t *state, int file_arg,
elf_hdr_fn_t *elf_fn, void *fn_arg)
{
const value_t *retval = NULL;
value_t *strval = (value_t *)parser_builtin_arg(state, file_arg);
const char *filename;
size_t filenamelen;
if (value_string_get(strval, &filename, &filenamelen))
{
int fd = fe_open(filename, "rb", 0);
if (fd < 0)
parser_report(state, "couldn't open ELF file to read - %s\n",filename);
else {
Elf *e = elf_begin(fd, ELF_C_READ, NULL);
if (e == NULL)
parser_report(state, "couldn't initialize ELF library - %s\n",
elf_errmsg(-1));
else {
Elf_Kind ek = elf_kind(e);
if (ek != ELF_K_ELF)
parser_report(state, "not an ELF file - %s\n", elf_errmsg(-1));
else {
GElf_Ehdr ehdr;
if (gelf_getehdr(e, &ehdr) == NULL)
parser_report(state, "no execution header in ELF file - %s\n",
elf_errmsg(-1));
else {
retval = (*elf_fn)(this_fn, state, filename, fd,
e, &ehdr, fn_arg);
}
}
(void)elf_end(e);
}
(void)fe_close(fd);
}
} else
parser_report_help(state, this_fn);
return retval;
}
static int
ld_init_impl(live_decoder_t * _decoder, int32 _internal_cmdln)
{
param_t fe_param;
int rv = LD_SUCCESS;
assert(_decoder != NULL);
unlimit();
/* ARCHAN 20050708: This part should be factored with fe_parse_option */
/* allocate and initialize front-end */
fe_init_params(&fe_param);
fe_param.SAMPLING_RATE = cmd_ln_float32("-samprate");
fe_param.FRAME_RATE = cmd_ln_int32("-frate");
fe_param.WINDOW_LENGTH = cmd_ln_float32("-wlen");
fe_param.FB_TYPE = strcmp("mel_scale", cmd_ln_str("-fbtype")) == 0 ?
MEL_SCALE : LOG_LINEAR;
fe_param.NUM_CEPSTRA = cmd_ln_int32("-ncep");
fe_param.NUM_FILTERS = cmd_ln_int32("-nfilt");
fe_param.FFT_SIZE = cmd_ln_int32("-nfft");
fe_param.LOWER_FILT_FREQ = cmd_ln_float32("-lowerf");
fe_param.UPPER_FILT_FREQ = cmd_ln_float32("-upperf");
fe_param.PRE_EMPHASIS_ALPHA = cmd_ln_float32("-alpha");
fe_param.dither = strcmp("no", cmd_ln_str("-dither"));
fe_param.warp_type = cmd_ln_str("-warp_type");
fe_param.warp_params = cmd_ln_str("-warp_params");
if ((_decoder->fe = fe_init(&fe_param)) == NULL) {
E_WARN("Failed to initialize front-end.\n");
rv = LD_ERROR_OUT_OF_MEMORY;
goto ld_init_impl_cleanup;
}
/* capture decoder parameters */
kb_init(&_decoder->kb);
/* initialize decoder variables */
_decoder->kbcore = _decoder->kb.kbcore;
_decoder->hyp_frame_num = -1;
_decoder->uttid = NULL;
_decoder->ld_state = LD_STATE_IDLE;
_decoder->hyp_str = NULL;
_decoder->hyp_segs = NULL;
/*
_decoder->swap= (cmd_ln_int32("-machine_endian") != cmd_ln_int32("-input_endian"));
*/
_decoder->swap =
(strcmp(cmd_ln_str("-machine_endian"), cmd_ln_str("-input_endian"))
!= 0);
_decoder->phypdump = (cmd_ln_int32("-phypdump"));
_decoder->rawext = (cmd_ln_str("-rawext"));
if (_decoder->phypdump)
E_INFO("Partial hypothesis WILL be dumped\n");
else
E_INFO("Partial hypothesis will NOT be dumped\n");
if (_decoder->swap)
E_INFO("Input data WILL be byte swapped\n");
else
E_INFO("Input data will NOT be byte swapped\n");
_decoder->internal_cmdln = _internal_cmdln;
_decoder->features =
feat_array_alloc(kbcore_fcb(_decoder->kbcore), LIVEBUFBLOCKSIZE);
if (_decoder->features == NULL) {
E_WARN("Failed to allocate internal feature buffer.\n");
rv = LD_ERROR_OUT_OF_MEMORY;
goto ld_init_impl_cleanup;
}
return LD_SUCCESS;
ld_init_impl_cleanup:
if (_decoder->fe != NULL) {
fe_close(_decoder->fe);
}
if (_decoder->features != NULL) {
/* consult the implementation of feat_array_alloc() for how to free our
* internal feature vector buffer */
ckd_free((void *) **_decoder->features);
ckd_free_2d((void **) _decoder->features);
}
if (_internal_cmdln == TRUE) {
cmd_ln_free();
}
_decoder->ld_state = LD_STATE_FINISHED;
return rv;
}
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;
}
