Add m-esr52 at 52.6.0

1 files changed, 913 insertions, 0 deletions

diff --git a/media/pocketsphinx/src/allphone_search.c b/media/pocketsphinx/src/allphone_search.c
new file mode 100644
index 000000000..974cdba4f
--- /dev/null
+++ b/media/pocketsphinx/src/allphone_search.c
@@ -0,0 +1,913 @@
+/* ====================================================================
+ * Copyright (c) 2014 Carnegie Mellon University.  All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *
+ * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND 
+ * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
+ * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ====================================================================
+ *
+ */
+
+/*
+* allphone_search.c -- Search for phonetic decoding.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include <sphinxbase/err.h>
+#include <sphinxbase/ckd_alloc.h>
+#include <sphinxbase/strfuncs.h>
+#include <sphinxbase/pio.h>
+#include <sphinxbase/cmd_ln.h>
+
+#include "pocketsphinx_internal.h"
+#include "allphone_search.h"
+
+static ps_lattice_t *
+allphone_search_lattice(ps_search_t * search)
+{
+    //cap
+    return NULL;
+}
+
+static int
+allphone_search_prob(ps_search_t * search)
+{
+    return 0;
+}
+
+static void
+allphone_backtrace(allphone_search_t * allphs, int32 f);
+
+static void
+allphone_search_seg_free(ps_seg_t * seg)
+{
+    ckd_free(seg);
+}
+
+static void
+allphone_search_fill_iter(ps_seg_t *seg, phseg_t *phseg)
+{
+    seg->sf = phseg->sf;
+    seg->ef = phseg->ef;
+    seg->ascr = phseg->score;
+    seg->lscr = phseg->tscore;
+    seg->word = bin_mdef_ciphone_str(ps_search_acmod(seg->search)->mdef, phseg->ci);
+}
+
+static ps_seg_t *
+allphone_search_seg_next(ps_seg_t * seg)
+{
+    phseg_iter_t *itor = (phseg_iter_t *) seg;
+    phseg_t *phseg;
+
+    itor->seg = itor->seg->next;
+    
+    if (itor->seg == NULL) {
+	allphone_search_seg_free(seg);
+        return NULL;
+    }
+    phseg = gnode_ptr(itor->seg);
+    allphone_search_fill_iter(seg, phseg);
+
+    return seg;
+}
+
+static ps_segfuncs_t fsg_segfuncs = {
+    /* seg_next */ allphone_search_seg_next,
+    /* seg_free */ allphone_search_seg_free
+};
+
+
+static ps_seg_t *
+allphone_search_seg_iter(ps_search_t * search, int32 * out_score)
+{
+    allphone_search_t *allphs = (allphone_search_t *) search;
+    phseg_iter_t *iter;
+
+    allphone_backtrace(allphs, allphs->frame - 1);
+    if (allphs->segments == NULL)
+        return NULL;
+    
+    iter = ckd_calloc(1, sizeof(phseg_iter_t));
+
+    iter->base.vt = &fsg_segfuncs;
+    iter->base.search = search;
+    iter->seg = allphs->segments;
+    allphone_search_fill_iter((ps_seg_t *)iter, gnode_ptr(iter->seg));
+
+    return (ps_seg_t *) iter;
+}
+
+static ps_searchfuncs_t allphone_funcs = {
+    /* name: */ "allphone",
+    /* start: */ allphone_search_start,
+    /* step: */ allphone_search_step,
+    /* finish: */ allphone_search_finish,
+    /* reinit: */ allphone_search_reinit,
+    /* free: */ allphone_search_free,
+    /* lattice: */ allphone_search_lattice,
+    /* hyp: */ allphone_search_hyp,
+    /* prob: */ allphone_search_prob,
+    /* seg_iter: */ allphone_search_seg_iter,
+};
+
+/**
+ * Find PHMM node with same senone sequence and tmat id as the given triphone.
+ * Return ptr to PHMM node if found, NULL otherwise.
+ */
+static phmm_t *
+phmm_lookup(allphone_search_t * allphs, s3pid_t pid)
+{
+    phmm_t *p;
+    bin_mdef_t *mdef;
+    phmm_t **ci_phmm;
+
+    mdef = ((ps_search_t *) allphs)->acmod->mdef;
+    ci_phmm = allphs->ci_phmm;
+
+    for (p = ci_phmm[bin_mdef_pid2ci(mdef, pid)]; p; p = p->next) {
+        if (mdef_pid2tmatid(mdef, p->pid) == mdef_pid2tmatid(mdef, pid))
+            if (mdef_pid2ssid(mdef, p->pid) == mdef_pid2ssid(mdef, pid))
+                return p;
+    }
+
+    //not found
+    return NULL;
+}
+
+static int32
+phmm_link(allphone_search_t * allphs)
+{
+    s3cipid_t ci, rc;
+    phmm_t *p, *p2;
+    int32 *rclist;
+    int32 i, n_link;
+    plink_t *l;
+    bin_mdef_t *mdef;
+    phmm_t **ci_phmm;
+
+    mdef = ((ps_search_t *) allphs)->acmod->mdef;
+    ci_phmm = allphs->ci_phmm;
+
+    rclist = (int32 *) ckd_calloc(mdef->n_ciphone + 1, sizeof(int32));
+
+    /* Create successor links between PHMM nodes */
+    n_link = 0;    
+    for (ci = 0; ci < mdef->n_ciphone; ci++) {
+        for (p = ci_phmm[ci]; p; p = p->next) {
+            /* Build rclist for p */
+            i = 0;
+            for (rc = 0; rc < mdef->n_ciphone; rc++) {
+                if (bitvec_is_set(p->rc, rc))
+                    rclist[i++] = rc;
+            }
+            rclist[i] = BAD_S3CIPID;
+
+            /* For each rc in rclist, transition to PHMMs for rc if left context = ci */
+            for (i = 0; IS_S3CIPID(rclist[i]); i++) {
+                for (p2 = ci_phmm[rclist[i]]; p2; p2 = p2->next) {
+                    if (bitvec_is_set(p2->lc, ci)) {
+                        /* transition from p to p2 */
+                        l = (plink_t *) ckd_calloc(1, sizeof(*l));
+                        l->phmm = p2;
+                        l->next = p->succlist;
+                        p->succlist = l;
+
+                        n_link++;
+                    }
+                }
+            }
+        }
+    }
+
+    ckd_free(rclist);
+
+    return n_link;
+}
+
+/**
+ * Build net from phone HMMs
+ */
+static int
+phmm_build(allphone_search_t * allphs)
+{
+    phmm_t *p, **pid2phmm;
+    bin_mdef_t *mdef;
+    int32 lrc_size;
+    uint32 *lc, *rc;
+    s3pid_t pid;
+    s3cipid_t ci;
+    s3cipid_t *filler;
+    int n_phmm, n_link;
+    int i, nphone;
+
+    mdef = ((ps_search_t *) allphs)->acmod->mdef;
+    allphs->ci_phmm =
+        (phmm_t **) ckd_calloc(bin_mdef_n_ciphone(mdef), sizeof(phmm_t *));
+    pid2phmm =
+        (phmm_t **) ckd_calloc(bin_mdef_n_phone(mdef), sizeof(phmm_t *));
+
+    /* For each unique ciphone/triphone entry in mdef, create a PHMM node */
+    n_phmm = 0;
+    nphone = allphs->ci_only ? bin_mdef_n_ciphone(mdef) : bin_mdef_n_phone(mdef);
+    E_INFO("Building PHMM net of %d phones\n", nphone);
+    for (pid = 0; pid < nphone; pid++) {
+        if ((p = phmm_lookup(allphs, pid)) == NULL) {
+            //not found, should be created
+            p = (phmm_t *) ckd_calloc(1, sizeof(*p));
+            hmm_init(allphs->hmmctx, &(p->hmm), FALSE,
+                     mdef_pid2ssid(mdef, pid), mdef->phone[pid].tmat);
+            p->pid = pid;
+            p->ci = bin_mdef_pid2ci(mdef, pid);
+            p->succlist = NULL;
+            p->next = allphs->ci_phmm[p->ci];
+            allphs->ci_phmm[p->ci] = p;
+            n_phmm++;
+        }
+        pid2phmm[pid] = p;
+    }
+
+    /* Fill out bitvecs of each PHMM node, alloc continuous memory chunk for context bitvectors */
+    lrc_size = bitvec_size(bin_mdef_n_ciphone(mdef));
+    lc = ckd_calloc(n_phmm * 2 * lrc_size, sizeof(bitvec_t));
+    rc = lc + (n_phmm * lrc_size);
+    for (ci = 0; ci < mdef->n_ciphone; ci++) {
+        for (p = allphs->ci_phmm[ci]; p; p = p->next) {
+            p->lc = lc;
+            lc += lrc_size;
+            p->rc = rc;
+            rc += lrc_size;
+        }
+    }
+
+    /* Fill out lc and rc bitmaps (remember to map all fillers to each other!!) */
+    filler =
+        (s3cipid_t *) ckd_calloc(bin_mdef_n_ciphone(mdef) + 1,
+                                 sizeof(s3cipid_t));
+
+    /* Connect fillers */
+    i = 0;
+    for (ci = 0; ci < bin_mdef_n_ciphone(mdef); ci++) {
+        p = pid2phmm[ci];
+        bitvec_set_all(p->lc, bin_mdef_n_ciphone(mdef));
+        bitvec_set_all(p->rc, bin_mdef_n_ciphone(mdef));
+        if (mdef->phone[ci].info.ci.filler) {
+            filler[i++] = ci;
+        }
+    }
+    filler[i] = BAD_S3CIPID;
+
+
+    /* Loop over cdphones only if ci_only is not set */
+    for (pid = bin_mdef_n_ciphone(mdef); pid < nphone;
+         pid++) {
+        p = pid2phmm[pid];
+
+        if (mdef->phone[mdef->phone[pid].info.cd.ctx[1]].info.ci.filler) {
+            for (i = 0; IS_S3CIPID(filler[i]); i++)
+                bitvec_set(p->lc, filler[i]);
+        }
+        else
+            bitvec_set(p->lc, mdef->phone[pid].info.cd.ctx[1]);
+
+        if (mdef->phone[mdef->phone[pid].info.cd.ctx[2]].info.ci.filler) {
+            for (i = 0; IS_S3CIPID(filler[i]); i++)
+                bitvec_set(p->rc, filler[i]);
+        }
+        else
+            bitvec_set(p->rc, mdef->phone[pid].info.cd.ctx[2]);
+    }
+    ckd_free(pid2phmm);
+    ckd_free(filler);
+
+    /* Create links between PHMM nodes */
+    n_link = phmm_link(allphs);
+
+    E_INFO("%d nodes, %d links\n", n_phmm, n_link);
+    return 0;
+}
+
+static void
+phmm_free(allphone_search_t * allphs)
+{
+    s3cipid_t ci;
+    bin_mdef_t *mdef;
+
+    if (!allphs->ci_phmm)
+        //nothing to free
+        return;
+    ckd_free(allphs->ci_phmm[0]->lc);
+    mdef = ((ps_search_t *) allphs)->acmod->mdef;
+    for (ci = 0; ci < mdef_n_ciphone(mdef); ++ci) {
+        phmm_t *p, *next;
+
+        for (p = allphs->ci_phmm[ci]; p; p = next) {
+            plink_t *l, *lnext;
+
+            next = p->next;
+            for (l = p->succlist; l; l = lnext) {
+                lnext = l->next;
+                ckd_free(l);
+            }
+            hmm_deinit(&(p->hmm));
+            ckd_free(p);
+        }
+    }
+    ckd_free(allphs->ci_phmm);
+}
+
+/** Evaluate active PHMMs */
+static int32
+phmm_eval_all(allphone_search_t * allphs, const int16 * senscr)
+{
+    s3cipid_t ci;
+    phmm_t *p;
+    int32 best;
+    bin_mdef_t *mdef;
+    phmm_t **ci_phmm;
+
+    mdef = ((ps_search_t *) allphs)->acmod->mdef;
+    ci_phmm = allphs->ci_phmm;
+
+    best = WORST_SCORE;
+
+    hmm_context_set_senscore(allphs->hmmctx, senscr);
+    for (ci = 0; ci < mdef->n_ciphone; ci++) {
+        for (p = ci_phmm[(unsigned) ci]; p; p = p->next) {
+            if (hmm_frame(&(p->hmm)) == allphs->frame) {
+                int32 score;
+                allphs->n_hmm_eval++;
+                score = hmm_vit_eval((hmm_t *) p);
+                if (score > best)
+                    best = score;
+            }
+        }
+    }
+
+    return best;
+}
+
+static void
+phmm_exit(allphone_search_t * allphs, int32 best)
+{
+    s3cipid_t ci;
+    phmm_t *p;
+    int32 th, nf;
+    history_t *h;
+    blkarray_list_t *history;
+    bin_mdef_t *mdef;
+    int32 curfrm;
+    phmm_t **ci_phmm;
+    int32 *ci2lmwid;
+
+    th = best + allphs->pbeam;
+
+    history = allphs->history;
+    mdef = ps_search_acmod(allphs)->mdef;
+    curfrm = allphs->frame;
+    ci_phmm = allphs->ci_phmm;
+    ci2lmwid = allphs->ci2lmwid;
+
+    nf = curfrm + 1;
+
+    for (ci = 0; ci < mdef->n_ciphone; ci++) {
+        for (p = ci_phmm[(unsigned) ci]; p; p = p->next) {
+            if (hmm_frame(&(p->hmm)) == curfrm) {
+
+                if (hmm_bestscore(&(p->hmm)) >= th) {
+
+                    h = (history_t *) ckd_calloc(1, sizeof(*h));
+                    h->ef = curfrm;
+                    h->phmm = p;
+                    h->hist = hmm_out_history(&(p->hmm));
+                    h->score = hmm_out_score(&(p->hmm));
+
+                    if (!allphs->lm) {
+                        h->tscore = allphs->inspen;
+                    }
+                    else {
+                        if (h->hist > 0) {
+                            int32 n_used;
+                            history_t *pred =
+                                blkarray_list_get(history, h->hist);
+
+                            if (pred->hist > 0) {
+                                history_t *pred_pred =
+                                    blkarray_list_get(history,
+                                                      h->hist);
+                                h->tscore =
+                                    ngram_tg_score(allphs->lm,
+                                                   ci2lmwid
+                                                   [pred_pred->phmm->ci],
+                                                   ci2lmwid[pred->
+                                                            phmm->ci],
+                                                   ci2lmwid[p->ci],
+                                                   &n_used) >>
+                                    SENSCR_SHIFT;
+                            }
+                            else {
+                                h->tscore =
+                                    ngram_bg_score(allphs->lm,
+                                                   ci2lmwid
+                                                   [pred->phmm->ci],
+                                                   ci2lmwid[p->ci],
+                                                   &n_used) >>
+                                    SENSCR_SHIFT;
+                            }
+                        }
+                        else {
+                            /*
+                             * This is the beginning SIL and in srch_allphone_begin()
+                             * it's inscore is set to 0.
+                             */
+                            h->tscore = 0;
+                        }
+                    }
+
+                    blkarray_list_append(history, h);
+
+                    /* Mark PHMM active in next frame */
+                    hmm_frame(&(p->hmm)) = nf;
+                }
+                else {
+                    /* Reset state scores */
+                    hmm_clear(&(p->hmm));
+                }
+            }
+        }
+    }
+}
+
+static void
+phmm_trans(allphone_search_t * allphs, int32 best,
+           int32 frame_history_start)
+{
+    history_t *h;
+    phmm_t *from, *to;
+    plink_t *l;
+    int32 newscore, nf, curfrm;
+    int32 *ci2lmwid;
+    int32 hist_idx;
+
+    curfrm = allphs->frame;
+    nf = curfrm + 1;
+    ci2lmwid = allphs->ci2lmwid;
+
+    /* Transition from exited nodes to initial states of HMMs */
+    for (hist_idx = frame_history_start;
+         hist_idx < blkarray_list_n_valid(allphs->history); hist_idx++) {
+        h = blkarray_list_get(allphs->history, hist_idx);
+        from = h->phmm;
+        for (l = from->succlist; l; l = l->next) {
+            int32 tscore;
+            to = l->phmm;
+
+            /* No LM, just use uniform (insertion penalty). */
+            if (!allphs->lm)
+                tscore = allphs->inspen;
+            /* If they are not in the LM, kill this
+             * transition. */
+            else if (ci2lmwid[to->ci] == NGRAM_INVALID_WID)
+                continue;
+            else {
+                int32 n_used;
+                if (h->hist > 0) {
+                    history_t *pred =
+                        blkarray_list_get(allphs->history, h->hist);
+                    tscore =
+                        ngram_tg_score(allphs->lm,
+                                       ci2lmwid[pred->phmm->ci],
+                                       ci2lmwid[from->ci],
+                                       ci2lmwid[to->ci],
+                                       &n_used) >> SENSCR_SHIFT;
+                }
+                else {
+                    tscore = ngram_bg_score(allphs->lm,
+                                            ci2lmwid[from->ci],
+                                            ci2lmwid[to->ci],
+                                            &n_used) >> SENSCR_SHIFT;
+                }
+            }
+
+            newscore = h->score + tscore;
+            if ((newscore > best + allphs->beam)
+                && (newscore > hmm_in_score(&(to->hmm)))) {
+                hmm_enter(&(to->hmm), newscore, hist_idx, nf);
+            }
+        }
+    }
+}
+
+ps_search_t *
+allphone_search_init(ngram_model_t * lm,
+                     cmd_ln_t * config,
+                     acmod_t * acmod, dict_t * dict, dict2pid_t * d2p)
+{
+    int i;
+    bin_mdef_t *mdef;
+    allphone_search_t *allphs;
+    static char *lmname = "default";
+
+    allphs = (allphone_search_t *) ckd_calloc(1, sizeof(*allphs));
+    ps_search_init(ps_search_base(allphs), &allphone_funcs, config, acmod,
+                   dict, d2p);
+    mdef = acmod->mdef;
+
+    allphs->hmmctx = hmm_context_init(bin_mdef_n_emit_state(mdef),
+                                      acmod->tmat->tp, NULL, mdef->sseq);
+    if (allphs->hmmctx == NULL) {
+        ps_search_free(ps_search_base(allphs));
+        return NULL;
+    }
+
+    allphs->ci_only = cmd_ln_boolean_r(config, "-allphone_ci");
+    allphs->lw = cmd_ln_float32_r(config, "-lw");
+
+    phmm_build(allphs);
+
+    if (lm) {
+        //language model is defined
+        allphs->lm = ngram_model_set_init(config, &lm, &lmname, NULL, 1);
+        if (!allphs->lm) {
+            E_ERROR
+                ("Failed to initialize ngram model set for phoneme decoding");
+            allphone_search_free((ps_search_t *) allphs);
+            return NULL;
+        }
+        allphs->ci2lmwid =
+            (int32 *) ckd_calloc(mdef->n_ciphone,
+                                 sizeof(*allphs->ci2lmwid));
+        for (i = 0; i < mdef->n_ciphone; i++) {
+            allphs->ci2lmwid[i] =
+                ngram_wid(allphs->lm,
+                          (char *) bin_mdef_ciphone_str(mdef, i));
+            /* Map filler phones to silence if not found */
+            if (allphs->ci2lmwid[i] == NGRAM_INVALID_WID
+                && bin_mdef_ciphone_str(mdef, i))
+                allphs->ci2lmwid[i] =
+                    ngram_wid(allphs->lm,
+                              (char *) bin_mdef_ciphone_str(mdef,
+                                                            mdef_silphone
+                                                            (mdef)));
+        }
+    }
+    else {
+        E_WARN
+            ("Failed to load language model specified in -allphone, doing unconstrained phone-loop decoding\n");
+        allphs->inspen =
+            (int32) (logmath_log
+                     (acmod->lmath, cmd_ln_float32_r(config, "-pip"))
+                     * allphs->lw) >> SENSCR_SHIFT;
+    }
+
+    allphs->n_tot_frame = 0;
+    allphs->frame = -1;
+    allphs->segments = NULL;
+
+    /* Get search pruning parameters */
+    allphs->beam
+        =
+        (int32) logmath_log(acmod->lmath,
+                            cmd_ln_float64_r(config, "-beam"))
+        >> SENSCR_SHIFT;
+    allphs->pbeam
+        =
+        (int32) logmath_log(acmod->lmath,
+                            cmd_ln_float64_r(config, "-pbeam"))
+        >> SENSCR_SHIFT;
+
+    /* LM related weights/penalties */
+    allphs->history = blkarray_list_init();
+
+    /* Acoustic score scale for posterior probabilities. */
+    allphs->ascale = 1.0 / cmd_ln_float32_r(config, "-ascale");
+
+    E_INFO("Allphone(beam: %d, pbeam: %d)\n", allphs->beam, allphs->pbeam);
+
+    ptmr_init(&allphs->perf);
+
+    return (ps_search_t *) allphs;
+}
+
+int
+allphone_search_reinit(ps_search_t * search, dict_t * dict,
+                       dict2pid_t * d2p)
+{
+    allphone_search_t *allphs = (allphone_search_t *) search;
+
+    /* Free old dict2pid, dict */
+    ps_search_base_reinit(search, dict, d2p);
+
+    if (!allphs->lm) {
+        E_WARN
+            ("-lm argument missing; doing unconstrained phone-loop decoding\n");
+        allphs->inspen =
+            (int32) (logmath_log
+                     (search->acmod->lmath,
+                      cmd_ln_float32_r(search->config,
+                                       "-pip")) *
+                     allphs->lw) >> SENSCR_SHIFT;
+    }
+
+    return 0;
+}
+
+void
+allphone_search_free(ps_search_t * search)
+{
+    allphone_search_t *allphs = (allphone_search_t *) search;
+
+    double n_speech = (double)allphs->n_tot_frame
+            / cmd_ln_int32_r(ps_search_config(allphs), "-frate");
+
+    E_INFO("TOTAL fwdflat %.2f CPU %.3f xRT\n",
+           allphs->perf.t_tot_cpu,
+           allphs->perf.t_tot_cpu / n_speech);
+    E_INFO("TOTAL fwdflat %.2f wall %.3f xRT\n",
+           allphs->perf.t_tot_elapsed,
+           allphs->perf.t_tot_elapsed / n_speech);
+
+    ps_search_deinit(search);
+    hmm_context_free(allphs->hmmctx);
+    phmm_free(allphs);
+    if (allphs->lm)
+        ngram_model_free(allphs->lm);
+    if (allphs->ci2lmwid)
+        ckd_free(allphs->ci2lmwid);
+
+    blkarray_list_free(allphs->history);
+
+    ckd_free(allphs);
+}
+
+int
+allphone_search_start(ps_search_t * search)
+{
+    allphone_search_t *allphs;
+    bin_mdef_t *mdef;
+    s3cipid_t ci;
+    phmm_t *p;
+
+    allphs = (allphone_search_t *) search;
+    mdef = search->acmod->mdef;
+
+    /* Reset all HMMs. */
+    for (ci = 0; ci < bin_mdef_n_ciphone(mdef); ci++) {
+        for (p = allphs->ci_phmm[(unsigned) ci]; p; p = p->next) {
+            hmm_clear(&(p->hmm));
+        }
+    }
+
+    allphs->n_hmm_eval = 0;
+    allphs->n_sen_eval = 0;
+
+    /* Free history nodes, if any */
+    blkarray_list_reset(allphs->history);
+
+    /* Initialize start state of the SILENCE PHMM */
+    allphs->frame = 0;
+    ci = bin_mdef_silphone(mdef);
+    if (NOT_S3CIPID(ci))
+        E_FATAL("Cannot find CI-phone %s\n", S3_SILENCE_CIPHONE);
+    for (p = allphs->ci_phmm[ci]; p && (p->pid != ci); p = p->next);
+    if (!p)
+        E_FATAL("Cannot find HMM for %s\n", S3_SILENCE_CIPHONE);
+    hmm_enter(&(p->hmm), 0, 0, allphs->frame);
+
+    ptmr_reset(&allphs->perf);
+    ptmr_start(&allphs->perf);
+
+    return 0;
+}
+
+static void
+allphone_search_sen_active(allphone_search_t * allphs)
+{
+    acmod_t *acmod;
+    bin_mdef_t *mdef;
+    phmm_t *p;
+    int32 ci;
+
+    acmod = ps_search_acmod(allphs);
+    mdef = acmod->mdef;
+
+    acmod_clear_active(acmod);
+    for (ci = 0; ci < bin_mdef_n_ciphone(mdef); ci++)
+        for (p = allphs->ci_phmm[ci]; p; p = p->next)
+            if (hmm_frame(&(p->hmm)) == allphs->frame)
+                acmod_activate_hmm(acmod, &(p->hmm));
+}
+
+int
+allphone_search_step(ps_search_t * search, int frame_idx)
+{
+    int32 bestscr, frame_history_start;
+    const int16 *senscr;
+    allphone_search_t *allphs = (allphone_search_t *) search;
+    acmod_t *acmod = search->acmod;
+
+    if (!acmod->compallsen)
+        allphone_search_sen_active(allphs);
+    senscr = acmod_score(acmod, &frame_idx);
+    allphs->n_sen_eval += acmod->n_senone_active;
+    bestscr = phmm_eval_all(allphs, senscr);
+
+    frame_history_start = blkarray_list_n_valid(allphs->history);
+    phmm_exit(allphs, bestscr);
+    phmm_trans(allphs, bestscr, frame_history_start);
+
+    allphs->frame++;
+
+    return 0;
+}
+
+static int32
+ascore(allphone_search_t * allphs, history_t * h)
+{
+    int32 score = h->score;
+
+    if (h->hist > 0) {
+        history_t *pred = blkarray_list_get(allphs->history, h->hist);
+        score -= pred->score;
+    }
+
+    return score - h->tscore;
+}
+
+static void
+allphone_clear_segments(allphone_search_t * allphs)
+{	
+    gnode_t *gn;
+    for (gn = allphs->segments; gn; gn = gn->next) {
+        ckd_free(gnode_ptr(gn));
+    }
+    glist_free(allphs->segments);
+    allphs->segments = NULL;
+}
+
+static void
+allphone_backtrace(allphone_search_t * allphs, int32 f)
+{
+    int32 best, hist_idx, best_idx;
+    int32 frm, last_frm;
+    history_t *h;
+    phseg_t *s;
+
+    /* Clear old list */
+    allphone_clear_segments(allphs);
+
+    frm = last_frm = f;
+    /* Find the first history entry for the requested frame */
+    hist_idx = blkarray_list_n_valid(allphs->history) - 1;
+    while (hist_idx > 0) {
+        h = blkarray_list_get(allphs->history, hist_idx);
+        if (h->ef <= f) {
+            frm = last_frm = h->ef;
+            break;
+        }
+        hist_idx--;
+    }
+
+    if (hist_idx < 0)
+        return;
+
+    /* Find bestscore */
+    best = (int32) 0x80000000;
+    best_idx = -1;
+    while (frm == last_frm && hist_idx > 0) {
+        h = blkarray_list_get(allphs->history, hist_idx);
+        frm = h->ef;
+        if (h->score > best && frm == last_frm) {
+            best = h->score;
+            best_idx = hist_idx;
+        }
+        hist_idx--;
+    }
+
+    if (best_idx < 0)
+        return;
+
+    /* Backtrace */
+    while (best_idx > 0) {
+        h = blkarray_list_get(allphs->history, best_idx);
+        s = (phseg_t *) ckd_calloc(1, sizeof(phseg_t));
+        s->ci = h->phmm->ci;
+        s->sf =
+            (h->hist >
+             0) ? ((history_t *) blkarray_list_get(allphs->history,
+                                                   h->hist))->ef + 1 : 0;
+        s->ef = h->ef;
+        s->score = ascore(allphs, h);
+        s->tscore = h->tscore;
+        allphs->segments = glist_add_ptr(allphs->segments, s);
+
+        best_idx = h->hist;
+    }
+
+    return;
+}
+
+int
+allphone_search_finish(ps_search_t * search)
+{
+    allphone_search_t *allphs;
+    int32 cf, n_hist;
+
+    allphs = (allphone_search_t *) search;
+
+    allphs->n_tot_frame += allphs->frame;
+    n_hist = blkarray_list_n_valid(allphs->history);
+    E_INFO
+        ("%d frames, %d HMMs (%d/fr), %d senones (%d/fr), %d history entries (%d/fr)\n",
+         allphs->frame, allphs->n_hmm_eval,
+         (allphs->frame > 0) ? allphs->n_hmm_eval / allphs->frame : 0,
+         allphs->n_sen_eval,
+         (allphs->frame > 0) ? allphs->n_sen_eval / allphs->frame : 0,
+         n_hist, (allphs->frame > 0) ? n_hist / allphs->frame : 0);
+
+    /* Now backtrace. */
+    allphone_backtrace(allphs, allphs->frame - 1);
+
+    /* Print out some statistics. */
+    ptmr_stop(&allphs->perf);
+    /* This is the number of frames processed. */
+    cf = ps_search_acmod(allphs)->output_frame;
+    if (cf > 0) {
+        double n_speech = (double) (cf + 1)
+            / cmd_ln_int32_r(ps_search_config(allphs), "-frate");
+        E_INFO("allphone %.2f CPU %.3f xRT\n",
+               allphs->perf.t_cpu, allphs->perf.t_cpu / n_speech);
+        E_INFO("allphone %.2f wall %.3f xRT\n",
+               allphs->perf.t_elapsed, allphs->perf.t_elapsed / n_speech);
+    }
+
+
+    return 0;
+}
+
+char const *
+allphone_search_hyp(ps_search_t * search, int32 * out_score,
+                    int32 * out_is_final)
+{
+    allphone_search_t *allphs;
+    phseg_t *p;
+    gnode_t *gn;
+    const char *phone_str;
+    bin_mdef_t *mdef;
+    int len, hyp_idx, phone_idx;
+
+    allphs = (allphone_search_t *) search;
+    mdef = search->acmod->mdef;
+
+    /* Create hypothesis */
+    if (search->hyp_str)
+        ckd_free(search->hyp_str);
+    search->hyp_str = NULL;
+
+    allphone_backtrace(allphs, allphs->frame - 1);
+    if (allphs->segments == NULL) {
+        return NULL;
+    }
+
+    len = glist_count(allphs->segments) * 10;  // maximum length of one phone with spacebar
+
+    search->hyp_str = (char *) ckd_calloc(len, sizeof(*search->hyp_str));
+    hyp_idx = 0;
+    for (gn = allphs->segments; gn; gn = gn->next) {
+	p = gnode_ptr(gn);
+        phone_str = bin_mdef_ciphone_str(mdef, p->ci);
+        phone_idx = 0;
+        while (phone_str[phone_idx] != '\0')
+            search->hyp_str[hyp_idx++] = phone_str[phone_idx++];
+        search->hyp_str[hyp_idx++] = ' ';
+    }
+    search->hyp_str[--hyp_idx] = '\0';
+    E_INFO("Hyp: %s\n", search->hyp_str);
+    return search->hyp_str;
+}