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; }