public static int phone_loop_search_start(ps_search_t search) { phone_loop_search_t pls = (phone_loop_search_t)search; int i; /* Reset and enter all phone HMMs. */ for (i = 0; i < pls.n_phones; ++i) { Pointer <hmm_t> hmmModel = pls.hmms.Point(i); hmm.hmm_clear(hmmModel); hmm.hmm_enter(hmmModel, 0, -1, 0); } pls.penalties.MemSet(0, pls.n_phones); for (i = 0; i < pls.window; i++) { pls.pen_buf[i].MemSet(0, pls.n_phones); } phone_loop_search_free_renorm(pls); pls.best_score = 0; pls.pen_buf_ptr = 0; return(0); }
public static int kws_search_step(ps_search_t search, int frame_idx) { Pointer <short> senscr; kws_search_t kwss = (kws_search_t)search; Pointer <acmod_t> _acmod = search.acmod; /* Activate senones */ if (_acmod.Deref.compallsen == 0) { kws_search_sen_active(kwss); } /* Calculate senone scores for current frame. */ BoxedValueInt boxed_frame_idx = new BoxedValueInt(frame_idx); senscr = acmod.acmod_score(_acmod, boxed_frame_idx); frame_idx = boxed_frame_idx.Val; /* Evaluate hmms in phone loop and in active keyphrase nodes */ kws_search_hmm_eval(kwss, senscr); /* Prune hmms with low prob */ kws_search_hmm_prune(kwss); /* Do hmms transitions */ kws_search_trans(kwss); ++kwss.frame; return(0); }
public static void kws_search_free(ps_search_t search) { kws_search_t kwss; double n_speech; Pointer <gnode_t> gn; kwss = (kws_search_t)search; n_speech = (double)kwss.n_tot_frame / cmd_ln.cmd_ln_int_r(pocketsphinx.ps_search_config(kwss), cstring.ToCString("-frate")); // LOGAN reimplement this //err.E_INFO("TOTAL kws %.2f CPU %.3f xRT\n", // kwss.perf.t_tot_cpu, // kwss.perf.t_tot_cpu / n_speech); //err.E_INFO("TOTAL kws %.2f wall %.3f xRT\n", // kwss.perf.t_tot_elapsed, // kwss.perf.t_tot_elapsed / n_speech); pocketsphinx.ps_search_base_free(search); hmm.hmm_context_free(kwss.hmmctx); kws_detections.kws_detections_reset(kwss.detections); ckd_alloc.ckd_free(kwss.detections); ckd_alloc.ckd_free(kwss.pl_hmms); for (gn = kwss.keyphrases; gn.IsNonNull; gn = glist.gnode_next(gn)) { Pointer <kws_keyphrase_t> keyphrase = (Pointer <kws_keyphrase_t>)glist.gnode_ptr(gn); ckd_alloc.ckd_free(keyphrase.Deref.hmms); ckd_alloc.ckd_free(keyphrase.Deref.word); ckd_alloc.ckd_free(keyphrase); } glist.glist_free(kwss.keyphrases); }
public static Pointer <byte> kws_search_get_keyphrases(ps_search_t search) { int c, len; kws_search_t kwss; Pointer <byte> line; Pointer <gnode_t> gn; kwss = (kws_search_t)search; len = 0; for (gn = kwss.keyphrases; gn.IsNonNull; gn = glist.gnode_next(gn)) { len += (int)cstring.strlen(((Pointer <kws_keyphrase_t>)glist.gnode_ptr(gn)).Deref.word) + 1; } c = 0; line = ckd_alloc.ckd_calloc <byte>(len); for (gn = kwss.keyphrases; gn.IsNonNull; gn = glist.gnode_next(gn)) { Pointer <byte> str = ((Pointer <kws_keyphrase_t>)glist.gnode_ptr(gn)).Deref.word; str.MemCopyTo(line.Point(c), (int)cstring.strlen(str)); c += (int)cstring.strlen(str); line[c++] = (byte)'\n'; } line[--c] = (byte)'\0'; return(line); }
public static int kws_search_finish(ps_search_t search) { kws_search_t kwss; int cf; kwss = (kws_search_t)search; kwss.n_tot_frame += kwss.frame; /* Print out some statistics. */ profile.ptmr_stop(kwss.perf); /* This is the number of frames processed. */ cf = pocketsphinx.ps_search_acmod(kwss).Deref.output_frame; if (cf > 0) { double n_speech = (double)(cf + 1) / cmd_ln.cmd_ln_int_r(pocketsphinx.ps_search_config(kwss), cstring.ToCString("-frate")); // LOGAN reimplement this //err.E_INFO("kws %.2f CPU %.3f xRT\n", // kwss.perf.t_cpu, kwss.perf.t_cpu / n_speech); //err.E_INFO("kws %.2f wall %.3f xRT\n", // kwss.perf.t_elapsed, kwss.perf.t_elapsed / n_speech); } return(0); }
public static void ps_search_base_reinit(ps_search_t search, Pointer <dict_t> dictionary, Pointer <dict2pid_t> d2p) { dict.dict_free(search.dict); dict2pid.dict2pid_free(search.d2p); /* FIXME: _retain() should just return NULL if passed NULL. */ if (dictionary.IsNonNull) { search.dict = dict.dict_retain(dictionary); search.start_wid = dict.dict_startwid(dictionary); search.finish_wid = dict.dict_finishwid(dictionary); search.silence_wid = dict.dict_silwid(dictionary); search.n_words = dict.dict_size(dictionary); } else { search.dict = PointerHelpers.NULL <dict_t>(); search.start_wid = search.finish_wid = search.silence_wid = -1; search.n_words = 0; } if (d2p.IsNonNull) { search.d2p = dict2pid.dict2pid_retain(d2p); } else { search.d2p = PointerHelpers.NULL <dict2pid_t>(); } }
public static ps_seg_t kws_search_seg_iter(ps_search_t search) { kws_search_t kwss = (kws_search_t)search; kws_seg_t itor; Pointer <gnode_t> detect_head = kwss.detections.Deref.detect_list; while (detect_head.IsNonNull && ((Pointer <kws_detection_t>)glist.gnode_ptr(detect_head)).Deref.ef > kwss.frame - kwss.delay) { detect_head = glist.gnode_next(detect_head); } if (detect_head.IsNull) { return(null); } itor = new kws_seg_t(); itor.vt = kws_segfuncs; itor.search = search; itor.lwf = 1.0f; itor.detection = detect_head; itor.last_frame = kwss.frame - kwss.delay; kws_seg_fill(itor); return((ps_seg_t)itor); }
public static void ps_search_base_free(ps_search_t search) { /* FIXME: We will have refcounting on acmod, config, etc, at which * point we will free them here too. */ ckd_alloc.ckd_free(search.name); ckd_alloc.ckd_free(search.type); dict.dict_free(search.dict); dict2pid.dict2pid_free(search.d2p); ckd_alloc.ckd_free(search.hyp_str); ps_lattice.ps_lattice_free(search.dag); }
public static void phone_loop_search_free(ps_search_t search) { phone_loop_search_t pls = (phone_loop_search_t)search; int i; pocketsphinx.ps_search_base_free(search); for (i = 0; i < pls.n_phones; ++i) { hmm.hmm_deinit(pls.hmms.Point(i)); } phone_loop_search_free_renorm(pls); ckd_alloc.ckd_free_2d(pls.pen_buf); ckd_alloc.ckd_free(pls.hmms); ckd_alloc.ckd_free(pls.penalties); hmm.hmm_context_free(pls.hmmctx); }
public static Pointer <byte> kws_search_hyp(ps_search_t search, BoxedValueInt out_score) { kws_search_t kwss = (kws_search_t)search; if (out_score != null) { out_score.Val = 0; } if (search.hyp_str.IsNonNull) { ckd_alloc.ckd_free(search.hyp_str); } search.hyp_str = kws_detections.kws_detections_hyp_str(kwss.detections, kwss.frame, kwss.delay); return(search.hyp_str); }
public static int phone_loop_search_step(ps_search_t search, int frame_idx) { phone_loop_search_t pls = (phone_loop_search_t)search; Pointer <acmod_t> acModel = pocketsphinx.ps_search_acmod(search); Pointer <short> senscr; int i; /* All CI senones are active all the time. */ if (pocketsphinx.ps_search_acmod(pls).Deref.compallsen == 0) { acmod.acmod_clear_active(pocketsphinx.ps_search_acmod(pls)); for (i = 0; i < pls.n_phones; ++i) { acmod.acmod_activate_hmm(acModel, pls.hmms.Point(i)); } } /* Calculate senone scores for current frame. */ BoxedValueInt boxed_frame_idx = new BoxedValueInt(frame_idx); senscr = acmod.acmod_score(acModel, boxed_frame_idx); frame_idx = boxed_frame_idx.Val; /* Renormalize, if necessary. */ if (pls.best_score + (2 * pls.beam) < hmm.WORST_SCORE) { err.E_INFO(string.Format("Renormalizing Scores at frame {0}, best score {1}\n", frame_idx, pls.best_score)); renormalize_hmms(pls, frame_idx, pls.best_score); } /* Evaluate phone HMMs for current frame. */ evaluate_hmms(pls, senscr, frame_idx); /* Store hmm scores for senone penaly calculation */ store_scores(pls, frame_idx); /* Prune phone HMMs. */ prune_hmms(pls, frame_idx); /* Do phone transitions. */ phone_transition(pls, frame_idx); return(0); }
public static int set_search_internal(Pointer <ps_decoder_t> ps, ps_search_t search) { ps_search_t old_search; if (search == null) { return(-1); } search.pls = ps.Deref.phone_loop; old_search = (ps_search_t)hash_table.hash_table_replace(ps.Deref.searches, ps_search_name(search), search); if (old_search != search) { ps_search_free(old_search); } return(0); }
public static int kws_search_start(ps_search_t search) { int i; kws_search_t kwss = (kws_search_t)search; kwss.frame = 0; kwss.bestscore = 0; kws_detections.kws_detections_reset(kwss.detections); /* Reset and enter all phone-loop HMMs. */ for (i = 0; i < kwss.n_pl; ++i) { Pointer <hmm_t> _hmm = (Pointer <hmm_t>)kwss.pl_hmms.Point(i); hmm.hmm_clear(_hmm); hmm.hmm_enter(_hmm, 0, -1, 0); } profile.ptmr_reset(kwss.perf); profile.ptmr_start(kwss.perf); return(0); }
public static void ps_search_init( ps_search_t search, ps_searchfuncs_t vt, Pointer <byte> type, Pointer <byte> name, Pointer <cmd_ln_t> config, Pointer <acmod_t> acousticmod, Pointer <dict_t> dictionary, Pointer <dict2pid_t> d2p) { search.vt = vt; search.name = ckd_alloc.ckd_salloc(name); search.type = ckd_alloc.ckd_salloc(type); search.config = config; search.acmod = acousticmod; if (d2p.IsNonNull) { search.d2p = dict2pid.dict2pid_retain(d2p); } else { search.d2p = PointerHelpers.NULL <dict2pid_t>(); } if (dictionary.IsNonNull) { search.dict = dict.dict_retain(dictionary); search.start_wid = dict.dict_startwid(dictionary); search.finish_wid = dict.dict_finishwid(dictionary); search.silence_wid = dict.dict_silwid(dictionary); search.n_words = dict.dict_size(dictionary); } else { search.dict = PointerHelpers.NULL <dict_t>(); search.start_wid = search.finish_wid = search.silence_wid = -1; search.n_words = 0; } }
public static void ps_search_free(ps_search_t s) { s.vt.free(s); }
public static int kws_search_reinit(ps_search_t search, Pointer <dict_t> dictionary, Pointer <dict2pid_t> d2p) { Pointer <Pointer <byte> > wrdptr; Pointer <byte> tmp_keyphrase; int wid, pronlen, in_dict; int n_hmms, n_wrds; int ssid, tmatid; int i, j, p; kws_search_t kwss = (kws_search_t)search; Pointer <bin_mdef_t> mdef = search.acmod.Deref.mdef; int silcipid = bin_mdef.bin_mdef_silphone(mdef); Pointer <gnode_t> gn; /* Free old dict2pid, dict */ pocketsphinx.ps_search_base_reinit(search, dictionary, d2p); /* Initialize HMM context. */ if (kwss.hmmctx.IsNonNull) { hmm.hmm_context_free(kwss.hmmctx); } kwss.hmmctx = hmm.hmm_context_init(bin_mdef.bin_mdef_n_emit_state(search.acmod.Deref.mdef), search.acmod.Deref.tmat.Deref.tp, PointerHelpers.NULL <short>(), search.acmod.Deref.mdef.Deref.sseq); if (kwss.hmmctx.IsNull) { return(-1); } /* Initialize phone loop HMMs. */ if (kwss.pl_hmms.IsNonNull) { for (i = 0; i < kwss.n_pl; ++i) { hmm.hmm_deinit((Pointer <hmm_t>)kwss.pl_hmms.Point(i)); } ckd_alloc.ckd_free(kwss.pl_hmms); } kwss.n_pl = bin_mdef.bin_mdef_n_ciphone(search.acmod.Deref.mdef); kwss.pl_hmms = ckd_alloc.ckd_calloc_struct <hmm_t>(kwss.n_pl); for (i = 0; i < kwss.n_pl; ++i) { hmm.hmm_init(kwss.hmmctx, kwss.pl_hmms.Point(i), 0, bin_mdef.bin_mdef_pid2ssid(search.acmod.Deref.mdef, i), bin_mdef.bin_mdef_pid2tmatid(search.acmod.Deref.mdef, i)); } for (gn = kwss.keyphrases; gn.IsNonNull; gn = glist.gnode_next(gn)) { Pointer <kws_keyphrase_t> keyphrase = (Pointer <kws_keyphrase_t>)glist.gnode_ptr(gn); /* Initialize keyphrase HMMs */ tmp_keyphrase = ckd_alloc.ckd_salloc(keyphrase.Deref.word); n_wrds = strfuncs.str2words(tmp_keyphrase, PointerHelpers.NULL <Pointer <byte> >(), 0); wrdptr = ckd_alloc.ckd_calloc <Pointer <byte> >(n_wrds); strfuncs.str2words(tmp_keyphrase, wrdptr, n_wrds); /* count amount of hmms */ n_hmms = 0; in_dict = 1; for (i = 0; i < n_wrds; i++) { wid = dict.dict_wordid(dictionary, wrdptr[i]); if (wid == s3types.BAD_S3WID) { err.E_ERROR(string.Format("Word '{0}' in phrase '{1}' is missing in the dictionary\n", cstring.FromCString(wrdptr[i]), cstring.FromCString(keyphrase.Deref.word))); in_dict = 0; break; } pronlen = dict.dict_pronlen(dictionary, wid); n_hmms += pronlen; } if (in_dict == 0) { ckd_alloc.ckd_free(wrdptr); ckd_alloc.ckd_free(tmp_keyphrase); continue; } /* allocate node array */ if (keyphrase.Deref.hmms.IsNonNull) { ckd_alloc.ckd_free(keyphrase.Deref.hmms); } keyphrase.Deref.hmms = ckd_alloc.ckd_calloc_struct <hmm_t>(n_hmms); keyphrase.Deref.n_hmms = n_hmms; /* fill node array */ j = 0; for (i = 0; i < n_wrds; i++) { wid = dict.dict_wordid(dictionary, wrdptr[i]); pronlen = dict.dict_pronlen(dictionary, wid); for (p = 0; p < pronlen; p++) { int ci = dict.dict_pron(dictionary, wid, p); if (p == 0) { /* first phone of word */ int rc = pronlen > 1 ? dict.dict_pron(dictionary, wid, 1) : silcipid; ssid = d2p.Deref.ldiph_lc[ci][rc][silcipid]; } else if (p == pronlen - 1) { /* last phone of the word */ int lc = dict.dict_pron(dictionary, wid, p - 1); Pointer <xwdssid_t> rssid = d2p.Deref.rssid[ci].Point(lc); int jjj = rssid.Deref.cimap[silcipid]; ssid = rssid.Deref.ssid[jjj]; // LOGAN WTF? Why does C allow you to declare the same variable twice in nested scopes? TODO file a bug on sphinx } else { /* word internal phone */ ssid = dict2pid.dict2pid_internal(d2p, wid, p); } tmatid = bin_mdef.bin_mdef_pid2tmatid(mdef, ci); hmm.hmm_init(kwss.hmmctx, keyphrase.Deref.hmms.Point(j), 0, ssid, tmatid); j++; } } ckd_alloc.ckd_free(wrdptr); ckd_alloc.ckd_free(tmp_keyphrase); } return(0); }
public static Pointer <ps_lattice_t> ps_search_lattice(ps_search_t s) { return(s.vt.lattice(s)); }
public static int kws_search_prob(ps_search_t search) { return(0); }
public static int ps_search_prob(ps_search_t s) { return(s.vt.prob(s)); }
public static int ps_search_step(ps_search_t s, int i) { return(s.vt.step(s, i)); }
public static int phone_loop_search_prob(ps_search_t search) { /* FIXME: Actually... they ought to be. */ err.E_WARN("Posterior probabilities are not returned from phone loop search"); return(0); }
public static Pointer <byte> phone_loop_search_hyp(ps_search_t search, BoxedValueInt out_score) { err.E_WARN("Hypotheses are not returned from phone loop search"); return(PointerHelpers.NULL <byte>()); }
public static int phone_loop_search_finish(ps_search_t search) { /* Actually nothing to do here really. */ return(0); }
public static int phone_loop_search_reinit(ps_search_t search, Pointer <dict_t> dict, Pointer <dict2pid_t> d2p) { phone_loop_search_t pls = (phone_loop_search_t)search; Pointer <cmd_ln_t> config = pocketsphinx.ps_search_config(search); Pointer <acmod_t> acmod = pocketsphinx.ps_search_acmod(search); int i; /* Free old dict2pid, dict, if necessary. */ pocketsphinx.ps_search_base_reinit(search, dict, d2p); /* Initialize HMM context. */ if (pls.hmmctx.IsNonNull) { hmm.hmm_context_free(pls.hmmctx); } pls.hmmctx = hmm.hmm_context_init(bin_mdef.bin_mdef_n_emit_state(acmod.Deref.mdef), acmod.Deref.tmat.Deref.tp, PointerHelpers.NULL <short>(), acmod.Deref.mdef.Deref.sseq); if (pls.hmmctx.IsNull) { return(-1); } /* Initialize penalty storage */ pls.n_phones = checked ((short)bin_mdef.bin_mdef_n_ciphone(acmod.Deref.mdef)); pls.window = (int)cmd_ln.cmd_ln_int_r(config, cstring.ToCString("-pl_window")); if (pls.penalties.IsNonNull) { ckd_alloc.ckd_free(pls.penalties); } pls.penalties = ckd_alloc.ckd_calloc <int>(pls.n_phones); if (pls.pen_buf.IsNonNull) { ckd_alloc.ckd_free_2d(pls.pen_buf); } pls.pen_buf = ckd_alloc.ckd_calloc_2d <int>((uint)pls.window, (uint)pls.n_phones); /* Initialize phone HMMs. */ if (pls.hmms.IsNonNull) { for (i = 0; i < pls.n_phones; ++i) { hmm.hmm_deinit(pls.hmms.Point(i)); } ckd_alloc.ckd_free(pls.hmms); } pls.hmms = ckd_alloc.ckd_calloc_struct <hmm_t>(pls.n_phones); for (i = 0; i < pls.n_phones; ++i) { hmm.hmm_init(pls.hmmctx, pls.hmms.Point(i), 0, bin_mdef.bin_mdef_pid2ssid(acmod.Deref.mdef, i), bin_mdef.bin_mdef_pid2tmatid(acmod.Deref.mdef, i)); } pls.penalty_weight = cmd_ln.cmd_ln_float_r(config, cstring.ToCString("-pl_weight")); pls.beam = logmath.logmath_log(acmod.Deref.lmath, cmd_ln.cmd_ln_float_r(config, cstring.ToCString("-pl_beam"))) >> hmm.SENSCR_SHIFT; pls.pbeam = logmath.logmath_log(acmod.Deref.lmath, cmd_ln.cmd_ln_float_r(config, cstring.ToCString("-pl_pbeam"))) >> hmm.SENSCR_SHIFT; pls.pip = logmath.logmath_log(acmod.Deref.lmath, cmd_ln.cmd_ln_float_r(config, cstring.ToCString("-pl_pip"))) >> hmm.SENSCR_SHIFT; err.E_INFO(string.Format("State beam {0} Phone exit beam {1} Insertion penalty {2}\n", pls.beam, pls.pbeam, pls.pip)); return(0); }
public static Pointer <byte> ps_search_hyp(ps_search_t s, BoxedValueInt out_score) { return(s.vt.hyp(s, out_score)); }
public static int ps_search_reinit(ps_search_t s, Pointer <dict_t> dict, Pointer <dict2pid_t> d2p) { return(s.vt.reinit(s, dict, d2p)); }
public static int ps_search_finish(ps_search_t s) { return(s.vt.finish(s)); }
public static ps_seg_t phone_loop_search_seg_iter(ps_search_t search) { err.E_WARN("Hypotheses are not returned from phone loop search"); return(null); }
public static Pointer <ps_lattice_t> kws_search_lattice(ps_search_t search) { return(PointerHelpers.NULL <ps_lattice_t>()); }
public static ps_seg_t ps_search_seg_iter(ps_search_t s) { return(s.vt.seg_iter(s)); }