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