Add m-esr52 at 52.6.0

5 files changed, 2304 insertions, 0 deletions

diff --git a/media/sphinxbase/src/libsphinxbase/feat/agc.c b/media/sphinxbase/src/libsphinxbase/feat/agc.c
new file mode 100644
index 000000000..271baf49d
--- /dev/null
+++ b/media/sphinxbase/src/libsphinxbase/feat/agc.c
@@ -0,0 +1,227 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1999-2004 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 work was supported in part by funding from the Defense Advanced 
+ * Research Projects Agency and the National Science Foundation of the 
+ * United States of America, and the CMU Sphinx Speech Consortium.
+ *
+ * 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.
+ *
+ * ====================================================================
+ *
+ */
+/*
+ * agc.c -- Various forms of automatic gain control (AGC)
+ * 
+ * **********************************************
+ * CMU ARPA Speech Project
+ *
+ * Copyright (c) 1996 Carnegie Mellon University.
+ * ALL RIGHTS RESERVED.
+ * **********************************************
+ * 
+ * HISTORY
+ * $Log$
+ * Revision 1.5  2005/06/21  19:25:41  arthchan2003
+ * 1, Fixed doxygen documentation. 2, Added $ keyword.
+ * 
+ * Revision 1.3  2005/03/30 01:22:46  archan
+ * Fixed mistakes in last updates. Add
+ *
+ * 
+ * 04-Nov-95	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Created.
+ */
+
+#include <string.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "sphinxbase/err.h"
+#include "sphinxbase/ckd_alloc.h"
+#include "sphinxbase/agc.h"
+
+/* NOTE!  These must match the enum in agc.h */
+const char *agc_type_str[] = {
+    "none",
+    "max",
+    "emax",
+    "noise"
+};
+static const int n_agc_type_str = sizeof(agc_type_str)/sizeof(agc_type_str[0]);
+
+agc_type_t
+agc_type_from_str(const char *str)
+{
+    int i;
+
+    for (i = 0; i < n_agc_type_str; ++i) {
+        if (0 == strcmp(str, agc_type_str[i]))
+            return (agc_type_t)i;
+    }
+    E_FATAL("Unknown AGC type '%s'\n", str);
+    return AGC_NONE;
+}
+
+agc_t *agc_init(void)
+{
+    agc_t *agc;
+    agc = ckd_calloc(1, sizeof(*agc));
+    agc->noise_thresh = FLOAT2MFCC(2.0);
+    
+    return agc;
+}
+
+void agc_free(agc_t *agc)
+{
+    ckd_free(agc);
+}
+
+/**
+ * Normalize c0 for all frames such that max(c0) = 0.
+ */
+void
+agc_max(agc_t *agc, mfcc_t **mfc, int32 n_frame)
+{
+    int32 i;
+
+    if (n_frame <= 0)
+        return;
+    agc->obs_max = mfc[0][0];
+    for (i = 1; i < n_frame; i++) {
+        if (mfc[i][0] > agc->obs_max) {
+            agc->obs_max = mfc[i][0];
+            agc->obs_frame = 1;
+        }
+    }
+
+    E_INFO("AGCMax: obs=max= %.2f\n", agc->obs_max);
+    for (i = 0; i < n_frame; i++)
+        mfc[i][0] -= agc->obs_max;
+}
+
+void
+agc_emax_set(agc_t *agc, float32 m)
+{
+    agc->max = FLOAT2MFCC(m);
+    E_INFO("AGCEMax: max= %.2f\n", m);
+}
+
+float32
+agc_emax_get(agc_t *agc)
+{
+    return MFCC2FLOAT(agc->max);
+}
+
+void
+agc_emax(agc_t *agc, mfcc_t **mfc, int32 n_frame)
+{
+    int i;
+
+    if (n_frame <= 0)
+        return;
+    for (i = 0; i < n_frame; ++i) {
+        if (mfc[i][0] > agc->obs_max) {
+            agc->obs_max = mfc[i][0];
+            agc->obs_frame = 1;
+        }
+        mfc[i][0] -= agc->max;
+    }
+}
+
+/* Update estimated max for next utterance */
+void
+agc_emax_update(agc_t *agc)
+{
+    if (agc->obs_frame) {            /* Update only if some data observed */
+        agc->obs_max_sum += agc->obs_max;
+        agc->obs_utt++;
+
+        /* Re-estimate max over past history; decay the history */
+        agc->max = agc->obs_max_sum / agc->obs_utt;
+        if (agc->obs_utt == 16) {
+            agc->obs_max_sum /= 2;
+            agc->obs_utt = 8;
+        }
+    }
+    E_INFO("AGCEMax: obs= %.2f, new= %.2f\n", agc->obs_max, agc->max);
+
+    /* Reset the accumulators for the next utterance. */
+    agc->obs_frame = 0;
+    agc->obs_max = FLOAT2MFCC(-1000.0); /* Less than any real C0 value (hopefully!!) */
+}
+
+void
+agc_noise(agc_t *agc,
+          mfcc_t **cep,
+          int32 nfr)
+{
+    mfcc_t min_energy; /* Minimum log-energy */
+    mfcc_t noise_level;        /* Average noise_level */
+    int32 i;           /* frame index */
+    int32 noise_frames;        /* Number of noise frames */
+
+    /* Determine minimum log-energy in utterance */
+    min_energy = cep[0][0];
+    for (i = 0; i < nfr; ++i) {
+        if (cep[i][0] < min_energy)
+            min_energy = cep[i][0];
+    }
+
+    /* Average all frames between min_energy and min_energy + agc->noise_thresh */
+    noise_frames = 0;
+    noise_level = 0;
+    min_energy += agc->noise_thresh;
+    for (i = 0; i < nfr; ++i) {
+        if (cep[i][0] < min_energy) {
+            noise_level += cep[i][0];
+            noise_frames++;
+        }
+    }
+
+    if (noise_frames > 0) {
+        noise_level /= noise_frames;
+        E_INFO("AGC NOISE: max= %6.3f\n", MFCC2FLOAT(noise_level));
+        /* Subtract noise_level from all log_energy values */
+        for (i = 0; i < nfr; i++) {
+            cep[i][0] -= noise_level;
+        }
+    }
+}
+
+void
+agc_set_threshold(agc_t *agc, float32 threshold)
+{
+    agc->noise_thresh = FLOAT2MFCC(threshold);
+}
+
+float32
+agc_get_threshold(agc_t *agc)
+{
+    return FLOAT2MFCC(agc->noise_thresh);
+}
diff --git a/media/sphinxbase/src/libsphinxbase/feat/cmn.c b/media/sphinxbase/src/libsphinxbase/feat/cmn.c
new file mode 100644
index 000000000..c133c19a3
--- /dev/null
+++ b/media/sphinxbase/src/libsphinxbase/feat/cmn.c
@@ -0,0 +1,238 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1999-2004 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 work was supported in part by funding from the Defense Advanced 
+ * Research Projects Agency and the National Science Foundation of the 
+ * United States of America, and the CMU Sphinx Speech Consortium.
+ *
+ * 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.
+ *
+ * ====================================================================
+ *
+ */
+/*
+ * cmn.c -- Various forms of cepstral mean normalization
+ *
+ * **********************************************
+ * CMU ARPA Speech Project
+ *
+ * Copyright (c) 1996 Carnegie Mellon University.
+ * ALL RIGHTS RESERVED.
+ * **********************************************
+ * 
+ * HISTORY
+ * $Log$
+ * Revision 1.14  2006/02/24  15:57:47  egouvea
+ * Removed cmn = NULL from the cmn_free(), since it's pointless (my bad!).
+ * 
+ * Removed cmn_prior, which was surrounded by #if 0/#endif, since the
+ * function is already in cmn_prior.c
+ * 
+ * Revision 1.13  2006/02/23 03:47:49  arthchan2003
+ * Used Evandro's changes. Resolved conflicts.
+ *
+ *
+ * Revision 1.12  2006/02/23 00:48:23  egouvea
+ * Replaced loops resetting vectors with the more efficient memset()
+ *
+ * Revision 1.11  2006/02/22 23:43:55  arthchan2003
+ * Merged from the branch SPHINX3_5_2_RCI_IRII_BRANCH: Put data structure into the cmn_t structure.
+ *
+ * Revision 1.10.4.2  2005/10/17 04:45:57  arthchan2003
+ * Free stuffs in cmn and feat corectly.
+ *
+ * Revision 1.10.4.1  2005/07/05 06:25:08  arthchan2003
+ * Fixed dox-doc.
+ *
+ * Revision 1.10  2005/06/21 19:28:00  arthchan2003
+ * 1, Fixed doxygen documentation. 2, Added $ keyword.
+ *
+ * Revision 1.3  2005/03/30 01:22:46  archan
+ * Fixed mistakes in last updates. Add
+ *
+ * 
+ * 20.Apr.2001  RAH (rhoughton@mediasite.com, ricky.houghton@cs.cmu.edu)
+ *              Added cmn_free() and moved *mean and *var out global space and named them cmn_mean and cmn_var
+ * 
+ * 28-Apr-1999	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Changed the name norm_mean() to cmn().
+ * 
+ * 19-Jun-1996	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Changed to compute CMN over ALL dimensions of cep instead of 1..12.
+ * 
+ * 04-Nov-1995	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Created.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (disable: 4244)
+#endif
+
+#include "sphinxbase/ckd_alloc.h"
+#include "sphinxbase/err.h"
+#include "sphinxbase/cmn.h"
+
+/* NOTE!  These must match the enum in cmn.h */
+const char *cmn_type_str[] = {
+    "none",
+    "current",
+    "prior"
+};
+static const int n_cmn_type_str = sizeof(cmn_type_str)/sizeof(cmn_type_str[0]);
+
+cmn_type_t
+cmn_type_from_str(const char *str)
+{
+    int i;
+
+    for (i = 0; i < n_cmn_type_str; ++i) {
+        if (0 == strcmp(str, cmn_type_str[i]))
+            return (cmn_type_t)i;
+    }
+    E_FATAL("Unknown CMN type '%s'\n", str);
+    return CMN_NONE;
+}
+
+cmn_t *
+cmn_init(int32 veclen)
+{
+    cmn_t *cmn;
+    cmn = (cmn_t *) ckd_calloc(1, sizeof(cmn_t));
+    cmn->veclen = veclen;
+    cmn->cmn_mean = (mfcc_t *) ckd_calloc(veclen, sizeof(mfcc_t));
+    cmn->cmn_var = (mfcc_t *) ckd_calloc(veclen, sizeof(mfcc_t));
+    cmn->sum = (mfcc_t *) ckd_calloc(veclen, sizeof(mfcc_t));
+    /* A front-end dependent magic number */
+    cmn->cmn_mean[0] = FLOAT2MFCC(12.0);
+    cmn->nframe = 0;
+    E_INFO("mean[0]= %.2f, mean[1..%d]= 0.0\n",
+           MFCC2FLOAT(cmn->cmn_mean[0]), veclen - 1);
+
+    return cmn;
+}
+
+
+void
+cmn(cmn_t *cmn, mfcc_t ** mfc, int32 varnorm, int32 n_frame)
+{
+    mfcc_t *mfcp;
+    mfcc_t t;
+    int32 i, f;
+    int32 n_pos_frame;
+
+    assert(mfc != NULL);
+
+    if (n_frame <= 0)
+        return;
+
+    /* If cmn->cmn_mean wasn't NULL, we need to zero the contents */
+    memset(cmn->cmn_mean, 0, cmn->veclen * sizeof(mfcc_t));
+
+    /* Find mean cep vector for this utterance */
+    for (f = 0, n_pos_frame = 0; f < n_frame; f++) {
+        mfcp = mfc[f];
+
+        /* Skip zero energy frames */
+        if (mfcp[0] < 0)
+    	    continue;
+
+        for (i = 0; i < cmn->veclen; i++) {
+            cmn->cmn_mean[i] += mfcp[i];
+        }
+
+        n_pos_frame++;
+    }
+
+    for (i = 0; i < cmn->veclen; i++)
+        cmn->cmn_mean[i] /= n_pos_frame;
+
+    E_INFO("CMN: ");
+    for (i = 0; i < cmn->veclen; i++)
+        E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i]));
+    E_INFOCONT("\n");
+    if (!varnorm) {
+        /* Subtract mean from each cep vector */
+        for (f = 0; f < n_frame; f++) {
+            mfcp = mfc[f];
+            for (i = 0; i < cmn->veclen; i++)
+                mfcp[i] -= cmn->cmn_mean[i];
+        }
+    }
+    else {
+        /* Scale cep vectors to have unit variance along each dimension, and subtract means */
+        /* If cmn->cmn_var wasn't NULL, we need to zero the contents */
+        memset(cmn->cmn_var, 0, cmn->veclen * sizeof(mfcc_t));
+
+        for (f = 0; f < n_frame; f++) {
+            mfcp = mfc[f];
+
+            for (i = 0; i < cmn->veclen; i++) {
+                t = mfcp[i] - cmn->cmn_mean[i];
+                cmn->cmn_var[i] += MFCCMUL(t, t);
+            }
+        }
+        for (i = 0; i < cmn->veclen; i++)
+            /* Inverse Std. Dev, RAH added type case from sqrt */
+            cmn->cmn_var[i] = FLOAT2MFCC(sqrt((float64)n_frame / MFCC2FLOAT(cmn->cmn_var[i])));
+
+        for (f = 0; f < n_frame; f++) {
+            mfcp = mfc[f];
+            for (i = 0; i < cmn->veclen; i++)
+                mfcp[i] = MFCCMUL((mfcp[i] - cmn->cmn_mean[i]), cmn->cmn_var[i]);
+        }
+    }
+}
+
+/* 
+ * RAH, free previously allocated memory
+ */
+void
+cmn_free(cmn_t * cmn)
+{
+    if (cmn != NULL) {
+        if (cmn->cmn_var)
+            ckd_free((void *) cmn->cmn_var);
+
+        if (cmn->cmn_mean)
+            ckd_free((void *) cmn->cmn_mean);
+
+        if (cmn->sum)
+            ckd_free((void *) cmn->sum);
+
+        ckd_free((void *) cmn);
+    }
+}
diff --git a/media/sphinxbase/src/libsphinxbase/feat/cmn_prior.c b/media/sphinxbase/src/libsphinxbase/feat/cmn_prior.c
new file mode 100644
index 000000000..9d1801aa7
--- /dev/null
+++ b/media/sphinxbase/src/libsphinxbase/feat/cmn_prior.c
@@ -0,0 +1,184 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1999-2004 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 work was supported in part by funding from the Defense Advanced 
+ * Research Projects Agency and the National Science Foundation of the 
+ * United States of America, and the CMU Sphinx Speech Consortium.
+ *
+ * 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.
+ *
+ * ====================================================================
+ *
+ */
+/*************************************************
+ * CMU ARPA Speech Project
+ *
+ * Copyright (c) 2000 Carnegie Mellon University.
+ * ALL RIGHTS RESERVED.
+ * **********************************************
+ * 
+ * 30-Dec-2000  Rita Singh (rsingh@cs.cmu.edu) at Carnegie Mellon University
+ * Created
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (disable: 4244)
+#endif
+
+#include "sphinxbase/ckd_alloc.h"
+#include "sphinxbase/err.h"
+#include "sphinxbase/cmn.h"
+
+void
+cmn_prior_set(cmn_t *cmn, mfcc_t const * vec)
+{
+    int32 i;
+
+    E_INFO("cmn_prior_set: from < ");
+    for (i = 0; i < cmn->veclen; i++)
+        E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i]));
+    E_INFOCONT(">\n");
+
+    for (i = 0; i < cmn->veclen; i++) {
+        cmn->cmn_mean[i] = vec[i];
+        cmn->sum[i] = vec[i] * CMN_WIN;
+    }
+    cmn->nframe = CMN_WIN;
+
+    E_INFO("cmn_prior_set: to   < ");
+    for (i = 0; i < cmn->veclen; i++)
+        E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i]));
+    E_INFOCONT(">\n");
+}
+
+void
+cmn_prior_get(cmn_t *cmn, mfcc_t * vec)
+{
+    int32 i;
+
+    for (i = 0; i < cmn->veclen; i++)
+        vec[i] = cmn->cmn_mean[i];
+
+}
+
+static void
+cmn_prior_shiftwin(cmn_t *cmn)
+{
+    mfcc_t sf;
+    int32 i;
+
+    E_INFO("cmn_prior_update: from < ");
+    for (i = 0; i < cmn->veclen; i++)
+        E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i]));
+    E_INFOCONT(">\n");
+
+    sf = FLOAT2MFCC(1.0) / cmn->nframe;
+    for (i = 0; i < cmn->veclen; i++)
+        cmn->cmn_mean[i] = cmn->sum[i] / cmn->nframe; /* sum[i] * sf */
+
+    /* Make the accumulation decay exponentially */
+    if (cmn->nframe >= CMN_WIN_HWM) {
+        sf = CMN_WIN * sf;
+        for (i = 0; i < cmn->veclen; i++)
+            cmn->sum[i] = MFCCMUL(cmn->sum[i], sf);
+        cmn->nframe = CMN_WIN;
+    }
+
+    E_INFO("cmn_prior_update: to   < ");
+    for (i = 0; i < cmn->veclen; i++)
+        E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i]));
+    E_INFOCONT(">\n");
+}
+
+void
+cmn_prior_update(cmn_t *cmn)
+{
+    mfcc_t sf;
+    int32 i;
+
+    if (cmn->nframe <= 0)
+        return;
+
+    E_INFO("cmn_prior_update: from < ");
+    for (i = 0; i < cmn->veclen; i++)
+        E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i]));
+    E_INFOCONT(">\n");
+
+    /* Update mean buffer */
+    sf = FLOAT2MFCC(1.0) / cmn->nframe;
+    for (i = 0; i < cmn->veclen; i++)
+        cmn->cmn_mean[i] = cmn->sum[i] / cmn->nframe; /* sum[i] * sf; */
+
+    /* Make the accumulation decay exponentially */
+    if (cmn->nframe > CMN_WIN_HWM) {
+        sf = CMN_WIN * sf;
+        for (i = 0; i < cmn->veclen; i++)
+            cmn->sum[i] = MFCCMUL(cmn->sum[i], sf);
+        cmn->nframe = CMN_WIN;
+    }
+
+    E_INFO("cmn_prior_update: to   < ");
+    for (i = 0; i < cmn->veclen; i++)
+        E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i]));
+    E_INFOCONT(">\n");
+}
+
+void
+cmn_prior(cmn_t *cmn, mfcc_t **incep, int32 varnorm, int32 nfr)
+{
+    int32 i, j;
+
+    if (nfr <= 0)
+        return;
+
+    if (varnorm)
+        E_FATAL
+            ("Variance normalization not implemented in live mode decode\n");
+
+    for (i = 0; i < nfr; i++) {
+
+	/* Skip zero energy frames */
+	if (incep[i][0] < 0)
+	    continue;
+
+        for (j = 0; j < cmn->veclen; j++) {
+            cmn->sum[j] += incep[i][j];
+            incep[i][j] -= cmn->cmn_mean[j];
+        }
+
+        ++cmn->nframe;
+    }
+
+    /* Shift buffer down if we have more than CMN_WIN_HWM frames */
+    if (cmn->nframe > CMN_WIN_HWM)
+        cmn_prior_shiftwin(cmn);
+}
diff --git a/media/sphinxbase/src/libsphinxbase/feat/feat.c b/media/sphinxbase/src/libsphinxbase/feat/feat.c
new file mode 100644
index 000000000..d2252fd85
--- /dev/null
+++ b/media/sphinxbase/src/libsphinxbase/feat/feat.c
@@ -0,0 +1,1497 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1999-2004 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 work was supported in part by funding from the Defense Advanced 
+ * Research Projects Agency and the National Science Foundation of the 
+ * United States of America, and the CMU Sphinx Speech Consortium.
+ *
+ * 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.
+ *
+ * ====================================================================
+ *
+ */
+/*
+ * feat.c -- Feature vector description and cepstra->feature computation.
+ *
+ * **********************************************
+ * CMU ARPA Speech Project
+ *
+ * Copyright (c) 1996 Carnegie Mellon University.
+ * ALL RIGHTS RESERVED.
+ * **********************************************
+ * 
+ * HISTORY
+ * $Log$
+ * Revision 1.22  2006/02/23  03:59:40  arthchan2003
+ * Merged from branch SPHINX3_5_2_RCI_IRII_BRANCH: a, Free buffers correctly. b, Fixed dox-doc.
+ * 
+ * Revision 1.21.4.3  2005/10/17 04:45:57  arthchan2003
+ * Free stuffs in cmn and feat corectly.
+ *
+ * Revision 1.21.4.2  2005/09/26 02:19:57  arthchan2003
+ * Add message to show the directory which the feature is searched for.
+ *
+ * Revision 1.21.4.1  2005/07/03 22:55:50  arthchan2003
+ * More correct deallocation in feat.c. The cmn deallocation is still not correct at this point.
+ *
+ * Revision 1.21  2005/06/22 03:29:35  arthchan2003
+ * Makefile.am s  for all subdirectory of libs3decoder/
+ *
+ * Revision 1.4  2005/04/21 23:50:26  archan
+ * Some more refactoring on the how reporting of structures inside kbcore_t is done, it is now 50% nice. Also added class-based LM test case into test-decode.sh.in.  At this moment, everything in search mode 5 is already done.  It is time to test the idea whether the search can really be used.
+ *
+ * Revision 1.3  2005/03/30 01:22:46  archan
+ * Fixed mistakes in last updates. Add
+ *
+ * 
+ * 20.Apr.2001  RAH (rhoughton@mediasite.com, ricky.houghton@cs.cmu.edu)
+ *              Adding feat_free() to free allocated memory
+ *
+ * 02-Jan-2001	Rita Singh (rsingh@cs.cmu.edu) at Carnegie Mellon University
+ *		Modified feat_s2mfc2feat_block() to handle empty buffers at
+ *		the end of an utterance
+ *
+ * 30-Dec-2000	Rita Singh (rsingh@cs.cmu.edu) at Carnegie Mellon University
+ *		Added feat_s2mfc2feat_block() to allow feature computation
+ *		from sequences of blocks of cepstral vectors
+ *
+ * 12-Jun-98	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Major changes to accommodate arbitrary feature input types.  Added
+ * 		feat_read(), moved various cep2feat functions from other files into
+ *		this one.  Also, made this module object-oriented with the feat_t type.
+ * 		Changed definition of s2mfc_read to let the caller manage MFC buffers.
+ * 
+ * 03-Oct-96	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Added unistd.h include.
+ * 
+ * 02-Oct-96	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Added check for sf argument to s2mfc_read being within file size.
+ * 
+ * 18-Sep-96	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Added sf, ef parameters to s2mfc_read().
+ * 
+ * 10-Jan-96	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Added feat_cepsize().
+ * 		Added different feature-handling (s2_4x, s3_1x39 at this point).
+ * 		Moved feature-dependent functions to feature-dependent files.
+ * 
+ * 09-Jan-96	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Moved constant declarations from feat.h into here.
+ * 
+ * 04-Nov-95	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Created.
+ */
+
+
+/*
+ * This module encapsulates different feature streams used by the Sphinx group.  New
+ * stream types can be added by augmenting feat_init() and providing an accompanying
+ * compute_feat function.  It also provides a "generic" feature vector definition for
+ * handling "arbitrary" speech input feature types (see the last section in feat_init()).
+ * In this case the speech input data should already be feature vectors; no computation,
+ * such as MFC->feature conversion, is available or needed.
+ */
+
+#include <assert.h>
+#include <string.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (disable: 4244 4996)
+#endif
+
+#include "sphinxbase/fe.h"
+#include "sphinxbase/feat.h"
+#include "sphinxbase/bio.h"
+#include "sphinxbase/pio.h"
+#include "sphinxbase/cmn.h"
+#include "sphinxbase/agc.h"
+#include "sphinxbase/err.h"
+#include "sphinxbase/ckd_alloc.h"
+#include "sphinxbase/prim_type.h"
+#include "sphinxbase/glist.h"
+
+#define FEAT_VERSION	"1.0"
+#define FEAT_DCEP_WIN		2
+
+#ifdef DUMP_FEATURES
+static void
+cep_dump_dbg(feat_t *fcb, mfcc_t **mfc, int32 nfr, const char *text)
+{
+    int32 i, j;
+
+    E_INFO("%s\n", text);
+    for (i = 0; i < nfr; i++) {
+        for (j = 0; j < fcb->cepsize; j++) {
+            fprintf(stderr, "%f ", MFCC2FLOAT(mfc[i][j]));
+        }
+        fprintf(stderr, "\n");
+    }
+}
+static void
+feat_print_dbg(feat_t *fcb, mfcc_t ***feat, int32 nfr, const char *text)
+{
+    E_INFO("%s\n", text);
+    feat_print(fcb, feat, nfr, stderr);
+}
+#else /* !DUMP_FEATURES */
+#define cep_dump_dbg(fcb,mfc,nfr,text)
+#define feat_print_dbg(fcb,mfc,nfr,text)
+#endif
+
+int32 **
+parse_subvecs(char const *str)
+{
+    char const *strp;
+    int32 n, n2, l;
+    glist_t dimlist;            /* List of dimensions in one subvector */
+    glist_t veclist;            /* List of dimlists (subvectors) */
+    int32 **subvec;
+    gnode_t *gn, *gn2;
+
+    veclist = NULL;
+
+    strp = str;
+    for (;;) {
+        dimlist = NULL;
+
+        for (;;) {
+            if (sscanf(strp, "%d%n", &n, &l) != 1)
+                E_FATAL("'%s': Couldn't read int32 @pos %d\n", str,
+                        strp - str);
+            strp += l;
+
+            if (*strp == '-') {
+                strp++;
+
+                if (sscanf(strp, "%d%n", &n2, &l) != 1)
+                    E_FATAL("'%s': Couldn't read int32 @pos %d\n", str,
+                            strp - str);
+                strp += l;
+            }
+            else
+                n2 = n;
+
+            if ((n < 0) || (n > n2))
+                E_FATAL("'%s': Bad subrange spec ending @pos %d\n", str,
+                        strp - str);
+
+            for (; n <= n2; n++) {
+		gnode_t *gn;
+		for (gn = dimlist; gn; gn = gnode_next(gn))
+		    if (gnode_int32(gn) == n)
+			break;
+		if (gn != NULL)
+                    E_FATAL("'%s': Duplicate dimension ending @pos %d\n",
+                            str, strp - str);
+
+                dimlist = glist_add_int32(dimlist, n);
+            }
+
+            if ((*strp == '\0') || (*strp == '/'))
+                break;
+
+            if (*strp != ',')
+                E_FATAL("'%s': Bad delimiter @pos %d\n", str, strp - str);
+
+            strp++;
+        }
+
+        veclist = glist_add_ptr(veclist, (void *) dimlist);
+
+        if (*strp == '\0')
+            break;
+
+        assert(*strp == '/');
+        strp++;
+    }
+
+    /* Convert the glists to arrays; remember the glists are in reverse order of the input! */
+    n = glist_count(veclist);   /* #Subvectors */
+    subvec = (int32 **) ckd_calloc(n + 1, sizeof(int32 *));     /* +1 for sentinel */
+    subvec[n] = NULL;           /* sentinel */
+
+    for (--n, gn = veclist; (n >= 0) && gn; gn = gnode_next(gn), --n) {
+        gn2 = (glist_t) gnode_ptr(gn);
+
+        n2 = glist_count(gn2);  /* Length of this subvector */
+        if (n2 <= 0)
+            E_FATAL("'%s': 0-length subvector\n", str);
+
+        subvec[n] = (int32 *) ckd_calloc(n2 + 1, sizeof(int32));        /* +1 for sentinel */
+        subvec[n][n2] = -1;     /* sentinel */
+
+        for (--n2; (n2 >= 0) && gn2; gn2 = gnode_next(gn2), --n2)
+            subvec[n][n2] = gnode_int32(gn2);
+        assert((n2 < 0) && (!gn2));
+    }
+    assert((n < 0) && (!gn));
+
+    /* Free the glists */
+    for (gn = veclist; gn; gn = gnode_next(gn)) {
+        gn2 = (glist_t) gnode_ptr(gn);
+        glist_free(gn2);
+    }
+    glist_free(veclist);
+
+    return subvec;
+}
+
+void
+subvecs_free(int32 **subvecs)
+{
+    int32 **sv;
+
+    for (sv = subvecs; sv && *sv; ++sv)
+        ckd_free(*sv);
+    ckd_free(subvecs);
+}
+
+int
+feat_set_subvecs(feat_t *fcb, int32 **subvecs)
+{
+    int32 **sv;
+    uint32 n_sv, n_dim, i;
+
+    if (subvecs == NULL) {
+        subvecs_free(fcb->subvecs);
+        ckd_free(fcb->sv_buf);
+        ckd_free(fcb->sv_len);
+        fcb->n_sv = 0;
+        fcb->subvecs = NULL;
+        fcb->sv_len = NULL;
+        fcb->sv_buf = NULL;
+        fcb->sv_dim = 0;
+        return 0;
+    }
+
+    if (fcb->n_stream != 1) {
+        E_ERROR("Subvector specifications require single-stream features!");
+        return -1;
+    }
+
+    n_sv = 0;
+    n_dim = 0;
+    for (sv = subvecs; sv && *sv; ++sv) {
+        int32 *d;
+
+        for (d = *sv; d && *d != -1; ++d) {
+            ++n_dim;
+        }
+        ++n_sv;
+    }
+    if (n_dim > feat_dimension(fcb)) {
+        E_ERROR("Total dimensionality of subvector specification %d "
+                "> feature dimensionality %d\n", n_dim, feat_dimension(fcb));
+        return -1;
+    }
+
+    fcb->n_sv = n_sv;
+    fcb->subvecs = subvecs;
+    fcb->sv_len = (uint32 *)ckd_calloc(n_sv, sizeof(*fcb->sv_len));
+    fcb->sv_buf = (mfcc_t *)ckd_calloc(n_dim, sizeof(*fcb->sv_buf));
+    fcb->sv_dim = n_dim;
+    for (i = 0; i < n_sv; ++i) {
+        int32 *d;
+        for (d = subvecs[i]; d && *d != -1; ++d) {
+            ++fcb->sv_len[i];
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * Project feature components to subvectors (if any).
+ */
+static void
+feat_subvec_project(feat_t *fcb, mfcc_t ***inout_feat, uint32 nfr)
+{
+    uint32 i;
+
+    if (fcb->subvecs == NULL)
+        return;
+    for (i = 0; i < nfr; ++i) {
+        mfcc_t *out;
+        int32 j;
+
+        out = fcb->sv_buf;
+        for (j = 0; j < fcb->n_sv; ++j) {
+            int32 *d;
+            for (d = fcb->subvecs[j]; d && *d != -1; ++d) {
+                *out++ = inout_feat[i][0][*d];
+            }
+        }
+        memcpy(inout_feat[i][0], fcb->sv_buf, fcb->sv_dim * sizeof(*fcb->sv_buf));
+    }
+}
+
+mfcc_t ***
+feat_array_alloc(feat_t * fcb, int32 nfr)
+{
+    int32 i, j, k;
+    mfcc_t *data, *d, ***feat;
+
+    assert(fcb);
+    assert(nfr > 0);
+    assert(feat_dimension(fcb) > 0);
+
+    /* Make sure to use the dimensionality of the features *before*
+       LDA and subvector projection. */
+    k = 0;
+    for (i = 0; i < fcb->n_stream; ++i)
+        k += fcb->stream_len[i];
+    assert(k >= feat_dimension(fcb));
+    assert(k >= fcb->sv_dim);
+
+    feat =
+        (mfcc_t ***) ckd_calloc_2d(nfr, feat_dimension1(fcb), sizeof(mfcc_t *));
+    data = (mfcc_t *) ckd_calloc(nfr * k, sizeof(mfcc_t));
+
+    for (i = 0; i < nfr; i++) {
+        d = data + i * k;
+        for (j = 0; j < feat_dimension1(fcb); j++) {
+            feat[i][j] = d;
+            d += feat_dimension2(fcb, j);
+        }
+    }
+
+    return feat;
+}
+
+mfcc_t ***
+feat_array_realloc(feat_t *fcb, mfcc_t ***old_feat, int32 ofr, int32 nfr)
+{
+    int32 i, k, cf;
+    mfcc_t*** new_feat;
+
+    assert(fcb);
+    assert(nfr > 0);
+    assert(ofr > 0);
+    assert(feat_dimension(fcb) > 0);
+
+    /* Make sure to use the dimensionality of the features *before*
+       LDA and subvector projection. */
+    k = 0;
+    for (i = 0; i < fcb->n_stream; ++i)
+        k += fcb->stream_len[i];
+    assert(k >= feat_dimension(fcb));
+    assert(k >= fcb->sv_dim);
+    
+    new_feat = feat_array_alloc(fcb, nfr);
+
+    cf = (nfr < ofr) ? nfr : ofr;
+    memcpy(new_feat[0][0], old_feat[0][0], cf * k * sizeof(mfcc_t));
+
+    feat_array_free(old_feat);
+    
+    return new_feat;
+}
+
+void
+feat_array_free(mfcc_t ***feat)
+{
+    ckd_free(feat[0][0]);
+    ckd_free_2d((void **)feat);
+}
+
+static void
+feat_s2_4x_cep2feat(feat_t * fcb, mfcc_t ** mfc, mfcc_t ** feat)
+{
+    mfcc_t *f;
+    mfcc_t *w, *_w;
+    mfcc_t *w1, *w_1, *_w1, *_w_1;
+    mfcc_t d1, d2;
+    int32 i, j;
+
+    assert(fcb);
+    assert(feat_cepsize(fcb) == 13);
+    assert(feat_n_stream(fcb) == 4);
+    assert(feat_stream_len(fcb, 0) == 12);
+    assert(feat_stream_len(fcb, 1) == 24);
+    assert(feat_stream_len(fcb, 2) == 3);
+    assert(feat_stream_len(fcb, 3) == 12);
+    assert(feat_window_size(fcb) == 4);
+
+    /* CEP; skip C0 */
+    memcpy(feat[0], mfc[0] + 1, (feat_cepsize(fcb) - 1) * sizeof(mfcc_t));
+
+    /*
+     * DCEP(SHORT): mfc[2] - mfc[-2]
+     * DCEP(LONG):  mfc[4] - mfc[-4]
+     */
+    w = mfc[2] + 1;             /* +1 to skip C0 */
+    _w = mfc[-2] + 1;
+
+    f = feat[1];
+    for (i = 0; i < feat_cepsize(fcb) - 1; i++) /* Short-term */
+        f[i] = w[i] - _w[i];
+
+    w = mfc[4] + 1;             /* +1 to skip C0 */
+    _w = mfc[-4] + 1;
+
+    for (j = 0; j < feat_cepsize(fcb) - 1; i++, j++)    /* Long-term */
+        f[i] = w[j] - _w[j];
+
+    /* D2CEP: (mfc[3] - mfc[-1]) - (mfc[1] - mfc[-3]) */
+    w1 = mfc[3] + 1;            /* Final +1 to skip C0 */
+    _w1 = mfc[-1] + 1;
+    w_1 = mfc[1] + 1;
+    _w_1 = mfc[-3] + 1;
+
+    f = feat[3];
+    for (i = 0; i < feat_cepsize(fcb) - 1; i++) {
+        d1 = w1[i] - _w1[i];
+        d2 = w_1[i] - _w_1[i];
+
+        f[i] = d1 - d2;
+    }
+
+    /* POW: C0, DC0, D2C0; differences computed as above for rest of cep */
+    f = feat[2];
+    f[0] = mfc[0][0];
+    f[1] = mfc[2][0] - mfc[-2][0];
+
+    d1 = mfc[3][0] - mfc[-1][0];
+    d2 = mfc[1][0] - mfc[-3][0];
+    f[2] = d1 - d2;
+}
+
+
+static void
+feat_s3_1x39_cep2feat(feat_t * fcb, mfcc_t ** mfc, mfcc_t ** feat)
+{
+    mfcc_t *f;
+    mfcc_t *w, *_w;
+    mfcc_t *w1, *w_1, *_w1, *_w_1;
+    mfcc_t d1, d2;
+    int32 i;
+
+    assert(fcb);
+    assert(feat_cepsize(fcb) == 13);
+    assert(feat_n_stream(fcb) == 1);
+    assert(feat_stream_len(fcb, 0) == 39);
+    assert(feat_window_size(fcb) == 3);
+
+    /* CEP; skip C0 */
+    memcpy(feat[0], mfc[0] + 1, (feat_cepsize(fcb) - 1) * sizeof(mfcc_t));
+    /*
+     * DCEP: mfc[2] - mfc[-2];
+     */
+    f = feat[0] + feat_cepsize(fcb) - 1;
+    w = mfc[2] + 1;             /* +1 to skip C0 */
+    _w = mfc[-2] + 1;
+
+    for (i = 0; i < feat_cepsize(fcb) - 1; i++)
+        f[i] = w[i] - _w[i];
+
+    /* POW: C0, DC0, D2C0 */
+    f += feat_cepsize(fcb) - 1;
+
+    f[0] = mfc[0][0];
+    f[1] = mfc[2][0] - mfc[-2][0];
+
+    d1 = mfc[3][0] - mfc[-1][0];
+    d2 = mfc[1][0] - mfc[-3][0];
+    f[2] = d1 - d2;
+
+    /* D2CEP: (mfc[3] - mfc[-1]) - (mfc[1] - mfc[-3]) */
+    f += 3;
+
+    w1 = mfc[3] + 1;            /* Final +1 to skip C0 */
+    _w1 = mfc[-1] + 1;
+    w_1 = mfc[1] + 1;
+    _w_1 = mfc[-3] + 1;
+
+    for (i = 0; i < feat_cepsize(fcb) - 1; i++) {
+        d1 = w1[i] - _w1[i];
+        d2 = w_1[i] - _w_1[i];
+
+        f[i] = d1 - d2;
+    }
+}
+
+
+static void
+feat_s3_cep(feat_t * fcb, mfcc_t ** mfc, mfcc_t ** feat)
+{
+    assert(fcb);
+    assert(feat_n_stream(fcb) == 1);
+    assert(feat_window_size(fcb) == 0);
+
+    /* CEP */
+    memcpy(feat[0], mfc[0], feat_cepsize(fcb) * sizeof(mfcc_t));
+}
+
+static void
+feat_s3_cep_dcep(feat_t * fcb, mfcc_t ** mfc, mfcc_t ** feat)
+{
+    mfcc_t *f;
+    mfcc_t *w, *_w;
+    int32 i;
+
+    assert(fcb);
+    assert(feat_n_stream(fcb) == 1);
+    assert(feat_stream_len(fcb, 0) == feat_cepsize(fcb) * 2);
+    assert(feat_window_size(fcb) == 2);
+
+    /* CEP */
+    memcpy(feat[0], mfc[0], feat_cepsize(fcb) * sizeof(mfcc_t));
+
+    /*
+     * DCEP: mfc[2] - mfc[-2];
+     */
+    f = feat[0] + feat_cepsize(fcb);
+    w = mfc[2];
+    _w = mfc[-2];
+
+    for (i = 0; i < feat_cepsize(fcb); i++)
+        f[i] = w[i] - _w[i];
+}
+
+static void
+feat_1s_c_d_dd_cep2feat(feat_t * fcb, mfcc_t ** mfc, mfcc_t ** feat)
+{
+    mfcc_t *f;
+    mfcc_t *w, *_w;
+    mfcc_t *w1, *w_1, *_w1, *_w_1;
+    mfcc_t d1, d2;
+    int32 i;
+
+    assert(fcb);
+    assert(feat_n_stream(fcb) == 1);
+    assert(feat_stream_len(fcb, 0) == feat_cepsize(fcb) * 3);
+    assert(feat_window_size(fcb) == FEAT_DCEP_WIN + 1);
+
+    /* CEP */
+    memcpy(feat[0], mfc[0], feat_cepsize(fcb) * sizeof(mfcc_t));
+
+    /*
+     * DCEP: mfc[w] - mfc[-w], where w = FEAT_DCEP_WIN;
+     */
+    f = feat[0] + feat_cepsize(fcb);
+    w = mfc[FEAT_DCEP_WIN];
+    _w = mfc[-FEAT_DCEP_WIN];
+
+    for (i = 0; i < feat_cepsize(fcb); i++)
+        f[i] = w[i] - _w[i];
+
+    /* 
+     * D2CEP: (mfc[w+1] - mfc[-w+1]) - (mfc[w-1] - mfc[-w-1]), 
+     * where w = FEAT_DCEP_WIN 
+     */
+    f += feat_cepsize(fcb);
+
+    w1 = mfc[FEAT_DCEP_WIN + 1];
+    _w1 = mfc[-FEAT_DCEP_WIN + 1];
+    w_1 = mfc[FEAT_DCEP_WIN - 1];
+    _w_1 = mfc[-FEAT_DCEP_WIN - 1];
+
+    for (i = 0; i < feat_cepsize(fcb); i++) {
+        d1 = w1[i] - _w1[i];
+        d2 = w_1[i] - _w_1[i];
+
+        f[i] = d1 - d2;
+    }
+}
+
+static void
+feat_1s_c_d_ld_dd_cep2feat(feat_t * fcb, mfcc_t ** mfc, mfcc_t ** feat)
+{
+    mfcc_t *f;
+    mfcc_t *w, *_w;
+    mfcc_t *w1, *w_1, *_w1, *_w_1;
+    mfcc_t d1, d2;
+    int32 i;
+
+    assert(fcb);
+    assert(feat_n_stream(fcb) == 1);
+    assert(feat_stream_len(fcb, 0) == feat_cepsize(fcb) * 4);
+    assert(feat_window_size(fcb) == FEAT_DCEP_WIN * 2);
+
+    /* CEP */
+    memcpy(feat[0], mfc[0], feat_cepsize(fcb) * sizeof(mfcc_t));
+
+    /*
+     * DCEP: mfc[w] - mfc[-w], where w = FEAT_DCEP_WIN;
+     */
+    f = feat[0] + feat_cepsize(fcb);
+    w = mfc[FEAT_DCEP_WIN];
+    _w = mfc[-FEAT_DCEP_WIN];
+
+    for (i = 0; i < feat_cepsize(fcb); i++)
+        f[i] = w[i] - _w[i];
+
+    /*
+     * LDCEP: mfc[w] - mfc[-w], where w = FEAT_DCEP_WIN * 2;
+     */
+    f += feat_cepsize(fcb);
+    w = mfc[FEAT_DCEP_WIN * 2];
+    _w = mfc[-FEAT_DCEP_WIN * 2];
+
+    for (i = 0; i < feat_cepsize(fcb); i++)
+        f[i] = w[i] - _w[i];
+
+    /* 
+     * D2CEP: (mfc[w+1] - mfc[-w+1]) - (mfc[w-1] - mfc[-w-1]), 
+     * where w = FEAT_DCEP_WIN 
+     */
+    f += feat_cepsize(fcb);
+
+    w1 = mfc[FEAT_DCEP_WIN + 1];
+    _w1 = mfc[-FEAT_DCEP_WIN + 1];
+    w_1 = mfc[FEAT_DCEP_WIN - 1];
+    _w_1 = mfc[-FEAT_DCEP_WIN - 1];
+
+    for (i = 0; i < feat_cepsize(fcb); i++) {
+        d1 = w1[i] - _w1[i];
+        d2 = w_1[i] - _w_1[i];
+
+        f[i] = d1 - d2;
+    }
+}
+
+static void
+feat_copy(feat_t * fcb, mfcc_t ** mfc, mfcc_t ** feat)
+{
+    int32 win, i, j;
+
+    win = feat_window_size(fcb);
+
+    /* Concatenate input features */
+    for (i = -win; i <= win; ++i) {
+        uint32 spos = 0;
+
+        for (j = 0; j < feat_n_stream(fcb); ++j) {
+            uint32 stream_len;
+
+            /* Unscale the stream length by the window. */
+            stream_len = feat_stream_len(fcb, j) / (2 * win + 1);
+            memcpy(feat[j] + ((i + win) * stream_len),
+                   mfc[i] + spos,
+                   stream_len * sizeof(mfcc_t));
+            spos += stream_len;
+        }
+    }
+}
+
+feat_t *
+feat_init(char const *type, cmn_type_t cmn, int32 varnorm,
+          agc_type_t agc, int32 breport, int32 cepsize)
+{
+    feat_t *fcb;
+
+    if (cepsize == 0)
+        cepsize = 13;
+    if (breport)
+        E_INFO
+            ("Initializing feature stream to type: '%s', ceplen=%d, CMN='%s', VARNORM='%s', AGC='%s'\n",
+             type, cepsize, cmn_type_str[cmn], varnorm ? "yes" : "no", agc_type_str[agc]);
+
+    fcb = (feat_t *) ckd_calloc(1, sizeof(feat_t));
+    fcb->refcount = 1;
+    fcb->name = (char *) ckd_salloc(type);
+    if (strcmp(type, "s2_4x") == 0) {
+        /* Sphinx-II format 4-stream feature (Hack!! hardwired constants below) */
+        if (cepsize != 13) {
+            E_ERROR("s2_4x features require cepsize == 13\n");
+            ckd_free(fcb);
+            return NULL;
+        }
+        fcb->cepsize = 13;
+        fcb->n_stream = 4;
+        fcb->stream_len = (uint32 *) ckd_calloc(4, sizeof(uint32));
+        fcb->stream_len[0] = 12;
+        fcb->stream_len[1] = 24;
+        fcb->stream_len[2] = 3;
+        fcb->stream_len[3] = 12;
+        fcb->out_dim = 51;
+        fcb->window_size = 4;
+        fcb->compute_feat = feat_s2_4x_cep2feat;
+    }
+    else if ((strcmp(type, "s3_1x39") == 0) || (strcmp(type, "1s_12c_12d_3p_12dd") == 0)) {
+        /* 1-stream cep/dcep/pow/ddcep (Hack!! hardwired constants below) */
+        if (cepsize != 13) {
+            E_ERROR("s2_4x features require cepsize == 13\n");
+            ckd_free(fcb);
+            return NULL;
+        }
+        fcb->cepsize = 13;
+        fcb->n_stream = 1;
+        fcb->stream_len = (uint32 *) ckd_calloc(1, sizeof(uint32));
+        fcb->stream_len[0] = 39;
+        fcb->out_dim = 39;
+        fcb->window_size = 3;
+        fcb->compute_feat = feat_s3_1x39_cep2feat;
+    }
+    else if (strncmp(type, "1s_c_d_dd", 9) == 0) {
+        fcb->cepsize = cepsize;
+        fcb->n_stream = 1;
+        fcb->stream_len = (uint32 *) ckd_calloc(1, sizeof(uint32));
+        fcb->stream_len[0] = cepsize * 3;
+        fcb->out_dim = cepsize * 3;
+        fcb->window_size = FEAT_DCEP_WIN + 1; /* ddcep needs the extra 1 */
+        fcb->compute_feat = feat_1s_c_d_dd_cep2feat;
+    }
+    else if (strncmp(type, "1s_c_d_ld_dd", 12) == 0) {
+        fcb->cepsize = cepsize;
+        fcb->n_stream = 1;
+        fcb->stream_len = (uint32 *) ckd_calloc(1, sizeof(uint32));
+        fcb->stream_len[0] = cepsize * 4;
+        fcb->out_dim = cepsize * 4;
+        fcb->window_size = FEAT_DCEP_WIN * 2;
+        fcb->compute_feat = feat_1s_c_d_ld_dd_cep2feat;
+    }
+    else if (strncmp(type, "cep_dcep", 8) == 0 || strncmp(type, "1s_c_d", 6) == 0) {
+        /* 1-stream cep/dcep */
+        fcb->cepsize = cepsize;
+        fcb->n_stream = 1;
+        fcb->stream_len = (uint32 *) ckd_calloc(1, sizeof(uint32));
+        fcb->stream_len[0] = feat_cepsize(fcb) * 2;
+        fcb->out_dim = fcb->stream_len[0];
+        fcb->window_size = 2;
+        fcb->compute_feat = feat_s3_cep_dcep;
+    }
+    else if (strncmp(type, "cep", 3) == 0 || strncmp(type, "1s_c", 4) == 0) {
+        /* 1-stream cep */
+        fcb->cepsize = cepsize;
+        fcb->n_stream = 1;
+        fcb->stream_len = (uint32 *) ckd_calloc(1, sizeof(uint32));
+        fcb->stream_len[0] = feat_cepsize(fcb);
+        fcb->out_dim = fcb->stream_len[0];
+        fcb->window_size = 0;
+        fcb->compute_feat = feat_s3_cep;
+    }
+    else if (strncmp(type, "1s_3c", 5) == 0 || strncmp(type, "1s_4c", 5) == 0) {
+	/* 1-stream cep with frames concatenated, so called cepwin features */
+        if (strncmp(type, "1s_3c", 5) == 0)
+            fcb->window_size = 3;
+        else
+    	    fcb->window_size = 4;
+
+        fcb->cepsize = cepsize;
+        fcb->n_stream = 1;
+        fcb->stream_len = (uint32 *) ckd_calloc(1, sizeof(uint32));
+        fcb->stream_len[0] = feat_cepsize(fcb) * (2 * fcb->window_size + 1);
+        fcb->out_dim = fcb->stream_len[0];
+        fcb->compute_feat = feat_copy;
+    }
+    else {
+        int32 i, k, l;
+        size_t len;
+        char *strp;
+        char *mtype = ckd_salloc(type);
+        char *wd = ckd_salloc(type);
+        /*
+         * Generic definition: Format should be %d,%d,%d,...,%d (i.e.,
+         * comma separated list of feature stream widths; #items =
+         * #streams).  An optional window size (frames will be
+         * concatenated) is also allowed, which can be specified with
+         * a colon after the list of feature streams.
+         */
+        len = strlen(mtype);
+        k = 0;
+        for (i = 1; i < len - 1; i++) {
+            if (mtype[i] == ',') {
+                mtype[i] = ' ';
+                k++;
+            }
+            else if (mtype[i] == ':') {
+                mtype[i] = '\0';
+                fcb->window_size = atoi(mtype + i + 1);
+                break;
+            }
+        }
+        k++;                    /* Presumably there are (#commas+1) streams */
+        fcb->n_stream = k;
+        fcb->stream_len = (uint32 *) ckd_calloc(k, sizeof(uint32));
+
+        /* Scan individual feature stream lengths */
+        strp = mtype;
+        i = 0;
+        fcb->out_dim = 0;
+        fcb->cepsize = 0;
+        while (sscanf(strp, "%s%n", wd, &l) == 1) {
+            strp += l;
+            if ((i >= fcb->n_stream)
+                || (sscanf(wd, "%u", &(fcb->stream_len[i])) != 1)
+                || (fcb->stream_len[i] <= 0))
+                E_FATAL("Bad feature type argument\n");
+            /* Input size before windowing */
+            fcb->cepsize += fcb->stream_len[i];
+            if (fcb->window_size > 0)
+                fcb->stream_len[i] *= (fcb->window_size * 2 + 1);
+            /* Output size after windowing */
+            fcb->out_dim += fcb->stream_len[i];
+            i++;
+        }
+        if (i != fcb->n_stream)
+            E_FATAL("Bad feature type argument\n");
+        if (fcb->cepsize != cepsize)
+    	    E_FATAL("Bad feature type argument\n");
+
+        /* Input is already the feature stream */
+        fcb->compute_feat = feat_copy;
+        ckd_free(mtype);
+        ckd_free(wd);
+    }
+
+    if (cmn != CMN_NONE)
+        fcb->cmn_struct = cmn_init(feat_cepsize(fcb));
+    fcb->cmn = cmn;
+    fcb->varnorm = varnorm;
+    if (agc != AGC_NONE) {
+        fcb->agc_struct = agc_init();
+        /*
+         * No need to check if agc is set to EMAX; agc_emax_set() changes only emax related things
+         * Moreover, if agc is not NONE and block mode is used, feat_agc() SILENTLY
+         * switches to EMAX
+         */
+        /* HACK: hardwired initial estimates based on use of CMN (from Sphinx2) */
+        agc_emax_set(fcb->agc_struct, (cmn != CMN_NONE) ? 5.0 : 10.0);
+    }
+    fcb->agc = agc;
+    /*
+     * Make sure this buffer is large enough to be used in feat_s2mfc2feat_block_utt()
+     */
+    fcb->cepbuf = (mfcc_t **) ckd_calloc_2d((LIVEBUFBLOCKSIZE < feat_window_size(fcb) * 2) ? feat_window_size(fcb) * 2 : LIVEBUFBLOCKSIZE,
+                                            feat_cepsize(fcb),
+                                            sizeof(mfcc_t));
+    /* This one is actually just an array of pointers to "flatten out"
+     * wraparounds. */
+    fcb->tmpcepbuf = (mfcc_t** )ckd_calloc(2 * feat_window_size(fcb) + 1,
+                                sizeof(*fcb->tmpcepbuf));
+
+    return fcb;
+}
+
+
+void
+feat_print(feat_t * fcb, mfcc_t *** feat, int32 nfr, FILE * fp)
+{
+    uint32 i, j, k;
+
+    for (i = 0; i < nfr; i++) {
+        fprintf(fp, "%8d:\n", i);
+
+        for (j = 0; j < feat_dimension1(fcb); j++) {
+            fprintf(fp, "\t%2d:", j);
+
+            for (k = 0; k < feat_dimension2(fcb, j); k++)
+                fprintf(fp, " %8.4f", MFCC2FLOAT(feat[i][j][k]));
+            fprintf(fp, "\n");
+        }
+    }
+
+    fflush(fp);
+}
+
+static void
+feat_cmn(feat_t *fcb, mfcc_t **mfc, int32 nfr, int32 beginutt, int32 endutt)
+{
+    cmn_type_t cmn_type = fcb->cmn;
+
+    if (!(beginutt && endutt)
+        && cmn_type != CMN_NONE) /* Only cmn_prior in block computation mode. */
+        fcb->cmn = cmn_type = CMN_PRIOR;
+
+    switch (cmn_type) {
+    case CMN_CURRENT:
+        cmn(fcb->cmn_struct, mfc, fcb->varnorm, nfr);
+        break;
+    case CMN_PRIOR:
+        cmn_prior(fcb->cmn_struct, mfc, fcb->varnorm, nfr);
+        if (endutt)
+            cmn_prior_update(fcb->cmn_struct);
+        break;
+    default:
+        ;
+    }
+    cep_dump_dbg(fcb, mfc, nfr, "After CMN");
+}
+
+static void
+feat_agc(feat_t *fcb, mfcc_t **mfc, int32 nfr, int32 beginutt, int32 endutt)
+{
+    agc_type_t agc_type = fcb->agc;
+
+    if (!(beginutt && endutt)
+        && agc_type != AGC_NONE) /* Only agc_emax in block computation mode. */
+        agc_type = AGC_EMAX;
+
+    switch (agc_type) {
+    case AGC_MAX:
+        agc_max(fcb->agc_struct, mfc, nfr);
+        break;
+    case AGC_EMAX:
+        agc_emax(fcb->agc_struct, mfc, nfr);
+        if (endutt)
+            agc_emax_update(fcb->agc_struct);
+        break;
+    case AGC_NOISE:
+        agc_noise(fcb->agc_struct, mfc, nfr);
+        break;
+    default:
+        ;
+    }
+    cep_dump_dbg(fcb, mfc, nfr, "After AGC");
+}
+
+static void
+feat_compute_utt(feat_t *fcb, mfcc_t **mfc, int32 nfr, int32 win, mfcc_t ***feat)
+{
+    int32 i;
+
+    cep_dump_dbg(fcb, mfc, nfr, "Incoming features (after padding)");
+
+    /* Create feature vectors */
+    for (i = win; i < nfr - win; i++) {
+        fcb->compute_feat(fcb, mfc + i, feat[i - win]);
+    }
+
+    feat_print_dbg(fcb, feat, nfr - win * 2, "After dynamic feature computation");
+
+    if (fcb->lda) {
+        feat_lda_transform(fcb, feat, nfr - win * 2);
+        feat_print_dbg(fcb, feat, nfr - win * 2, "After LDA");
+    }
+
+    if (fcb->subvecs) {
+        feat_subvec_project(fcb, feat, nfr - win * 2);
+        feat_print_dbg(fcb, feat, nfr - win * 2, "After subvector projection");
+    }
+}
+
+
+/**
+ * Read Sphinx-II format mfc file (s2mfc = Sphinx-II format MFC data).
+ * If out_mfc is NULL, no actual reading will be done, and the number of 
+ * frames (plus padding) that would be read is returned.
+ * 
+ * It's important that normalization is done before padding because
+ * frames outside the data we are interested in shouldn't be taken
+ * into normalization stats.
+ *
+ * @return # frames read (plus padding) if successful, -1 if
+ * error (e.g., mfc array too small).  
+ */
+static int32
+feat_s2mfc_read_norm_pad(feat_t *fcb, char *file, int32 win,
+            		 int32 sf, int32 ef,
+            		 mfcc_t ***out_mfc,
+            		 int32 maxfr,
+            		 int32 cepsize)
+{
+    FILE *fp;
+    int32 n_float32;
+    float32 *float_feat;
+    struct stat statbuf;
+    int32 i, n, byterev;
+    int32 start_pad, end_pad;
+    mfcc_t **mfc;
+
+    /* Initialize the output pointer to NULL, so that any attempts to
+       free() it if we fail before allocating it will not segfault! */
+    if (out_mfc)
+        *out_mfc = NULL;
+    E_INFO("Reading mfc file: '%s'[%d..%d]\n", file, sf, ef);
+    if (ef >= 0 && ef <= sf) {
+        E_ERROR("%s: End frame (%d) <= Start frame (%d)\n", file, ef, sf);
+        return -1;
+    }
+
+    /* Find filesize; HACK!! To get around intermittent NFS failures, use stat_retry */
+    if ((stat_retry(file, &statbuf) < 0)
+        || ((fp = fopen(file, "rb")) == NULL)) {
+        E_ERROR_SYSTEM("Failed to open file '%s' for reading", file);
+        return -1;
+    }
+
+    /* Read #floats in header */
+    if (fread_retry(&n_float32, sizeof(int32), 1, fp) != 1) {
+        E_ERROR("%s: fread(#floats) failed\n", file);
+        fclose(fp);
+        return -1;
+    }
+
+    /* Check if n_float32 matches file size */
+    byterev = 0;
+    if ((int32) (n_float32 * sizeof(float32) + 4) != (int32) statbuf.st_size) { /* RAH, typecast both sides to remove compile warning */
+        n = n_float32;
+        SWAP_INT32(&n);
+
+        if ((int32) (n * sizeof(float32) + 4) != (int32) (statbuf.st_size)) {   /* RAH, typecast both sides to remove compile warning */
+            E_ERROR
+                ("%s: Header size field: %d(%08x); filesize: %d(%08x)\n",
+                 file, n_float32, n_float32, statbuf.st_size,
+                 statbuf.st_size);
+            fclose(fp);
+            return -1;
+        }
+
+        n_float32 = n;
+        byterev = 1;
+    }
+    if (n_float32 <= 0) {
+        E_ERROR("%s: Header size field (#floats) = %d\n", file, n_float32);
+        fclose(fp);
+        return -1;
+    }
+
+    /* Convert n to #frames of input */
+    n = n_float32 / cepsize;
+    if (n * cepsize != n_float32) {
+        E_ERROR("Header size field: %d; not multiple of %d\n", n_float32,
+                cepsize);
+        fclose(fp);
+        return -1;
+    }
+
+    /* Check start and end frames */
+    if (sf > 0) {
+        if (sf >= n) {
+            E_ERROR("%s: Start frame (%d) beyond file size (%d)\n", file,
+                    sf, n);
+            fclose(fp);
+            return -1;
+        }
+    }
+    if (ef < 0)
+        ef = n-1;
+    else if (ef >= n) {
+        E_WARN("%s: End frame (%d) beyond file size (%d), will truncate\n",
+               file, ef, n);
+        ef = n-1;
+    }
+
+    /* Add window to start and end frames */
+    sf -= win;
+    ef += win;
+    if (sf < 0) {
+        start_pad = -sf;
+        sf = 0;
+    }
+    else
+        start_pad = 0;
+    if (ef >= n) {
+        end_pad = ef - n + 1;
+        ef = n - 1;
+    }
+    else
+        end_pad = 0;
+
+    /* Limit n if indicated by [sf..ef] */
+    if ((ef - sf + 1) < n)
+        n = (ef - sf + 1);
+    if (maxfr > 0 && n + start_pad + end_pad > maxfr) {
+        E_ERROR("%s: Maximum output size(%d frames) < actual #frames(%d)\n",
+                file, maxfr, n + start_pad + end_pad);
+        fclose(fp);
+        return -1;
+    }
+
+    /* If no output buffer was supplied, then skip the actual data reading. */
+    if (out_mfc != NULL) {
+        /* Position at desired start frame and read actual MFC data */
+        mfc = (mfcc_t **)ckd_calloc_2d(n + start_pad + end_pad, cepsize, sizeof(mfcc_t));
+        if (sf > 0)
+            fseek(fp, sf * cepsize * sizeof(float32), SEEK_CUR);
+        n_float32 = n * cepsize;
+#ifdef FIXED_POINT
+        float_feat = ckd_calloc(n_float32, sizeof(float32));
+#else
+        float_feat = mfc[start_pad];
+#endif
+        if (fread_retry(float_feat, sizeof(float32), n_float32, fp) != n_float32) {
+            E_ERROR("%s: fread(%dx%d) (MFC data) failed\n", file, n, cepsize);
+            ckd_free_2d(mfc);
+            fclose(fp);
+            return -1;
+        }
+        if (byterev) {
+            for (i = 0; i < n_float32; i++) {
+                SWAP_FLOAT32(&float_feat[i]);
+            }
+        }
+#ifdef FIXED_POINT
+        for (i = 0; i < n_float32; ++i) {
+            mfc[start_pad][i] = FLOAT2MFCC(float_feat[i]);
+        }
+        ckd_free(float_feat);
+#endif
+
+        /* Normalize */
+        feat_cmn(fcb, mfc + start_pad, n, 1, 1);
+        feat_agc(fcb, mfc + start_pad, n, 1, 1);
+
+        /* Replicate start and end frames if necessary. */
+        for (i = 0; i < start_pad; ++i)
+            memcpy(mfc[i], mfc[start_pad], cepsize * sizeof(mfcc_t));
+        for (i = 0; i < end_pad; ++i)
+            memcpy(mfc[start_pad + n + i], mfc[start_pad + n - 1],
+                   cepsize * sizeof(mfcc_t));
+
+        *out_mfc = mfc;
+    }
+
+    fclose(fp);
+    return n + start_pad + end_pad;
+}
+
+
+
+int32
+feat_s2mfc2feat(feat_t * fcb, const char *file, const char *dir, const char *cepext,
+                int32 sf, int32 ef, mfcc_t *** feat, int32 maxfr)
+{
+    char *path;
+    char *ps = "/";
+    int32 win, nfr;
+    size_t file_length, cepext_length, path_length = 0;
+    mfcc_t **mfc;
+
+    if (fcb->cepsize <= 0) {
+        E_ERROR("Bad cepsize: %d\n", fcb->cepsize);
+        return -1;
+    }
+
+    if (cepext == NULL)
+        cepext = "";
+
+    /*
+     * Create mfc filename, combining file, dir and extension if
+     * necessary
+     */
+
+    /*
+     * First we decide about the path. If dir is defined, then use
+     * it. Otherwise assume the filename already contains the path.
+     */
+    if (dir == NULL) {
+        dir = "";
+        ps = "";
+        /*
+         * This is not true but some 3rd party apps
+         * may parse the output explicitly checking for this line
+         */
+        E_INFO("At directory . (current directory)\n");
+    }
+    else {
+        E_INFO("At directory %s\n", dir);
+        /*
+         * Do not forget the path separator!
+         */
+        path_length += strlen(dir) + 1;
+    }
+
+    /*
+     * Include cepext, if it's not already part of the filename.
+     */
+    file_length = strlen(file);
+    cepext_length = strlen(cepext);
+    if ((file_length > cepext_length)
+        && (strcmp(file + file_length - cepext_length, cepext) == 0)) {
+        cepext = "";
+        cepext_length = 0;
+    }
+
+    /*
+     * Do not forget the '\0'
+     */
+    path_length += file_length + cepext_length + 1;
+    path = (char*) ckd_calloc(path_length, sizeof(char));
+
+#ifdef HAVE_SNPRINTF
+    /*
+     * Paranoia is our best friend...
+     */
+    while ((file_length = snprintf(path, path_length, "%s%s%s%s", dir, ps, file, cepext)) > path_length) {
+        path_length = file_length;
+        path = (char*) ckd_realloc(path, path_length * sizeof(char));
+    }
+#else
+    sprintf(path, "%s%s%s%s", dir, ps, file, cepext);
+#endif
+
+    win = feat_window_size(fcb);
+    /* Pad maxfr with win, so we read enough raw feature data to
+     * calculate the requisite number of dynamic features. */
+    if (maxfr >= 0)
+        maxfr += win * 2;
+
+    if (feat != NULL) {
+        /* Read mfc file including window or padding if necessary. */
+        nfr = feat_s2mfc_read_norm_pad(fcb, path, win, sf, ef, &mfc, maxfr, fcb->cepsize);
+        ckd_free(path);
+        if (nfr < 0) {
+            ckd_free_2d((void **) mfc);
+            return -1;
+        }
+
+        /* Actually compute the features */
+        feat_compute_utt(fcb, mfc, nfr, win, feat);
+        
+        ckd_free_2d((void **) mfc);
+    }
+    else {
+        /* Just calculate the number of frames we would need. */
+        nfr = feat_s2mfc_read_norm_pad(fcb, path, win, sf, ef, NULL, maxfr, fcb->cepsize);
+        ckd_free(path);
+        if (nfr < 0)
+            return nfr;
+    }
+
+
+    return (nfr - win * 2);
+}
+
+static int32
+feat_s2mfc2feat_block_utt(feat_t * fcb, mfcc_t ** uttcep,
+			  int32 nfr, mfcc_t *** ofeat)
+{
+    mfcc_t **cepbuf;
+    int32 i, win, cepsize;
+
+    win = feat_window_size(fcb);
+    cepsize = feat_cepsize(fcb);
+
+    /* Copy and pad out the utterance (this requires that the
+     * feature computation functions always access the buffer via
+     * the frame pointers, which they do)  */
+    cepbuf = (mfcc_t **)ckd_calloc(nfr + win * 2, sizeof(mfcc_t *));
+    memcpy(cepbuf + win, uttcep, nfr * sizeof(mfcc_t *));
+
+    /* Do normalization before we interpolate on the boundary */    
+    feat_cmn(fcb, cepbuf + win, nfr, 1, 1);
+    feat_agc(fcb, cepbuf + win, nfr, 1, 1);
+
+    /* Now interpolate */    
+    for (i = 0; i < win; ++i) {
+        cepbuf[i] = fcb->cepbuf[i];
+        memcpy(cepbuf[i], uttcep[0], cepsize * sizeof(mfcc_t));
+        cepbuf[nfr + win + i] = fcb->cepbuf[win + i];
+        memcpy(cepbuf[nfr + win + i], uttcep[nfr - 1], cepsize * sizeof(mfcc_t));
+    }
+    /* Compute as usual. */
+    feat_compute_utt(fcb, cepbuf, nfr + win * 2, win, ofeat);
+    ckd_free(cepbuf);
+    return nfr;
+}
+
+int32
+feat_s2mfc2feat_live(feat_t * fcb, mfcc_t ** uttcep, int32 *inout_ncep,
+		     int32 beginutt, int32 endutt, mfcc_t *** ofeat)
+{
+    int32 win, cepsize, nbufcep;
+    int32 i, j, nfeatvec;
+    int32 zero = 0;
+
+    /* Avoid having to check this everywhere. */
+    if (inout_ncep == NULL) inout_ncep = &zero;
+
+    /* Special case for entire utterances. */
+    if (beginutt && endutt && *inout_ncep > 0)
+        return feat_s2mfc2feat_block_utt(fcb, uttcep, *inout_ncep, ofeat);
+
+    win = feat_window_size(fcb);
+    cepsize = feat_cepsize(fcb);
+
+    /* Empty the input buffer on start of utterance. */
+    if (beginutt)
+        fcb->bufpos = fcb->curpos;
+
+    /* Calculate how much data is in the buffer already. */
+    nbufcep = fcb->bufpos - fcb->curpos;
+    if (nbufcep < 0)
+	nbufcep = fcb->bufpos + LIVEBUFBLOCKSIZE - fcb->curpos;
+    /* Add any data that we have to replicate. */
+    if (beginutt && *inout_ncep > 0)
+        nbufcep += win;
+    if (endutt)
+        nbufcep += win;
+
+    /* Only consume as much input as will fit in the buffer. */
+    if (nbufcep + *inout_ncep > LIVEBUFBLOCKSIZE) {
+        /* We also can't overwrite the trailing window, hence the
+         * reason why win is subtracted here. */
+        *inout_ncep = LIVEBUFBLOCKSIZE - nbufcep - win;
+        /* Cancel end of utterance processing. */
+        endutt = FALSE;
+    }
+
+    /* FIXME: Don't modify the input! */
+    feat_cmn(fcb, uttcep, *inout_ncep, beginutt, endutt);
+    feat_agc(fcb, uttcep, *inout_ncep, beginutt, endutt);
+
+    /* Replicate first frame into the first win frames if we're at the
+     * beginning of the utterance and there was some actual input to
+     * deal with.  (FIXME: Not entirely sure why that condition) */
+    if (beginutt && *inout_ncep > 0) {
+        for (i = 0; i < win; i++) {
+            memcpy(fcb->cepbuf[fcb->bufpos++], uttcep[0],
+                   cepsize * sizeof(mfcc_t));
+            fcb->bufpos %= LIVEBUFBLOCKSIZE;
+        }
+        /* Move the current pointer past this data. */
+        fcb->curpos = fcb->bufpos;
+        nbufcep -= win;
+    }
+
+    /* Copy in frame data to the circular buffer. */
+    for (i = 0; i < *inout_ncep; ++i) {
+        memcpy(fcb->cepbuf[fcb->bufpos++], uttcep[i],
+               cepsize * sizeof(mfcc_t));
+        fcb->bufpos %= LIVEBUFBLOCKSIZE;
+	++nbufcep;
+    }
+
+    /* Replicate last frame into the last win frames if we're at the
+     * end of the utterance (even if there was no input, so we can
+     * flush the output). */
+    if (endutt) {
+        int32 tpos; /* Index of last input frame. */
+        if (fcb->bufpos == 0)
+            tpos = LIVEBUFBLOCKSIZE - 1;
+        else
+            tpos = fcb->bufpos - 1;
+        for (i = 0; i < win; ++i) {
+            memcpy(fcb->cepbuf[fcb->bufpos++], fcb->cepbuf[tpos],
+                   cepsize * sizeof(mfcc_t));
+            fcb->bufpos %= LIVEBUFBLOCKSIZE;
+        }
+    }
+
+    /* We have to leave the trailing window of frames. */
+    nfeatvec = nbufcep - win;
+    if (nfeatvec <= 0)
+        return 0; /* Do nothing. */
+
+    for (i = 0; i < nfeatvec; ++i) {
+        /* Handle wraparound cases. */
+        if (fcb->curpos - win < 0 || fcb->curpos + win >= LIVEBUFBLOCKSIZE) {
+            /* Use tmpcepbuf for this case.  Actually, we just need the pointers. */
+            for (j = -win; j <= win; ++j) {
+                int32 tmppos =
+                    (fcb->curpos + j + LIVEBUFBLOCKSIZE) % LIVEBUFBLOCKSIZE;
+		fcb->tmpcepbuf[win + j] = fcb->cepbuf[tmppos];
+            }
+            fcb->compute_feat(fcb, fcb->tmpcepbuf + win, ofeat[i]);
+        }
+        else {
+            fcb->compute_feat(fcb, fcb->cepbuf + fcb->curpos, ofeat[i]);
+        }
+	/* Move the read pointer forward. */
+        ++fcb->curpos;
+        fcb->curpos %= LIVEBUFBLOCKSIZE;
+    }
+
+    if (fcb->lda)
+        feat_lda_transform(fcb, ofeat, nfeatvec);
+
+    if (fcb->subvecs)
+        feat_subvec_project(fcb, ofeat, nfeatvec);
+
+    return nfeatvec;
+}
+
+void 
+feat_update_stats(feat_t *fcb)
+{
+    if (fcb->cmn == CMN_PRIOR) {
+        cmn_prior_update(fcb->cmn_struct);
+    }
+    if (fcb->agc == AGC_EMAX || fcb->agc == AGC_MAX) {
+	agc_emax_update(fcb->agc_struct);	
+    }
+}
+
+feat_t *
+feat_retain(feat_t *f)
+{
+    ++f->refcount;
+    return f;
+}
+
+int
+feat_free(feat_t * f)
+{
+    if (f == NULL)
+        return 0;
+    if (--f->refcount > 0)
+        return f->refcount;
+
+    if (f->cepbuf)
+        ckd_free_2d((void **) f->cepbuf);
+    ckd_free(f->tmpcepbuf);
+
+    if (f->name) {
+        ckd_free((void *) f->name);
+    }
+    if (f->lda)
+        ckd_free_3d((void ***) f->lda);
+
+    ckd_free(f->stream_len);
+    ckd_free(f->sv_len);
+    ckd_free(f->sv_buf);
+    subvecs_free(f->subvecs);
+
+    cmn_free(f->cmn_struct);
+    agc_free(f->agc_struct);
+
+    ckd_free(f);
+    return 0;
+}
+
+
+void
+feat_report(feat_t * f)
+{
+    int i;
+    E_INFO_NOFN("Initialization of feat_t, report:\n");
+    E_INFO_NOFN("Feature type         = %s\n", f->name);
+    E_INFO_NOFN("Cepstral size        = %d\n", f->cepsize);
+    E_INFO_NOFN("Number of streams    = %d\n", f->n_stream);
+    for (i = 0; i < f->n_stream; i++) {
+        E_INFO_NOFN("Vector size of stream[%d]: %d\n", i,
+                    f->stream_len[i]);
+    }
+    E_INFO_NOFN("Number of subvectors = %d\n", f->n_sv);
+    for (i = 0; i < f->n_sv; i++) {
+        int32 *sv;
+
+        E_INFO_NOFN("Components of subvector[%d]:", i);
+        for (sv = f->subvecs[i]; sv && *sv != -1; ++sv)
+            E_INFOCONT(" %d", *sv);
+        E_INFOCONT("\n");
+    }
+    E_INFO_NOFN("Whether CMN is used  = %d\n", f->cmn);
+    E_INFO_NOFN("Whether AGC is used  = %d\n", f->agc);
+    E_INFO_NOFN("Whether variance is normalized = %d\n", f->varnorm);
+    E_INFO_NOFN("\n");
+}
diff --git a/media/sphinxbase/src/libsphinxbase/feat/lda.c b/media/sphinxbase/src/libsphinxbase/feat/lda.c
new file mode 100644
index 000000000..182b029de
--- /dev/null
+++ b/media/sphinxbase/src/libsphinxbase/feat/lda.c
@@ -0,0 +1,158 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 2006 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 work was supported in part by funding from the Defense Advanced 
+ * Research Projects Agency and the National Science Foundation of the 
+ * United States of America, and the CMU Sphinx Speech Consortium.
+ *
+ * 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.
+ *
+ * ====================================================================
+ *
+ */
+/*
+ * lda.c -- Read and apply LDA matrices to features.
+ *
+ * Author: David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+#include <assert.h>
+#include <string.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (disable: 4018)
+#endif
+
+#include "sphinxbase/feat.h"
+#include "sphinxbase/ckd_alloc.h"
+#include "sphinxbase/bio.h"
+#include "sphinxbase/err.h"
+
+#define MATRIX_FILE_VERSION "0.1"
+
+int32
+feat_read_lda(feat_t *feat, const char *ldafile, int32 dim)
+{
+    FILE *fh;
+    int32 byteswap;
+    uint32 chksum, i, m, n;
+    char **argname, **argval;
+
+    assert(feat);
+    if (feat->n_stream != 1) {
+        E_ERROR("LDA incompatible with multi-stream features (n_stream = %d)\n",
+                feat->n_stream);
+        return -1;
+    }
+
+    if ((fh = fopen(ldafile, "rb")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open transform file '%s' for reading", ldafile);
+        return -1;
+    }
+
+    if (bio_readhdr(fh, &argname, &argval, &byteswap) < 0) {
+        E_ERROR("Failed to read header from transform file '%s'\n", ldafile);
+        fclose(fh);
+        return -1;
+    }
+
+    for (i = 0; argname[i]; i++) {
+        if (strcmp(argname[i], "version") == 0) {
+            if (strcmp(argval[i], MATRIX_FILE_VERSION) != 0)
+                E_WARN("%s: Version mismatch: %s, expecting %s\n",
+                       ldafile, argval[i], MATRIX_FILE_VERSION);
+        }
+    }
+
+    bio_hdrarg_free(argname, argval);
+    argname = argval = NULL;
+
+    chksum = 0;
+
+    if (feat->lda)
+        ckd_free_3d((void ***)feat->lda);
+
+    {
+        /* Use a temporary variable to avoid strict-aliasing problems. */
+        void ***outlda;
+
+        if (bio_fread_3d(&outlda, sizeof(float32),
+                         &feat->n_lda, &m, &n,
+                         fh, byteswap, &chksum) < 0) {
+            E_ERROR_SYSTEM("%s: bio_fread_3d(lda) failed\n", ldafile);
+            fclose(fh);
+            return -1;
+        }
+        feat->lda = (void *)outlda;
+    }
+    fclose(fh);
+    
+#ifdef FIXED_POINT
+    /* FIXME: This is a fragile hack that depends on mfcc_t and
+     * float32 being the same size (which they are, but...) */
+    for (i = 0; i < feat->n_lda * m * n; ++i) {
+        feat->lda[0][0][i] = FLOAT2MFCC(((float *)feat->lda[0][0])[i]);
+    }
+#endif
+
+    /* Note that SphinxTrain stores the eigenvectors as row vectors. */
+    if (n != feat->stream_len[0])
+	E_FATAL("LDA matrix dimension %d doesn't match feature stream size %d\n", n, feat->stream_len[0]);
+    
+    /* Override dim from file if it is 0 or greater than m. */
+    if (dim > m || dim <= 0) {
+        dim = m;
+    }
+    feat->out_dim = dim;
+
+    return 0;
+}
+
+void
+feat_lda_transform(feat_t *fcb, mfcc_t ***inout_feat, uint32 nfr)
+{
+    mfcc_t *tmp;
+    uint32 i, j, k;
+
+    tmp = ckd_calloc(fcb->stream_len[0], sizeof(mfcc_t));
+    for (i = 0; i < nfr; ++i) {
+        /* Do the matrix multiplication inline here since fcb->lda
+         * is transposed (eigenvectors in rows not columns). */
+        /* FIXME: In the future we ought to use the BLAS. */
+        memset(tmp, 0, sizeof(mfcc_t) * fcb->stream_len[0]);
+        for (j = 0; j < feat_dimension(fcb); ++j) {
+            for (k = 0; k < fcb->stream_len[0]; ++k) {
+                tmp[j] += MFCCMUL(inout_feat[i][0][k], fcb->lda[0][j][k]);
+            }
+        }
+        memcpy(inout_feat[i][0], tmp, fcb->stream_len[0] * sizeof(mfcc_t));
+    }
+    ckd_free(tmp);
+}