new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/cmdln_macro.h
@@ -0,0 +1,386 @@
+/* -*- 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.
+ *
+ * ====================================================================
+ *
+ */
+
+/* cmdln_macro.h - Command line definitions for PocketSphinx */
+
+#ifndef __PS_CMDLN_MACRO_H__
+#define __PS_CMDLN_MACRO_H__
+
+#include <sphinxbase/cmd_ln.h>
+#include <sphinxbase/feat.h>
+#include <sphinxbase/fe.h>
+
+/** Minimal set of command-line options for PocketSphinx. */
+#define POCKETSPHINX_OPTIONS \
+    waveform_to_cepstral_command_line_macro(), \
+    cepstral_to_feature_command_line_macro(), \
+    POCKETSPHINX_ACMOD_OPTIONS,      \
+        POCKETSPHINX_BEAM_OPTIONS,   \
+        POCKETSPHINX_SEARCH_OPTIONS, \
+        POCKETSPHINX_DICT_OPTIONS,   \
+        POCKETSPHINX_NGRAM_OPTIONS,  \
+        POCKETSPHINX_FSG_OPTIONS,    \
+        POCKETSPHINX_KWS_OPTIONS,    \
+        POCKETSPHINX_DEBUG_OPTIONS
+
+/** Options for debugging and logging. */
+#define POCKETSPHINX_DEBUG_OPTIONS                      \
+    { "-logfn",                                         \
+            ARG_STRING,                                 \
+            NULL,                                       \
+            "File to write log messages in"             \
+     },                                                 \
+    { "-debug",                                         \
+            ARG_INT32,                                  \
+            NULL,                                       \
+            "Verbosity level for debugging messages"    \
+     },                                                 \
+     { "-mfclogdir",                                    \
+             ARG_STRING,                                \
+             NULL,                                      \
+             "Directory to log feature files to"        \
+             },                                         \
+    { "-rawlogdir",                                     \
+            ARG_STRING,                                 \
+            NULL,                                       \
+            "Directory to log raw audio files to" },    \
+     { "-senlogdir",                                    \
+             ARG_STRING,                                \
+             NULL,                                      \
+             "Directory to log senone score files to"   \
+             }
+
+/** Options defining beam width parameters for tuning the search. */
+#define POCKETSPHINX_BEAM_OPTIONS                                       \
+{ "-beam",                                                              \
+      ARG_FLOAT64,                                                      \
+      "1e-48",                                                          \
+      "Beam width applied to every frame in Viterbi search (smaller values mean wider beam)" }, \
+{ "-wbeam",                                                             \
+      ARG_FLOAT64,                                                      \
+      "7e-29",                                                          \
+      "Beam width applied to word exits" },                             \
+{ "-pbeam",                                                             \
+      ARG_FLOAT64,                                                      \
+      "1e-48",                                                          \
+      "Beam width applied to phone transitions" },                      \
+{ "-lpbeam",                                                            \
+      ARG_FLOAT64,                                                      \
+      "1e-40",                                                          \
+      "Beam width applied to last phone in words" },                    \
+{ "-lponlybeam",                                                        \
+      ARG_FLOAT64,                                                      \
+      "7e-29",                                                          \
+      "Beam width applied to last phone in single-phone words" },       \
+{ "-fwdflatbeam",                                                       \
+      ARG_FLOAT64,                                                      \
+      "1e-64",                                                          \
+      "Beam width applied to every frame in second-pass flat search" }, \
+{ "-fwdflatwbeam",                                                      \
+      ARG_FLOAT64,                                                      \
+      "7e-29",                                                          \
+      "Beam width applied to word exits in second-pass flat search" },  \
+{ "-pl_window",                                                         \
+      ARG_INT32,                                                        \
+      "5",                                                              \
+      "Phoneme lookahead window size, in frames" },                     \
+{ "-pl_beam",                                                           \
+      ARG_FLOAT64,                                                      \
+      "1e-10",                                                          \
+      "Beam width applied to phone loop search for lookahead" },        \
+{ "-pl_pbeam",                                                          \
+      ARG_FLOAT64,                                                      \
+      "1e-10",                                                          \
+      "Beam width applied to phone loop transitions for lookahead" },   \
+{ "-pl_pip",                                                            \
+      ARG_FLOAT32,                                                      \
+      "1.0",                                                            \
+      "Phone insertion penalty for phone loop" },                       \
+{ "-pl_weight",                                                         \
+      ARG_FLOAT64,                                                      \
+      "3.0",                                                            \
+      "Weight for phoneme lookahead penalties" }                        \
+
+/** Options defining other parameters for tuning the search. */
+#define POCKETSPHINX_SEARCH_OPTIONS \
+{ "-compallsen",                                                                                \
+      ARG_BOOLEAN,                                                                              \
+      "no",                                                                                     \
+      "Compute all senone scores in every frame (can be faster when there are many senones)" }, \
+{ "-fwdtree",                                                                                   \
+      ARG_BOOLEAN,                                                                              \
+      "yes",                                                                                    \
+      "Run forward lexicon-tree search (1st pass)" },                                           \
+{ "-fwdflat",                                                                                   \
+      ARG_BOOLEAN,                                                                              \
+      "yes",                                                                                    \
+      "Run forward flat-lexicon search over word lattice (2nd pass)" },                         \
+{ "-bestpath",                                                                                  \
+      ARG_BOOLEAN,                                                                              \
+      "yes",                                                                                    \
+      "Run bestpath (Dijkstra) search over word lattice (3rd pass)" },                          \
+{ "-backtrace",                                                                                 \
+      ARG_BOOLEAN,                                                                              \
+      "no",                                                                                     \
+      "Print results and backtraces to log file." },                                            \
+{ "-latsize",                                                                                   \
+      ARG_INT32,                                                                                \
+      "5000",                                                                                   \
+      "Initial backpointer table size" },                                                       \
+{ "-maxwpf",                                                                                    \
+      ARG_INT32,                                                                                \
+      "-1",                                                                                     \
+      "Maximum number of distinct word exits at each frame (or -1 for no pruning)" },           \
+{ "-maxhmmpf",                                                                                  \
+      ARG_INT32,                                                                                \
+      "30000",                                                                                  \
+      "Maximum number of active HMMs to maintain at each frame (or -1 for no pruning)" },       \
+{ "-min_endfr",                                                                                 \
+      ARG_INT32,                                                                                \
+      "0",                                                                                      \
+      "Nodes ignored in lattice construction if they persist for fewer than N frames" },        \
+{ "-fwdflatefwid",                                                                              \
+      ARG_INT32,                                                                                \
+      "4",                                                                     	                \
+      "Minimum number of end frames for a word to be searched in fwdflat search" },             \
+{ "-fwdflatsfwin",                                                                              \
+      ARG_INT32,                                                                                \
+      "25",                                                                    	                \
+      "Window of frames in lattice to search for successor words in fwdflat search " }
+
+/** Command-line options for keyword spotting */
+#define POCKETSPHINX_KWS_OPTIONS \
+{ "-keyphrase",                                                 \
+         ARG_STRING,                                            \
+         NULL,                                                  \
+         "Keyphrase to spot"},                                  \
+{ "-kws",                                                       \
+         ARG_STRING,                                            \
+         NULL,                                                  \
+         "A file with keyphrases to spot, one per line"},       \
+{ "-kws_plp",                                                   \
+      ARG_FLOAT64,                                              \
+      "1e-1",                                                   \
+      "Phone loop probability for keyword spotting" },          \
+{ "-kws_threshold",                                             \
+      ARG_FLOAT64,                                              \
+      "1",                                                      \
+      "Threshold for p(hyp)/p(alternatives) ratio" }
+
+/** Command-line options for finite state grammars. */
+#define POCKETSPHINX_FSG_OPTIONS \
+    { "-fsg",                                                   \
+            ARG_STRING,                                         \
+            NULL,                                               \
+            "Sphinx format finite state grammar file"},         \
+{ "-jsgf",                                                      \
+        ARG_STRING,                                             \
+        NULL,                                                   \
+        "JSGF grammar file" },                                  \
+{ "-toprule",                                                   \
+        ARG_STRING,                                             \
+        NULL,                                                   \
+        "Start rule for JSGF (first public rule is default)" }, \
+{ "-fsgusealtpron",                                             \
+        ARG_BOOLEAN,                                            \
+        "yes",                                                  \
+        "Add alternate pronunciations to FSG"},                 \
+{ "-fsgusefiller",                                              \
+        ARG_BOOLEAN,                                            \
+        "yes",                                                  \
+        "Insert filler words at each state."}
+
+/** Command-line options for statistical language models. */
+#define POCKETSPHINX_NGRAM_OPTIONS \
+{ "-allphone",										\
+      ARG_STRING,									\
+      NULL,										\
+      "Perform phoneme decoding with phonetic lm" },					\
+{ "-allphone_ci",									\
+      ARG_BOOLEAN,									\
+      "no",										\
+      "Perform phoneme decoding with phonetic lm and context-independent units only" }, \
+{ "-lm",										\
+      ARG_STRING,									\
+      NULL,										\
+      "Word trigram language model input file" },					\
+{ "-lmctl",										\
+      ARG_STRING,									\
+      NULL,										\
+      "Specify a set of language model\n"},						\
+{ "-lmname",										\
+      ARG_STRING,									\
+      NULL,									\
+      "Which language model in -lmctl to use by default"},				\
+{ "-lw",										\
+      ARG_FLOAT32,									\
+      "6.5",										\
+      "Language model probability weight" },						\
+{ "-fwdflatlw",										\
+      ARG_FLOAT32,									\
+      "8.5",										\
+      "Language model probability weight for flat lexicon (2nd pass) decoding" },	\
+{ "-bestpathlw",									\
+      ARG_FLOAT32,									\
+      "9.5",										\
+      "Language model probability weight for bestpath search" },			\
+{ "-ascale",										\
+      ARG_FLOAT32,									\
+      "20.0",										\
+      "Inverse of acoustic model scale for confidence score calculation" },		\
+{ "-wip",										\
+      ARG_FLOAT32,									\
+      "0.65",										\
+      "Word insertion penalty" },							\
+{ "-nwpen",										\
+      ARG_FLOAT32,									\
+      "1.0",										\
+      "New word transition penalty" },							\
+{ "-pip",										\
+      ARG_FLOAT32,									\
+      "1.0",										\
+      "Phone insertion penalty" },							\
+{ "-uw",										\
+      ARG_FLOAT32,									\
+      "1.0",										\
+      "Unigram weight" }, 								\
+{ "-silprob",										\
+      ARG_FLOAT32,									\
+      "0.005",										\
+      "Silence word transition probability" },						\
+{ "-fillprob",										\
+      ARG_FLOAT32,									\
+      "1e-8",										\
+        "Filler word transition probability" } \
+
+/** Command-line options for dictionaries. */
+#define POCKETSPHINX_DICT_OPTIONS \
+    { "-dict",							\
+      REQARG_STRING,						\
+      NULL,							\
+      "Main pronunciation dictionary (lexicon) input file" },	\
+    { "-fdict",							\
+      ARG_STRING,						\
+      NULL,							\
+      "Noise word pronunciation dictionary input file" },	\
+    { "-dictcase",						\
+      ARG_BOOLEAN,						\
+      "no",							\
+      "Dictionary is case sensitive (NOTE: case insensitivity applies to ASCII characters only)" }	\
+
+/** Command-line options for acoustic modeling */
+#define POCKETSPHINX_ACMOD_OPTIONS \
+{ "-hmm",                                                                       \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "Directory containing acoustic model files."},                            \
+{ "-featparams",                                                                \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "File containing feature extraction parameters."},                        \
+{ "-mdef",                                                                      \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "Model definition input file" },                                          \
+{ "-senmgau", \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "Senone to codebook mapping input file (usually not needed)" }, \
+{ "-tmat",                                                                      \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "HMM state transition matrix input file" },                               \
+{ "-tmatfloor",                                                                 \
+      ARG_FLOAT32,                                                              \
+      "0.0001",                                                                 \
+      "HMM state transition probability floor (applied to -tmat file)" },       \
+{ "-mean",                                                                      \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "Mixture gaussian means input file" },                                    \
+{ "-var",                                                                       \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "Mixture gaussian variances input file" },                                \
+{ "-varfloor",                                                                  \
+      ARG_FLOAT32,                                                              \
+      "0.0001",                                                                 \
+      "Mixture gaussian variance floor (applied to data from -var file)" },     \
+{ "-mixw",                                                                      \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "Senone mixture weights input file (uncompressed)" },                     \
+{ "-mixwfloor",                                                                 \
+      ARG_FLOAT32,                                                              \
+      "0.0000001",                                                              \
+      "Senone mixture weights floor (applied to data from -mixw file)" },       \
+{ "-aw",                                                                \
+    ARG_INT32,                                                          \
+    "1", \
+        "Inverse weight applied to acoustic scores." },                 \
+{ "-sendump",                                                                   \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "Senone dump (compressed mixture weights) input file" },                  \
+{ "-mllr",                                                                      \
+      ARG_STRING,                                                               \
+      NULL,                                                                     \
+      "MLLR transformation to apply to means and variances" },                  \
+{ "-mmap",                                                                      \
+      ARG_BOOLEAN,                                                              \
+      "yes",                                                                    \
+      "Use memory-mapped I/O (if possible) for model files" },                  \
+{ "-ds",                                                                        \
+      ARG_INT32,                                                                \
+      "1",                                                                      \
+      "Frame GMM computation downsampling ratio" },                             \
+{ "-topn",                                                                      \
+      ARG_INT32,                                                                \
+      "4",                                                                      \
+      "Maximum number of top Gaussians to use in scoring." },                   \
+{ "-topn_beam",                                                                 \
+      ARG_STRING,                                                               \
+      "0",                                                                     \
+      "Beam width used to determine top-N Gaussians (or a list, per-feature)" },\
+{ "-logbase",                                                                   \
+      ARG_FLOAT32,                                                              \
+      "1.0001",                                                                 \
+      "Base in which all log-likelihoods calculated" }
+
+#define CMDLN_EMPTY_OPTION { NULL, 0, NULL, NULL }
+
+#endif /* __PS_CMDLN_MACRO_H__ */

new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/pocketsphinx-COPYING.txt
@@ -0,0 +1,36 @@
+/* ====================================================================
+ * Copyright (c) 1999-2015 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.
+ *
+ * ====================================================================
+ *
+ */
+ 

new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/pocketsphinx.h
@@ -0,0 +1,658 @@
+/* -*- c-basic-offset:4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1999-2008 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.
+ *
+ * ====================================================================
+ *
+ */
+/**
+ * @file pocketsphinx.h Main header file for the PocketSphinx decoder.
+ */
+
+#ifndef __POCKETSPHINX_H__
+#define __POCKETSPHINX_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if 0
+}
+#endif
+
+/* System headers we need. */
+#include <stdio.h>
+
+/* SphinxBase headers we need. */
+#include <sphinxbase/cmd_ln.h>
+#include <sphinxbase/logmath.h>
+#include <sphinxbase/fe.h>
+#include <sphinxbase/feat.h>
+
+/* PocketSphinx headers (not many of them!) */
+#include <pocketsphinx_export.h>
+#include <cmdln_macro.h>
+#include <ps_lattice.h>
+#include <ps_mllr.h>
+
+/**
+ * PocketSphinx speech recognizer object.
+ */
+typedef struct ps_decoder_s ps_decoder_t;
+
+#include <ps_search.h>
+
+/**
+ * PocketSphinx N-best hypothesis iterator object.
+ */
+typedef struct ps_astar_s ps_nbest_t;
+
+/**
+ * PocketSphinx segmentation iterator object.
+ */
+typedef struct ps_seg_s ps_seg_t;
+
+/**
+ * Sets default grammar and language model if they are not set explicitly and
+ * are present in the default search path.
+ */
+POCKETSPHINX_EXPORT void
+ps_default_search_args(cmd_ln_t *);
+
+/**
+ * Initialize the decoder from a configuration object.
+ *
+ * @note The decoder retains ownership of the pointer
+ * <code>config</code>, so you must not attempt to free it manually.
+ * If you wish to reuse it elsewhere, call cmd_ln_retain() on it.
+ *
+ * @param config a command-line structure, as created by
+ * cmd_ln_parse_r() or cmd_ln_parse_file_r().
+ */
+POCKETSPHINX_EXPORT
+ps_decoder_t *ps_init(cmd_ln_t *config);
+
+/**
+ * Reinitialize the decoder with updated configuration.
+ *
+ * This function allows you to switch the acoustic model, dictionary,
+ * or other configuration without creating an entirely new decoding
+ * object.
+ *
+ * @note The decoder retains ownership of the pointer
+ * <code>config</code>, so you must not attempt to free it manually.
+ * If you wish to reuse it elsewhere, call cmd_ln_retain() on it.
+ *
+ * @param ps Decoder.
+ * @param config An optional new configuration to use.  If this is
+ *               NULL, the previous configuration will be reloaded,
+ *               with any changes applied.
+ * @return 0 for success, <0 for failure.
+ */
+POCKETSPHINX_EXPORT
+int ps_reinit(ps_decoder_t *ps, cmd_ln_t *config);
+
+/**
+ * Returns the argument definitions used in ps_init().
+ *
+ * This is here to avoid exporting global data, which is problematic
+ * on Win32 and Symbian (and possibly other platforms).
+ */
+POCKETSPHINX_EXPORT
+arg_t const *ps_args(void);
+
+/**
+ * Retain a pointer to the decoder.
+ *
+ * This increments the reference count on the decoder, allowing it to
+ * be shared between multiple parent objects.  In general you will not
+ * need to use this function, ever.  It is mainly here for the
+ * convenience of scripting language bindings.
+ *
+ * @return pointer to retained decoder.
+ */
+POCKETSPHINX_EXPORT
+ps_decoder_t *ps_retain(ps_decoder_t *ps);
+
+/**
+ * Finalize the decoder.
+ *
+ * This releases all resources associated with the decoder, including
+ * any language models or grammars which have been added to it, and
+ * the initial configuration object passed to ps_init().
+ *
+ * @param ps Decoder to be freed.
+ * @return New reference count (0 if freed).
+ */
+POCKETSPHINX_EXPORT
+int ps_free(ps_decoder_t *ps);
+
+/**
+ * Get the configuration object for this decoder.
+ *
+ * @return The configuration object for this decoder.  The decoder
+ *         retains ownership of this pointer, so you should not
+ *         attempt to free it manually.  Use cmd_ln_retain() if you
+ *         wish to reuse it elsewhere.
+ */
+POCKETSPHINX_EXPORT
+cmd_ln_t *ps_get_config(ps_decoder_t *ps);
+
+/**
+ * Get the log-math computation object for this decoder.
+ *
+ * @return The log-math object for this decoder.  The decoder retains
+ *         ownership of this pointer, so you should not attempt to
+ *         free it manually.  Use logmath_retain() if you wish to
+ *         reuse it elsewhere.
+ */
+POCKETSPHINX_EXPORT
+logmath_t *ps_get_logmath(ps_decoder_t *ps);
+
+/**
+ * Get the feature extraction object for this decoder.
+ *
+ * @return The feature extraction object for this decoder.  The
+ *         decoder retains ownership of this pointer, so you should
+ *         not attempt to free it manually.  Use fe_retain() if you
+ *         wish to reuse it elsewhere.
+ */
+POCKETSPHINX_EXPORT
+fe_t *ps_get_fe(ps_decoder_t *ps);
+
+/**
+ * Get the dynamic feature computation object for this decoder.
+ *
+ * @return The dynamic feature computation object for this decoder.  The
+ *         decoder retains ownership of this pointer, so you should
+ *         not attempt to free it manually.  Use feat_retain() if you
+ *         wish to reuse it elsewhere.
+ */
+POCKETSPHINX_EXPORT
+feat_t *ps_get_feat(ps_decoder_t *ps);
+
+/**
+ * Adapt current acoustic model using a linear transform.
+ *
+ * @param mllr The new transform to use, or NULL to update the existing
+ *              transform.  The decoder retains ownership of this pointer,
+ *              so you should not attempt to free it manually.  Use
+ *              ps_mllr_retain() if you wish to reuse it
+ *              elsewhere.
+ * @return The updated transform object for this decoder, or
+ *         NULL on failure.
+ */
+POCKETSPHINX_EXPORT
+ps_mllr_t *ps_update_mllr(ps_decoder_t *ps, ps_mllr_t *mllr);
+
+/**
+ * Reload the pronunciation dictionary from a file.
+ *
+ * This function replaces the current pronunciation dictionary with
+ * the one stored in dictfile.  This also causes the active search
+ * module(s) to be reinitialized, in the same manner as calling
+ * ps_add_word() with update=TRUE.
+ *
+ * @param dictfile Path to dictionary file to load.
+ * @param fdictfile Path to filler dictionary to load, or NULL to keep
+ *                  the existing filler dictionary.
+ * @param format Format of the dictionary file, or NULL to determine
+ *               automatically (currently unused,should be NULL)
+ */
+POCKETSPHINX_EXPORT
+int ps_load_dict(ps_decoder_t *ps, char const *dictfile,
+                 char const *fdictfile, char const *format);
+
+/**
+ * Dump the current pronunciation dictionary to a file.
+ *
+ * This function dumps the current pronunciation dictionary to a tex
+ *
+ * @param dictfile Path to file where dictionary will be written.
+ * @param format Format of the dictionary file, or NULL for the
+ *               default (text) format (currently unused, should be NULL)
+ */
+POCKETSPHINX_EXPORT
+int ps_save_dict(ps_decoder_t *ps, char const *dictfile, char const *format);
+
+/**
+ * Add a word to the pronunciation dictionary.
+ *
+ * This function adds a word to the pronunciation dictionary and the
+ * current language model (but, obviously, not to the current FSG if
+ * FSG mode is enabled).  If the word is already present in one or the
+ * other, it does whatever is necessary to ensure that the word can be
+ * recognized.
+ *
+ * @param word Word string to add.
+ * @param phones Whitespace-separated list of phoneme strings
+ *               describing pronunciation of <code>word</code>.
+ * @param update If TRUE, update the search module (whichever one is
+ *               currently active) to recognize the newly added word.
+ *               If adding multiple words, it is more efficient to
+ *               pass FALSE here in all but the last word.
+ * @return The internal ID (>= 0) of the newly added word, or <0 on
+ *         failure.
+ */
+POCKETSPHINX_EXPORT
+int ps_add_word(ps_decoder_t *ps,
+                char const *word,
+                char const *phones,
+                int update);
+
+/** 
+ * Lookup for the word in the dictionary and return phone transcription
+ * for it.
+ *
+ * @param ps Pocketsphinx decoder
+ * @param word Word to look for
+ *
+ * @return Whitespace-spearated phone string describing the pronunciation of the <code>word</code>
+ *         or NULL if word is not present in the dictionary. The string is
+ *         allocated and must be freed by the user.
+ */
+POCKETSPHINX_EXPORT
+char *ps_lookup_word(ps_decoder_t *ps, 
+	             const char *word);
+
+/**
+ * Decode a raw audio stream.
+ *
+ * No headers are recognized in this files.  The configuration
+ * parameters <tt>-samprate</tt> and <tt>-input_endian</tt> are used
+ * to determine the sampling rate and endianness of the stream,
+ * respectively.  Audio is always assumed to be 16-bit signed PCM.
+ *
+ * @param ps Decoder.
+ * @param rawfh Previously opened file stream.
+ * @param maxsamps Maximum number of samples to read from rawfh, or -1
+ *                 to read until end-of-file.
+ * @return Number of samples of audio.
+ */
+POCKETSPHINX_EXPORT
+long ps_decode_raw(ps_decoder_t *ps, FILE *rawfh,
+                   long maxsamps);
+
+/**
+ * Decode a senone score dump file.
+ *
+ * @param ps Decoder
+ * @param fh Previously opened file handle positioned at start of file.
+ * @return Number of frames read.
+ */
+POCKETSPHINX_EXPORT
+int ps_decode_senscr(ps_decoder_t *ps, FILE *senfh);
+
+/**
+ * Start processing of the stream of speech. Channel parameters like
+ * noise-level are maintained for the stream and reused among utterances.
+ * Times returned in segment iterators are also stream-wide.
+ *
+ * @return 0 for success, <0 on error.
+ */
+POCKETSPHINX_EXPORT
+int ps_start_stream(ps_decoder_t *ps);
+
+/**
+ * Start utterance processing.
+ *
+ * This function should be called before any utterance data is passed
+ * to the decoder.  It marks the start of a new utterance and
+ * reinitializes internal data structures.
+ *
+ * @param ps Decoder to be started.
+ * @return 0 for success, <0 on error.
+ */
+POCKETSPHINX_EXPORT
+int ps_start_utt(ps_decoder_t *ps);
+
+/**
+ * Decode raw audio data.
+ *
+ * @param ps Decoder.
+ * @param no_search If non-zero, perform feature extraction but don't
+ *                  do any recognition yet.  This may be necessary if
+ *                  your processor has trouble doing recognition in
+ *                  real-time.
+ * @param full_utt If non-zero, this block of data is a full utterance
+ *                 worth of data.  This may allow the recognizer to
+ *                 produce more accurate results.
+ * @return Number of frames of data searched, or <0 for error.
+ */
+POCKETSPHINX_EXPORT
+int ps_process_raw(ps_decoder_t *ps,
+                   int16 const *data,
+                   size_t n_samples,
+                   int no_search,
+                   int full_utt);
+
+/**
+ * Decode acoustic feature data.
+ *
+ * @param ps Decoder.
+ * @param no_search If non-zero, perform feature extraction but don't
+ *                  do any recognition yet.  This may be necessary if
+ *                  your processor has trouble doing recognition in
+ *                  real-time.
+ * @param full_utt If non-zero, this block of data is a full utterance
+ *                 worth of data.  This may allow the recognizer to
+ *                 produce more accurate results.
+ * @return Number of frames of data searched, or <0 for error.
+ */
+POCKETSPHINX_EXPORT
+int ps_process_cep(ps_decoder_t *ps,
+                   mfcc_t **data,
+                   int n_frames,
+                   int no_search,
+                   int full_utt);
+
+/**
+ * Get the number of frames of data searched.
+ *
+ * Note that there is a delay between this and the number of frames of
+ * audio which have been input to the system.  This is due to the fact
+ * that acoustic features are computed using a sliding window of
+ * audio, and dynamic features are computed over a sliding window of
+ * acoustic features.
+ *
+ * @param ps Decoder.
+ * @return Number of frames of speech data which have been recognized
+ * so far.
+ */
+POCKETSPHINX_EXPORT
+int ps_get_n_frames(ps_decoder_t *ps);
+
+/**
+ * End utterance processing.
+ *
+ * @param ps Decoder.
+ * @return 0 for success, <0 on error
+ */
+POCKETSPHINX_EXPORT
+int ps_end_utt(ps_decoder_t *ps);
+
+/**
+ * Get hypothesis string and path score.
+ *
+ * @param ps Decoder.
+ * @param out_best_score Output: path score corresponding to returned string.
+ * @return String containing best hypothesis at this point in
+ *         decoding.  NULL if no hypothesis is available.
+ */
+POCKETSPHINX_EXPORT
+char const *ps_get_hyp(ps_decoder_t *ps, int32 *out_best_score);
+
+/**
+ * Get hypothesis string and final flag.
+ *
+ * @param ps Decoder.
+ * @param out_is_best_score Output: if hypothesis is reached final state in the grammar.
+ * @return String containing best hypothesis at this point in
+ *         decoding.  NULL if no hypothesis is available.
+ */
+POCKETSPHINX_EXPORT
+char const *ps_get_hyp_final(ps_decoder_t *ps, int32 *out_is_final);
+
+/**
+ * Get posterior probability.
+ *
+ * @note Unless the -bestpath option is enabled, this function will
+ * always return zero (corresponding to a posterior probability of
+ * 1.0).  Even if -bestpath is enabled, it will also return zero when
+ * called on a partial result.  Ongoing research into effective
+ * confidence annotation for partial hypotheses may result in these
+ * restrictions being lifted in future versions.
+ *
+ * @param ps Decoder.
+ * @return Posterior probability of the best hypothesis.
+ */
+POCKETSPHINX_EXPORT
+int32 ps_get_prob(ps_decoder_t *ps);
+
+/**
+ * Get word lattice.
+ *
+ * There isn't much you can do with this so far, a public API will
+ * appear in the future.
+ *
+ * @param ps Decoder.
+ * @return Word lattice object containing all hypotheses so far.  NULL
+ *         if no hypotheses are available.  This pointer is owned by
+ *         the decoder and you should not attempt to free it manually.
+ *         It is only valid until the next utterance, unless you use
+ *         ps_lattice_retain() to retain it.
+ */
+POCKETSPHINX_EXPORT
+ps_lattice_t *ps_get_lattice(ps_decoder_t *ps);
+
+/**
+ * Get an iterator over the word segmentation for the best hypothesis.
+ *
+ * @param ps Decoder.
+ * @param out_best_score Output: path score corresponding to hypothesis.
+ * @return Iterator over the best hypothesis at this point in
+ *         decoding.  NULL if no hypothesis is available.
+ */
+POCKETSPHINX_EXPORT
+ps_seg_t *ps_seg_iter(ps_decoder_t *ps, int32 *out_best_score);
+
+/**
+ * Get the next segment in a word segmentation.
+ *
+ * @param seg Segment iterator.
+ * @return Updated iterator with the next segment.  NULL at end of
+ *         utterance (the iterator will be freed in this case).
+ */
+POCKETSPHINX_EXPORT
+ps_seg_t *ps_seg_next(ps_seg_t *seg);
+
+/**
+ * Get word string from a segmentation iterator.
+ *
+ * @param seg Segment iterator.
+ * @return Read-only string giving string name of this segment.  This
+ * is only valid until the next call to ps_seg_next().
+ */
+POCKETSPHINX_EXPORT
+char const *ps_seg_word(ps_seg_t *seg);
+
+/**
+ * Get inclusive start and end frames from a segmentation iterator.
+ *
+ * @note These frame numbers are inclusive, i.e. the end frame refers
+ * to the last frame in which the given word or other segment was
+ * active.  Therefore, the actual duration is *out_ef - *out_sf + 1.
+ *
+ * @param seg Segment iterator.
+ * @param out_sf Output: First frame index in segment.
+ * @param out_sf Output: Last frame index in segment.
+ */
+POCKETSPHINX_EXPORT
+void ps_seg_frames(ps_seg_t *seg, int *out_sf, int *out_ef);
+
+/**
+ * Get language, acoustic, and posterior probabilities from a
+ * segmentation iterator.
+ *
+ * @note Unless the -bestpath option is enabled, this function will
+ * always return zero (corresponding to a posterior probability of
+ * 1.0).  Even if -bestpath is enabled, it will also return zero when
+ * called on a partial result.  Ongoing research into effective
+ * confidence annotation for partial hypotheses may result in these
+ * restrictions being lifted in future versions.
+ *
+ * @param out_ascr Output: acoustic model score for this segment.
+ * @param out_lscr Output: language model score for this segment.
+ * @param out_lback Output: language model backoff mode for this
+ *                  segment (i.e. the number of words used in
+ *                  calculating lscr).  This field is, of course, only
+ *                  meaningful for N-Gram models.
+ * @return Log posterior probability of current segment.  Log is
+ *         expressed in the log-base used in the decoder.  To convert
+ *         to linear floating-point, use logmath_exp(ps_get_logmath(),
+ *         pprob).
+ */
+POCKETSPHINX_EXPORT
+int32 ps_seg_prob(ps_seg_t *seg, int32 *out_ascr, int32 *out_lscr, int32 *out_lback);
+
+/**
+ * Finish iterating over a word segmentation early, freeing resources.
+ */
+POCKETSPHINX_EXPORT
+void ps_seg_free(ps_seg_t *seg);
+
+/**
+ * Get an iterator over the best hypotheses, optionally within a
+ * selected region of the utterance. Iterator is empty now, it must
+ * be advanced with ps_nbest_next first. The function may also
+ * return a NULL which means that there is no hypothesis available for this
+ * utterance.
+ *
+ * @param ps Decoder.
+ * @param sf Start frame for N-best search (0 for whole utterance) 
+ * @param ef End frame for N-best search (-1 for whole utterance) 
+ * @param ctx1 First word of trigram context (NULL for whole utterance)
+ * @param ctx2 First word of trigram context (NULL for whole utterance)
+ * @return Iterator over N-best hypotheses or NULL if no hypothesis is available
+ */
+POCKETSPHINX_EXPORT
+ps_nbest_t *ps_nbest(ps_decoder_t *ps, int sf, int ef,
+                     char const *ctx1, char const *ctx2);
+
+/**
+ * Move an N-best list iterator forward.
+ *
+ * @param nbest N-best iterator.
+ * @return Updated N-best iterator, or NULL if no more hypotheses are
+ *         available (iterator is freed ni this case).
+ */
+POCKETSPHINX_EXPORT 
+ps_nbest_t *ps_nbest_next(ps_nbest_t *nbest);
+
+/**
+ * Get the hypothesis string from an N-best list iterator.
+ *
+ * @param nbest N-best iterator.
+ * @param out_score Output: Path score for this hypothesis.
+ * @return String containing next best hypothesis.
+ */
+POCKETSPHINX_EXPORT
+char const *ps_nbest_hyp(ps_nbest_t *nbest, int32 *out_score);
+
+/**
+ * Get the word segmentation from an N-best list iterator.
+ *
+ * @param nbest N-best iterator.
+ * @param out_score Output: Path score for this hypothesis.
+ * @return Iterator over the next best hypothesis.
+ */
+POCKETSPHINX_EXPORT
+ps_seg_t *ps_nbest_seg(ps_nbest_t *nbest, int32 *out_score);
+
+/**
+ * Finish N-best search early, releasing resources.
+ *
+ * @param nbest N-best iterator.
+ */
+POCKETSPHINX_EXPORT
+void ps_nbest_free(ps_nbest_t *nbest);
+
+/**
+ * Get performance information for the current utterance.
+ *
+ * @param ps Decoder.
+ * @param out_nspeech Output: Number of seconds of speech.
+ * @param out_ncpu    Output: Number of seconds of CPU time used.
+ * @param out_nwall   Output: Number of seconds of wall time used.
+ */
+POCKETSPHINX_EXPORT
+void ps_get_utt_time(ps_decoder_t *ps, double *out_nspeech,
+                     double *out_ncpu, double *out_nwall);
+
+/**
+ * Get overall performance information.
+ *
+ * @param ps Decoder.
+ * @param out_nspeech Output: Number of seconds of speech.
+ * @param out_ncpu    Output: Number of seconds of CPU time used.
+ * @param out_nwall   Output: Number of seconds of wall time used.
+ */
+POCKETSPHINX_EXPORT
+void ps_get_all_time(ps_decoder_t *ps, double *out_nspeech,
+                     double *out_ncpu, double *out_nwall);
+
+/**
+ * Checks if the last feed audio buffer contained speech
+ *
+ * @param ps Decoder.
+ * @return 1 if last buffer contained speech, 0 - otherwise
+ */
+POCKETSPHINX_EXPORT
+uint8 ps_get_in_speech(ps_decoder_t *ps);
+
+
+/**
+ * Sets the limit of the raw audio data to store in decoder
+ * to retrieve it later on ps_get_rawdata.
+ *
+ * @param ps Decoder
+ * @param size bytes of the utterance to store
+ */
+POCKETSPHINX_EXPORT
+void ps_set_rawdata_size(ps_decoder_t *ps, int32 size);
+
+
+/**
+ * Retrieves the raw data collected during utterance decoding.
+ * 
+ * @param ps Decoder
+ * @param buffer preallocated buffer to store the data, must be within the limit
+ * set before
+ * @param size size of the data collected in samples (not bytes).
+ */
+POCKETSPHINX_EXPORT
+void ps_get_rawdata(ps_decoder_t *ps, int16 **buffer, int32 *size);
+
+/**
+ * @mainpage PocketSphinx API Documentation
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ * @version 0.6
+ * @date March, 2010
+ *
+ * @section intro_sec Introduction
+ *
+ * This is the API documentation for the PocketSphinx speech
+ * recognition engine.  The main API calls are documented in
+ * <pocketsphinx.h>.
+ */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* __POCKETSPHINX_H__ */

new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/pocketsphinx_export.h
@@ -0,0 +1,15 @@
+#ifndef __POCKETSPHINX_EXPORT_H__
+#define __POCKETSPHINX_EXPORT_H__
+
+/* Win32/WinCE DLL gunk */
+#if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(_WIN32_WP) && !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(__WINSCW__) && !defined(__SYMBIAN32__)
+#ifdef POCKETSPHINX_EXPORTS /* Visual Studio */
+#define POCKETSPHINX_EXPORT __declspec(dllexport)
+#else
+#define POCKETSPHINX_EXPORT __declspec(dllimport)
+#endif
+#else /* !_WIN32 */
+#define POCKETSPHINX_EXPORT
+#endif
+
+#endif /* __POCKETSPHINX_EXPORT_H__ */

new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/ps_lattice.h
@@ -0,0 +1,445 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 2008 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.
+ *
+ * ====================================================================
+ *
+ */
+
+/**
+ * @file ps_lattice.h Word graph search
+ */
+
+#ifndef __PS_LATTICE_H__
+#define __PS_LATTICE_H__
+
+/* SphinxBase headers. */
+#include <sphinxbase/prim_type.h>
+#include <sphinxbase/ngram_model.h>
+
+/* PocketSphinx headers. */
+#include <pocketsphinx_export.h>
+
+/**
+ * Word graph structure used in bestpath/nbest search.
+ */
+typedef struct ps_lattice_s ps_lattice_t;
+
+/**
+ * DAG nodes.
+ *
+ * A node corresponds to a number of hypothesized instances of a word
+ * which all share the same starting point.
+ */
+typedef struct ps_latnode_s ps_latnode_t;
+
+/**
+ * Iterator over DAG nodes.
+ */
+typedef struct ps_latnode_s ps_latnode_iter_t; /* pay no attention to the man behind the curtain */
+
+/**
+ * Links between DAG nodes.
+ *
+ * A link corresponds to a single hypothesized instance of a word with
+ * a given start and end point.
+ */
+typedef struct ps_latlink_s ps_latlink_t;
+
+/**
+ * Iterator over DAG links.
+ */
+typedef struct latlink_list_s ps_latlink_iter_t;
+
+/* Forward declaration needed to avoid circular includes */
+struct ps_decoder_s;
+
+/**
+ * Read a lattice from a file on disk.
+ *
+ * @param ps Decoder to use for processing this lattice, or NULL.
+ * @param file Path to lattice file.
+ * @return Newly created lattice, or NULL for failure.
+ */
+POCKETSPHINX_EXPORT
+ps_lattice_t *ps_lattice_read(struct ps_decoder_s *ps,
+                              char const *file);
+
+/**
+ * Retain a lattice.
+ *
+ * This function retains ownership of a lattice for the caller,
+ * preventing it from being freed automatically.  You must call
+ * ps_lattice_free() to free it after having called this function.
+ *
+ * @return pointer to the retained lattice.
+ */
+POCKETSPHINX_EXPORT
+ps_lattice_t *ps_lattice_retain(ps_lattice_t *dag);
+
+/**
+ * Free a lattice.
+ *
+ * @return new reference count (0 if dag was freed)
+ */
+POCKETSPHINX_EXPORT
+int ps_lattice_free(ps_lattice_t *dag);
+
+/**
+ * Write a lattice to disk.
+ *
+ * @return 0 for success, <0 on failure.
+ */
+POCKETSPHINX_EXPORT
+int ps_lattice_write(ps_lattice_t *dag, char const *filename);
+
+/**
+ * Write a lattice to disk in HTK format
+ *
+ * @return 0 for success, <0 on failure.
+ */
+POCKETSPHINX_EXPORT
+int ps_lattice_write_htk(ps_lattice_t *dag, char const *filename);
+
+/**
+ * Get the log-math computation object for this lattice
+ *
+ * @return The log-math object for this lattice.  The lattice retains
+ *         ownership of this pointer, so you should not attempt to
+ *         free it manually.  Use logmath_retain() if you wish to
+ *         reuse it elsewhere.
+ */
+POCKETSPHINX_EXPORT
+logmath_t *ps_lattice_get_logmath(ps_lattice_t *dag);
+
+
+/**
+ * Start iterating over nodes in the lattice.
+ *
+ * @note No particular order of traversal is guaranteed, and you
+ * should not depend on this.
+ *
+ * @param dag Lattice to iterate over.
+ * @return Iterator over lattice nodes.
+ */
+POCKETSPHINX_EXPORT
+ps_latnode_iter_t *ps_latnode_iter(ps_lattice_t *dag);
+
+/**
+ * Move to next node in iteration.
+ * @param itor Node iterator.
+ * @return Updated node iterator, or NULL if finished
+ */
+POCKETSPHINX_EXPORT
+ps_latnode_iter_t *ps_latnode_iter_next(ps_latnode_iter_t *itor);
+
+/**
+ * Stop iterating over nodes.
+ * @param itor Node iterator.
+ */
+POCKETSPHINX_EXPORT
+void ps_latnode_iter_free(ps_latnode_iter_t *itor);
+
+/**
+ * Get node from iterator.
+ */
+POCKETSPHINX_EXPORT
+ps_latnode_t *ps_latnode_iter_node(ps_latnode_iter_t *itor);
+
+/**
+ * Get start and end time range for a node.
+ *
+ * @param node Node inquired about.
+ * @param out_fef Output: End frame of first exit from this node.
+ * @param out_lef Output: End frame of last exit from this node.
+ * @return Start frame for all edges exiting this node.
+ */
+POCKETSPHINX_EXPORT
+int ps_latnode_times(ps_latnode_t *node, int16 *out_fef, int16 *out_lef);
+
+/**
+ * Get word string for this node.
+ *
+ * @param dag Lattice to which node belongs.
+ * @param node Node inquired about.
+ * @return Word string for this node (possibly a pronunciation variant).
+ */
+POCKETSPHINX_EXPORT
+char const *ps_latnode_word(ps_lattice_t *dag, ps_latnode_t *node);
+
+/**
+ * Get base word string for this node.
+ *
+ * @param dag Lattice to which node belongs.
+ * @param node Node inquired about.
+ * @return Base word string for this node.
+ */
+POCKETSPHINX_EXPORT
+char const *ps_latnode_baseword(ps_lattice_t *dag, ps_latnode_t *node);
+
+/**
+ * Iterate over exits from this node.
+ *
+ * @param node Node inquired about.
+ * @return Iterator over exit links from this node.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_iter_t *ps_latnode_exits(ps_latnode_t *node);
+
+/**
+ * Iterate over entries to this node.
+ *
+ * @param node Node inquired about.
+ * @return Iterator over entry links to this node.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_iter_t *ps_latnode_entries(ps_latnode_t *node);
+
+/**
+ * Get best posterior probability and associated acoustic score from a lattice node.
+ *
+ * @param dag Lattice to which node belongs.
+ * @param node Node inquired about.
+ * @param out_link Output: exit link with highest posterior probability
+ * @return Posterior probability of the best link exiting this node.
+ *         Log is expressed in the log-base used in the decoder.  To
+ *         convert to linear floating-point, use
+ *         logmath_exp(ps_lattice_get_logmath(), pprob).
+ */
+POCKETSPHINX_EXPORT
+int32 ps_latnode_prob(ps_lattice_t *dag, ps_latnode_t *node,
+                      ps_latlink_t **out_link);
+
+/**
+ * Get next link from a lattice link iterator.
+ *
+ * @param itor Iterator.
+ * @return Updated iterator, or NULL if finished.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_iter_t *ps_latlink_iter_next(ps_latlink_iter_t *itor);
+
+/**
+ * Stop iterating over links.
+ * @param itor Link iterator.
+ */
+POCKETSPHINX_EXPORT
+void ps_latlink_iter_free(ps_latlink_iter_t *itor);
+
+/**
+ * Get link from iterator.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_t *ps_latlink_iter_link(ps_latlink_iter_t *itor);
+
+/**
+ * Get start and end times from a lattice link.
+ *
+ * @note these are <strong>inclusive</strong> - i.e. the last frame of
+ * this word is ef, not ef-1.
+ *
+ * @param link Link inquired about.
+ * @param out_sf Output: (optional) start frame of this link.
+ * @return End frame of this link.
+ */
+POCKETSPHINX_EXPORT
+int ps_latlink_times(ps_latlink_t *link, int16 *out_sf);
+
+/**
+ * Get destination and source nodes from a lattice link
+ *
+ * @param link Link inquired about
+ * @param out_src Output: (optional) source node.
+ * @return destination node
+ */
+POCKETSPHINX_EXPORT
+ps_latnode_t *ps_latlink_nodes(ps_latlink_t *link, ps_latnode_t **out_src);
+
+/**
+ * Get word string from a lattice link.
+ *
+ * @param dag Lattice to which node belongs.
+ * @param link Link inquired about
+ * @return Word string for this link (possibly a pronunciation variant).
+ */
+POCKETSPHINX_EXPORT
+char const *ps_latlink_word(ps_lattice_t *dag, ps_latlink_t *link);
+
+/**
+ * Get base word string from a lattice link.
+ *
+ * @param dag Lattice to which node belongs.
+ * @param link Link inquired about
+ * @return Base word string for this link
+ */
+POCKETSPHINX_EXPORT
+char const *ps_latlink_baseword(ps_lattice_t *dag, ps_latlink_t *link);
+
+/**
+ * Get predecessor link in best path.
+ *
+ * @param link Link inquired about
+ * @return Best previous link from bestpath search, if any.  Otherwise NULL
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_t *ps_latlink_pred(ps_latlink_t *link);
+
+/**
+ * Get acoustic score and posterior probability from a lattice link.
+ *
+ * @param dag Lattice to which node belongs.
+ * @param link Link inquired about
+ * @param out_ascr Output: (optional) acoustic score.
+ * @return Posterior probability for this link.  Log is expressed in
+ *         the log-base used in the decoder.  To convert to linear
+ *         floating-point, use logmath_exp(ps_lattice_get_logmath(), pprob).
+ */
+POCKETSPHINX_EXPORT
+int32 ps_latlink_prob(ps_lattice_t *dag, ps_latlink_t *link, int32 *out_ascr);
+
+/**
+ * Create a directed link between "from" and "to" nodes, but if a link already exists,
+ * choose one with the best link_scr.
+ */
+POCKETSPHINX_EXPORT
+void ps_lattice_link(ps_lattice_t *dag, ps_latnode_t *from, ps_latnode_t *to,
+                     int32 score, int32 ef);
+
+/**
+ * Start a forward traversal of edges in a word graph.
+ *
+ * @note A keen eye will notice an inconsistency in this API versus
+ * other types of iterators in PocketSphinx.  The reason for this is
+ * that the traversal algorithm is much more efficient when it is able
+ * to modify the lattice structure.  Therefore, to avoid giving the
+ * impression that multiple traversals are possible at once, no
+ * separate iterator structure is provided.
+ *
+ * @param dag Lattice to be traversed.
+ * @param start Start node (source) of traversal.
+ * @param end End node (goal) of traversal.
+ * @return First link in traversal.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_t *ps_lattice_traverse_edges(ps_lattice_t *dag, ps_latnode_t *start, ps_latnode_t *end);
+
+/**
+ * Get the next link in forward traversal.
+ *
+ * @param dag Lattice to be traversed.
+ * @param end End node (goal) of traversal.
+ * @return Next link in traversal.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_t *ps_lattice_traverse_next(ps_lattice_t *dag, ps_latnode_t *end);
+
+/**
+ * Start a reverse traversal of edges in a word graph.
+ *
+ * @note See ps_lattice_traverse_edges() for why this API is the way it is.
+ *
+ * @param dag Lattice to be traversed.
+ * @param start Start node (goal) of traversal.
+ * @param end End node (source) of traversal.
+ * @return First link in traversal.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_t *ps_lattice_reverse_edges(ps_lattice_t *dag, ps_latnode_t *start, ps_latnode_t *end);
+
+/**
+ * Get the next link in reverse traversal.
+ *
+ * @param dag Lattice to be traversed.
+ * @param start Start node (goal) of traversal.
+ * @return Next link in traversal.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_t *ps_lattice_reverse_next(ps_lattice_t *dag, ps_latnode_t *start);
+
+/**
+ * Do N-Gram based best-path search on a word graph.
+ *
+ * This function calculates both the best path as well as the forward
+ * probability used in confidence estimation.
+ *
+ * @return Final link in best path, NULL on error.
+ */
+POCKETSPHINX_EXPORT
+ps_latlink_t *ps_lattice_bestpath(ps_lattice_t *dag, ngram_model_t *lmset,
+                                  float32 lwf, float32 ascale);
+
+/**
+ * Calculate link posterior probabilities on a word graph.
+ *
+ * This function assumes that bestpath search has already been done.
+ *
+ * @return Posterior probability of the utterance as a whole.
+ */
+POCKETSPHINX_EXPORT
+int32 ps_lattice_posterior(ps_lattice_t *dag, ngram_model_t *lmset,
+                           float32 ascale);
+
+/**
+ * Prune all links (and associated nodes) below a certain posterior probability.
+ *
+ * This function assumes that ps_lattice_posterior() has already been called.
+ *
+ * @param beam Minimum posterior probability for links. This is
+ *         expressed in the log-base used in the decoder.  To convert
+ *         from linear floating-point, use
+ *         logmath_log(ps_lattice_get_logmath(), prob).
+ * @return number of arcs removed.
+ */
+POCKETSPHINX_EXPORT
+int32 ps_lattice_posterior_prune(ps_lattice_t *dag, int32 beam);
+
+#ifdef NOT_IMPLEMENTED_YET
+/**
+ * Expand lattice using an N-gram language model.
+ *
+ * This function expands the lattice such that each node represents a
+ * unique N-gram history, and adds language model scores to the links.
+ */
+POCKETSPHINX_EXPORT
+int32 ps_lattice_ngram_expand(ps_lattice_t *dag, ngram_model_t *lm);
+#endif
+
+/**
+ * Get the number of frames in the lattice.
+ *
+ * @param dag The lattice in question.
+ * @return Number of frames in this lattice.
+ */
+POCKETSPHINX_EXPORT
+int ps_lattice_n_frames(ps_lattice_t *dag);
+
+#endif /* __PS_LATTICE_H__ */

new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/ps_mllr.h
@@ -0,0 +1,75 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 2008 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.
+ *
+ * ====================================================================
+ *
+ */
+
+/**
+ * @file ps_mllr.h Model-space linear transforms for speaker adaptation
+ */
+
+#ifndef __PS_MLLR_H__
+#define __PS_MLLR_H__
+
+/* SphinxBase headers. */
+#include <sphinxbase/prim_type.h>
+#include <sphinxbase/ngram_model.h>
+
+/* PocketSphinx headers. */
+#include <pocketsphinx_export.h>
+
+/**
+ * Feature space linear transform object.
+ */
+typedef struct ps_mllr_s ps_mllr_t;
+
+/**
+ * Read a speaker-adaptive linear transform from a file.
+ */
+POCKETSPHINX_EXPORT
+ps_mllr_t *ps_mllr_read(char const *file);
+
+/**
+ * Retain a pointer to a linear transform.
+ */
+POCKETSPHINX_EXPORT
+ps_mllr_t *ps_mllr_retain(ps_mllr_t *mllr);
+
+/**
+ * Release a pointer to a linear transform.
+ */
+POCKETSPHINX_EXPORT
+int ps_mllr_free(ps_mllr_t *mllr);
+
+#endif /* __PS_MLLR_H__ */

new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/ps_search.h
@@ -0,0 +1,296 @@
+/* -*- c-basic-offset:4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 2014 Alpha Cephei Inc..  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 ALPHA CEPHEI INC. ``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.
+ *
+ * ====================================================================
+ *
+ */
+/**
+ * @file ps_search.h User can configure several "search" objects with
+ * different grammars and langauge models and switch them in runtime to
+ * provide interactive experience for the user.
+ *
+ * There are different possible search modes:
+ * 
+ * <ul>
+ * <li>keyword - efficiently looks for keyphrase and ignores other speech. allows to configure detection threshold.</li>
+ * <li>grammar - recognizes speech according to JSGF grammar. Unlike keyphrase grammar search doesn't ignore words which are not in grammar but tries to recognize them.</li>
+ * <li>ngram/lm - recognizes natural speech with a language model.</li>
+ * <li>allphone - recognizes phonemes with a phonetic language model.</li>
+ * </ul>
+ * 
+ * Each search has a name and can be referenced by a name, names are
+ * application-specific. The function ps_set_search allows to activate
+ * the search previously added by a name. 
+ *
+ * To add the search one needs to point to the grammar/language model
+ * describing the search. The location of the grammar is specific to the
+ * application.
+ * 
+ * The exact design of a searches depends on your application. For
+ * example, you might want to listen for activation keyword first and once
+ * keyword is recognized switch to ngram search to recognize actual
+ * command. Once you recognized the command you can switch to grammar
+ * search to recognize the confirmation and then switch back to keyword listening
+ * mode to wait for another command.
+ *
+ * If only a simple recognition is required it is sufficient to add a single search or
+ * just configure the required mode with configuration options.
+ */
+
+#ifndef __PS_SEARCH_H__
+#define __PS_SEARCH_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sphinxbase/fsg_model.h>
+#include <sphinxbase/ngram_model.h>
+
+/**
+ * PocketSphinx search iterator.
+ */
+typedef struct ps_search_iter_s ps_search_iter_t;
+
+
+/**
+ * Actives search with the provided name.
+ *
+ * Activates search with the provided name. The search must be added before
+ * using either ps_set_fsg(), ps_set_lm() or ps_set_kws().
+ *
+ * @return 0 on success, 1 on failure
+ */
+POCKETSPHINX_EXPORT
+int ps_set_search(ps_decoder_t *ps, const char *name);
+
+/**
+ * Returns name of curent search in decoder
+ *
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT 
+const char* ps_get_search(ps_decoder_t *ps);
+
+/**
+ * Unsets the search and releases related resources.
+ *
+ * Unsets the search previously added with
+ * using either ps_set_fsg(), ps_set_lm() or ps_set_kws().
+ *
+ * @see ps_set_fsg
+ * @see ps_set_lm
+ * @see ps_set_kws
+ */
+POCKETSPHINX_EXPORT
+int ps_unset_search(ps_decoder_t *ps, const char *name);
+
+/**
+ * Returns iterator over current searches 
+ *
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT
+ps_search_iter_t *ps_search_iter(ps_decoder_t *ps);
+
+/**
+ * Updates search iterator to point to the next position.
+ * 
+ * This function automatically frees the iterator object upon reaching
+ * the final entry.
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT
+ps_search_iter_t *ps_search_iter_next(ps_search_iter_t *itor);
+
+/**
+ * Retrieves the name of the search the iterator points to.
+ *
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT
+const char* ps_search_iter_val(ps_search_iter_t *itor);
+
+/**
+ * Delete an unfinished search iterator
+ *
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT
+void ps_search_iter_free(ps_search_iter_t *itor);
+
+/**
+ * Updates search iterator to point to the next position.
+ * 
+ * This function automatically frees the iterator object upon reaching
+ * the final entry.
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT
+const char* ps_search_iter_val(ps_search_iter_t *itor);
+
+
+/**
+ * Get the language model set object for this decoder.
+ *
+ * If N-Gram decoding is not enabled, this will return NULL.  You will
+ * need to enable it using ps_set_lmset().
+ *
+ * @return The language model set object for this decoder.  The
+ *         decoder retains ownership of this pointer, so you should
+ *         not attempt to free it manually.  Use ngram_model_retain()
+ *         if you wish to reuse it elsewhere.
+ */
+POCKETSPHINX_EXPORT 
+ngram_model_t *ps_get_lm(ps_decoder_t *ps, const char *name);
+
+/**
+ * Adds new search based on N-gram language model.
+ *
+ * Associates N-gram search with the provided name. The search can be activated
+ * using ps_set_search().
+ *
+ * @see ps_set_search.
+ */ 
+POCKETSPHINX_EXPORT
+int ps_set_lm(ps_decoder_t *ps, const char *name, ngram_model_t *lm);
+
+/**
+ * Adds new search based on N-gram language model.
+ *
+ * Convenient method to load N-gram model and create a search.
+ * 
+ * @see ps_set_lm
+ */
+POCKETSPHINX_EXPORT
+int ps_set_lm_file(ps_decoder_t *ps, const char *name, const char *path);
+
+/**
+ * Get the finite-state grammar set object for this decoder.
+ *
+ * If FSG decoding is not enabled, this returns NULL.  Call
+ * ps_set_fsgset() to enable it.
+ *
+ * @return The current FSG set object for this decoder, or
+ *         NULL if none is available.
+ */
+POCKETSPHINX_EXPORT
+fsg_model_t *ps_get_fsg(ps_decoder_t *ps, const char *name);
+
+/**
+ * Adds new search based on finite state grammar.
+ *
+ * Associates FSG search with the provided name. The search can be activated
+ * using ps_set_search().
+ *
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT
+int ps_set_fsg(ps_decoder_t *ps, const char *name, fsg_model_t *fsg);
+
+/**
+ * Adds new search using JSGF model.
+ *
+ * Convenient method to load JSGF model and create a search.
+ *
+ * @see ps_set_fsg
+ */
+POCKETSPHINX_EXPORT
+int ps_set_jsgf_file(ps_decoder_t *ps, const char *name, const char *path);
+
+/**
+ * Adds new search using JSGF model.
+ *
+ * Convenience method to parse JSGF model from string and create a search.
+ *
+ * @see ps_set_fsg
+ */
+POCKETSPHINX_EXPORT
+int ps_set_jsgf_string(ps_decoder_t *ps, const char *name, const char *jsgf_string);
+
+/**
+ * Get the current Key phrase to spot
+ *
+ * If KWS is not enabled, this returns NULL. Call
+ * ps_update_kws() to enable it.
+ *
+ * @return The current keyphrase to spot
+ */
+POCKETSPHINX_EXPORT 
+const char* ps_get_kws(ps_decoder_t *ps, const char *name);
+
+/**
+ * Adds keywords from a file to spotting
+ *
+ * Associates KWS search with the provided name. The search can be activated
+ * using ps_set_search().
+ *
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT 
+int ps_set_kws(ps_decoder_t *ps, const char *name, const char *keyfile);
+
+/**
+ * Adds new keyword to spot
+ *
+ * Associates KWS search with the provided name. The search can be activated
+ * using ps_set_search().
+ *
+ * @see ps_set_search
+ */
+POCKETSPHINX_EXPORT 
+int ps_set_keyphrase(ps_decoder_t *ps, const char *name, const char *keyphrase);
+
+/**
+ * Adds new search based on phone N-gram language model.
+ *
+ * Associates N-gram search with the provided name. The search can be activated
+ * using ps_set_search().
+ *
+ * @see ps_set_search.
+ */ 
+POCKETSPHINX_EXPORT
+int ps_set_allphone(ps_decoder_t *ps, const char *name, ngram_model_t *lm);
+
+/**
+ * Adds new search based on phone N-gram language model.
+ *
+ * Convenient method to load N-gram model and create a search.
+ * 
+ * @see ps_set_allphone
+ */
+POCKETSPHINX_EXPORT
+int ps_set_allphone_file(ps_decoder_t *ps, const char *name, const char *path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __PS_SEARCH_H__ */

new file mode 100644
--- /dev/null
+++ b/media/pocketsphinx/src/acmod.c
@@ -0,0 +1,1377 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 2008 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.
+ *
+ * ====================================================================
+ *
+ */
+
+
+/**
+ * @file acmod.c Acoustic model structures for PocketSphinx.
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+/* System headers. */
+#include <assert.h>
+#include <string.h>
+#include <math.h>
+
+/* SphinxBase headers. */
+#include <sphinxbase/prim_type.h>
+#include <sphinxbase/err.h>
+#include <sphinxbase/cmd_ln.h>
+#include <sphinxbase/strfuncs.h>
+#include <sphinxbase/byteorder.h>
+#include <sphinxbase/feat.h>
+#include <sphinxbase/bio.h>
+
+/* Local headers. */
+#include "cmdln_macro.h"
+#include "acmod.h"
+#include "s2_semi_mgau.h"
+#include "ptm_mgau.h"
+#include "ms_mgau.h"
+
+/* Feature and front-end parameters that may be in feat.params */
+static const arg_t feat_defn[] = {
+    waveform_to_cepstral_command_line_macro(),
+    cepstral_to_feature_command_line_macro(),
+    CMDLN_EMPTY_OPTION
+};
+
+#ifndef WORDS_BIGENDIAN
+#define WORDS_BIGENDIAN 1
+#endif
+
+static int32 acmod_process_mfcbuf(acmod_t *acmod);
+
+static int
+acmod_init_am(acmod_t *acmod)
+{
+    char const *mdeffn, *tmatfn, *mllrfn, *hmmdir;
+
+    /* Read model definition. */
+    if ((mdeffn = cmd_ln_str_r(acmod->config, "-mdef")) == NULL) {
+        if ((hmmdir = cmd_ln_str_r(acmod->config, "-hmm")) == NULL)
+            E_ERROR("Acoustic model definition is not specified either "
+                    "with -mdef option or with -hmm\n");
+        else
+            E_ERROR("Folder '%s' does not contain acoustic model "
+                    "definition 'mdef'\n", hmmdir);
+
+        return -1;
+    }
+
+    if ((acmod->mdef = bin_mdef_read(acmod->config, mdeffn)) == NULL) {
+        E_ERROR("Failed to read acoustic model definition from %s\n", mdeffn);
+        return -1;
+    }
+
+    /* Read transition matrices. */
+    if ((tmatfn = cmd_ln_str_r(acmod->config, "-tmat")) == NULL) {
+        E_ERROR("No tmat file specified\n");
+        return -1;
+    }
+    acmod->tmat = tmat_init(tmatfn, acmod->lmath,
+                            cmd_ln_float32_r(acmod->config, "-tmatfloor"),
+                            TRUE);
+
+    /* Read the acoustic models. */
+    if ((cmd_ln_str_r(acmod->config, "-mean") == NULL)
+        || (cmd_ln_str_r(acmod->config, "-var") == NULL)
+        || (cmd_ln_str_r(acmod->config, "-tmat") == NULL)) {
+        E_ERROR("No mean/var/tmat files specified\n");
+        return -1;
+    }
+
+    if (cmd_ln_str_r(acmod->config, "-senmgau")) {
+        E_INFO("Using general multi-stream GMM computation\n");
+        acmod->mgau = ms_mgau_init(acmod, acmod->lmath, acmod->mdef);
+        if (acmod->mgau == NULL)
+            return -1;
+    }
+    else {
+        E_INFO("Attempting to use PTM computation module\n");
+        if ((acmod->mgau = ptm_mgau_init(acmod, acmod->mdef)) == NULL) {
+            E_INFO("Attempting to use semi-continuous computation module\n");
+            if ((acmod->mgau = s2_semi_mgau_init(acmod)) == NULL) {
+                E_INFO("Falling back to general multi-stream GMM computation\n");
+                acmod->mgau = ms_mgau_init(acmod, acmod->lmath, acmod->mdef);
+                if (acmod->mgau == NULL)
+                    return -1;
+            }
+        }
+    }
+
+    /* If there is an MLLR transform, apply it. */
+    if ((mllrfn = cmd_ln_str_r(acmod->config, "-mllr"))) {
+        ps_mllr_t *mllr = ps_mllr_read(mllrfn);
+        if (mllr == NULL)
+            return -1;
+        acmod_update_mllr(acmod, mllr);
+    }
+
+    return 0;
+}
+
+static int
+acmod_init_feat(acmod_t *acmod)
+{
+    acmod->fcb =
+        feat_init(cmd_ln_str_r(acmod->config, "-feat"),
+                  cmn_type_from_str(cmd_ln_str_r(acmod->config,"-cmn")),
+                  cmd_ln_boolean_r(acmod->config, "-varnorm"),
+                  agc_type_from_str(cmd_ln_str_r(acmod->config, "-agc")),
+                  1, cmd_ln_int32_r(acmod->config, "-ceplen"));
+    if (acmod->fcb == NULL)
+        return -1;
+
+    if (cmd_ln_str_r(acmod->config, "-lda")) {
+        E_INFO("Reading linear feature transformation from %s\n",
+               cmd_ln_str_r(acmod->config, "-lda"));
+        if (feat_read_lda(acmod->fcb,
+                          cmd_ln_str_r(acmod->config, "-lda"),
+                          cmd_ln_int32_r(acmod->config, "-ldadim")) < 0)
+            return -1;
+    }
+
+    if (cmd_ln_str_r(acmod->config, "-svspec")) {
+        int32 **subvecs;
+        E_INFO("Using subvector specification %s\n",
+               cmd_ln_str_r(acmod->config, "-svspec"));
+        if ((subvecs = parse_subvecs(cmd_ln_str_r(acmod->config, "-svspec"))) == NULL)
+            return -1;
+        if ((feat_set_subvecs(acmod->fcb, subvecs)) < 0)
+            return -1;
+    }
+
+    if (cmd_ln_exists_r(acmod->config, "-agcthresh")
+        && 0 != strcmp(cmd_ln_str_r(acmod->config, "-agc"), "none")) {
+        agc_set_threshold(acmod->fcb->agc_struct,
+                          cmd_ln_float32_r(acmod->config, "-agcthresh"));
+    }
+
+    if (acmod->fcb->cmn_struct
+        && cmd_ln_exists_r(acmod->config, "-cmninit")) {
+        char *c, *cc, *vallist;
+        int32 nvals;
+
+        vallist = ckd_salloc(cmd_ln_str_r(acmod->config, "-cmninit"));
+        c = vallist;
+        nvals = 0;
+        while (nvals < acmod->fcb->cmn_struct->veclen
+               && (cc = strchr(c, ',')) != NULL) {
+            *cc = '\0';
+            acmod->fcb->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof_c(c));
+            c = cc + 1;
+            ++nvals;
+        }
+        if (nvals < acmod->fcb->cmn_struct->veclen && *c != '\0') {
+            acmod->fcb->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof_c(c));
+        }
+        ckd_free(vallist);
+    }
+    return 0;
+}
+
+int
+acmod_fe_mismatch(acmod_t *acmod, fe_t *fe)
+{
+    /* Output vector dimension needs to be the same. */
+    if (cmd_ln_int32_r(acmod->config, "-ceplen") != fe_get_output_size(fe)) {
+        E_ERROR("Configured feature length %d doesn't match feature "
+                "extraction output size %d\n",
+                cmd_ln_int32_r(acmod->config, "-ceplen"),
+                fe_get_output_size(fe));
+        return TRUE;
+    }
+    /* Feature parameters need to be the same. */
+    /* ... */
+    return FALSE;
+}
+
+int
+acmod_feat_mismatch(acmod_t *acmod, feat_t *fcb)
+{
+    /* Feature type needs to be the same. */
+    if (0 != strcmp(cmd_ln_str_r(acmod->config, "-feat"), feat_name(fcb)))
+        return TRUE;
+    /* Input vector dimension needs to be the same. */
+    if (cmd_ln_int32_r(acmod->config, "-ceplen") != feat_cepsize(fcb))
+        return TRUE;
+    /* FIXME: Need to check LDA and stuff too. */
+    return FALSE;
+}
+
+acmod_t *
+acmod_init(cmd_ln_t *config, logmath_t *lmath, fe_t *fe, feat_t *fcb)
+{
+    acmod_t *acmod;
+    char const *featparams;
+
+    acmod = ckd_calloc(1, sizeof(*acmod));
+    acmod->config = cmd_ln_retain(config);
+    acmod->lmath = lmath;
+    acmod->state = ACMOD_IDLE;
+
+    /* Look for feat.params in acoustic model dir. */
+    if ((featparams = cmd_ln_str_r(acmod->config, "-featparams"))) {
+        if (NULL !=
+            cmd_ln_parse_file_r(acmod->config, feat_defn, featparams, FALSE))
+            E_INFO("Parsed model-specific feature parameters from %s\n",
+                    featparams);
+    }
+
+    /* Initialize feature computation. */
+    if (fe) {
+        if (acmod_fe_mismatch(acmod, fe))
+            goto error_out;
+        fe_retain(fe);
+        acmod->fe = fe;
+    }
+    else {
+        /* Initialize a new front end. */
+        acmod->fe = fe_init_auto_r(config);
+        if (acmod->fe == NULL)
+            goto error_out;
+        if (acmod_fe_mismatch(acmod, acmod->fe))
+            goto error_out;
+    }
+    if (fcb) {
+        if (acmod_feat_mismatch(acmod, fcb))
+            goto error_out;
+        feat_retain(fcb);
+        acmod->fcb = fcb;
+    }
+    else {
+        /* Initialize a new fcb. */
+        if (acmod_init_feat(acmod) < 0)
+            goto error_out;
+    }
+
+    /* Load acoustic model parameters. */
+    if (acmod_init_am(acmod) < 0)
+        goto error_out;
+
+
+    /* The MFCC buffer needs to be at least as large as the dynamic
+     * feature window.  */
+    acmod->n_mfc_alloc = acmod->fcb->window_size * 2 + 1;
+    acmod->mfc_buf = (mfcc_t **)
+        ckd_calloc_2d(acmod->n_mfc_alloc, acmod->fcb->cepsize,
+                      sizeof(**acmod->mfc_buf));
+
+    /* Feature buffer has to be at least as large as MFCC buffer. */
+    acmod->n_feat_alloc = acmod->n_mfc_alloc + cmd_ln_int32_r(config, "-pl_window");
+    acmod->feat_buf = feat_array_alloc(acmod->fcb, acmod->n_feat_alloc);
+    acmod->framepos = ckd_calloc(acmod->n_feat_alloc, sizeof(*acmod->framepos));
+
+    acmod->utt_start_frame = 0;
+
+    /* Senone computation stuff. */
+    acmod->senone_scores = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
+                                                     sizeof(*acmod->senone_scores));
+    acmod->senone_active_vec = bitvec_alloc(bin_mdef_n_sen(acmod->mdef));
+    acmod->senone_active = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
+                                                     sizeof(*acmod->senone_active));
+    acmod->log_zero = logmath_get_zero(acmod->lmath);
+    acmod->compallsen = cmd_ln_boolean_r(config, "-compallsen");
+    return acmod;
+
+error_out:
+    acmod_free(acmod);
+    return NULL;
+}
+
+void
+acmod_free(acmod_t *acmod)
+{
+    if (acmod == NULL)
+        return;
+
+    feat_free(acmod->fcb);
+    fe_free(acmod->fe);
+    cmd_ln_free_r(acmod->config);
+
+    if (acmod->mfc_buf)
+        ckd_free_2d((void **)acmod->mfc_buf);
+    if (acmod->feat_buf)
+        feat_array_free(acmod->feat_buf);
+
+    if (acmod->mfcfh)
+        fclose(acmod->mfcfh);
+    if (acmod->rawfh)
+        fclose(acmod->rawfh);
+    if (acmod->senfh)
+        fclose(acmod->senfh);
+
+    ckd_free(acmod->framepos);
+    ckd_free(acmod->senone_scores);
+    ckd_free(acmod->senone_active_vec);
+    ckd_free(acmod->senone_active);
+    ckd_free(acmod->rawdata);
+
+    if (acmod->mdef)
+        bin_mdef_free(acmod->mdef);
+    if (acmod->tmat)
+        tmat_free(acmod->tmat);
+    if (acmod->mgau)
+        ps_mgau_free(acmod->mgau);
+    if (acmod->mllr)
+        ps_mllr_free(acmod->mllr);
+
+    ckd_free(acmod);
+}
+
+ps_mllr_t *
+acmod_update_mllr(acmod_t *acmod, ps_mllr_t *mllr)
+{
+    if (acmod->mllr)
+        ps_mllr_free(acmod->mllr);
+    acmod->mllr = mllr;
+    ps_mgau_transform(acmod->mgau, mllr);
+
+    return mllr;
+}
+
+int
+acmod_write_senfh_header(acmod_t *acmod, FILE *logfh)
+{
+    char nsenstr[64], logbasestr[64];
+
+    sprintf(nsenstr, "%d", bin_mdef_n_sen(acmod->mdef));
+    sprintf(logbasestr, "%f", logmath_get_base(acmod->lmath));
+    return bio_writehdr(logfh,
+                        "version", "0.1",
+                        "mdef_file", cmd_ln_str_r(acmod->config, "-mdef"),
+                        "n_sen", nsenstr,
+                        "logbase", logbasestr, NULL);
+}
+
+int
+acmod_set_senfh(acmod_t *acmod, FILE *logfh)
+{
+    if (acmod->senfh)
+        fclose(acmod->senfh);
+    acmod->senfh = logfh;
+    if (logfh == NULL)
+        return 0;
+    return acmod_write_senfh_header(acmod, logfh);
+}
+
+int
+acmod_set_mfcfh(acmod_t *acmod, FILE *logfh)
+{
+    int rv = 0;
+
+    if (acmod->mfcfh)
+        fclose(acmod->mfcfh);
+    acmod->mfcfh = logfh;
+    fwrite(&rv, 4, 1, acmod->mfcfh);
+    return rv;
+}
+
+int
+acmod_set_rawfh(acmod_t *acmod, FILE *logfh)
+{
+    if (acmod->rawfh)
+        fclose(acmod->rawfh);
+    acmod->rawfh = logfh;
+    return 0;
+}
+
+void
+acmod_grow_feat_buf(acmod_t *acmod, int nfr)
+{
+    if (nfr > MAX_N_FRAMES)
+        E_FATAL("Decoder can not process more than %d frames at once, "
+                "requested %d\n", MAX_N_FRAMES, nfr);
+
+    acmod->feat_buf = feat_array_realloc(acmod->fcb, acmod->feat_buf,
+                                         acmod->n_feat_alloc, nfr);
+    acmod->framepos = ckd_realloc(acmod->framepos,
+                                  nfr * sizeof(*acmod->framepos));
+    acmod->n_feat_alloc = nfr;
+}
+
+int
+acmod_set_grow(acmod_t *acmod, int grow_feat)
+{
+    int tmp = acmod->grow_feat;
+    acmod->grow_feat = grow_feat;
+
+    /* Expand feat_buf to a reasonable size to start with. */
+    if (grow_feat && acmod->n_feat_alloc < 128)
+        acmod_grow_feat_buf(acmod, 128);
+
+    return tmp;
+}
+
+int
+acmod_start_utt(acmod_t *acmod)
+{
+    fe_start_utt(acmod->fe);
+    acmod->state = ACMOD_STARTED;
+    acmod->n_mfc_frame = 0;
+    acmod->n_feat_frame = 0;
+    acmod->mfc_outidx = 0;
+    acmod->feat_outidx = 0;
+    acmod->output_frame = 0;
+    acmod->senscr_frame = -1;
+    acmod->n_senone_active = 0;
+    acmod->mgau->frame_idx = 0;
+    acmod->rawdata_pos = 0;
+
+    return 0;
+}
+
+int
+acmod_end_utt(acmod_t *acmod)
+{
+    int32 nfr = 0;
+
+    acmod->state = ACMOD_ENDED;
+    if (acmod->n_mfc_frame < acmod->n_mfc_alloc) {
+        int inptr;
+        /* Where to start writing them (circular buffer) */
+        inptr = (acmod->mfc_outidx + acmod->n_mfc_frame) % acmod->n_mfc_alloc;
+        /* nfr is always either zero or one. */
+        fe_end_utt(acmod->fe, acmod->mfc_buf[inptr], &nfr);
+        acmod->n_mfc_frame += nfr;
+        
+        /* Process whatever's left, and any leadout or update stats if needed. */
+        if (nfr)
+            nfr = acmod_process_mfcbuf(acmod);
+        else
+            feat_update_stats(acmod->fcb);
+    }
+    if (acmod->mfcfh) {
+        long outlen;
+        int32 rv;
+        outlen = (ftell(acmod->mfcfh) - 4) / 4;
+        if (!WORDS_BIGENDIAN)
+            SWAP_INT32(&outlen);
+        /* Try to seek and write */
+        if ((rv = fseek(acmod->mfcfh, 0, SEEK_SET)) == 0) {
+            fwrite(&outlen, 4, 1, acmod->mfcfh);
+        }
+        fclose(acmod->mfcfh);
+        acmod->mfcfh = NULL;
+    }
+    if (acmod->rawfh) {
+        fclose(acmod->rawfh);
+        acmod->rawfh = NULL;
+    }
+
+    if (acmod->senfh) {
+        fclose(acmod->senfh);
+        acmod->senfh = NULL;
+    }
+
+    return nfr;
+}
+
+static int
+acmod_log_mfc(acmod_t *acmod,
+              mfcc_t **cep, int n_frames)
+{
+    int i, n;
+    int32 *ptr = (int32 *)cep[0];
+
+    n = n_frames * feat_cepsize(acmod->fcb);
+    /* Swap bytes. */
+    if (!WORDS_BIGENDIAN) {
+        for (i = 0; i < (n * sizeof(mfcc_t)); ++i) {
+            SWAP_INT32(ptr + i);
+        }
+    }
+    /* Write features. */
+    if (fwrite(cep[0], sizeof(mfcc_t), n, acmod->mfcfh) != n) {
+        E_ERROR_SYSTEM("Failed to write %d values to log file", n);
+    }
+
+    /* Swap them back. */
+    if (!WORDS_BIGENDIAN) {
+        for (i = 0; i < (n * sizeof(mfcc_t)); ++i) {
+            SWAP_INT32(ptr + i);
+        }
+    }
+    return 0;
+}
+
+static int
+acmod_process_full_cep(acmod_t *acmod,
+                       mfcc_t ***inout_cep,
+                       int *inout_n_frames)
+{
+    int32 nfr;
+
+    /* Write to log file. */
+    if (acmod->mfcfh)
+        acmod_log_mfc(acmod, *inout_cep, *inout_n_frames);
+
+    /* Resize feat_buf to fit. */
+    if (acmod->n_feat_alloc < *inout_n_frames) {
+
+        if (*inout_n_frames > MAX_N_FRAMES)
+            E_FATAL("Batch processing can not process more than %d frames "
+                    "at once, requested %d\n", MAX_N_FRAMES, *inout_n_frames);
+
+        feat_array_free(acmod->feat_buf);
+        acmod->feat_buf = feat_array_alloc(acmod->fcb, *inout_n_frames);
+        acmod->n_feat_alloc = *inout_n_frames;
+        acmod->n_feat_frame = 0;
+        acmod->feat_outidx = 0;
+    }
+    /* Make dynamic features. */
+    nfr = feat_s2mfc2feat_live(acmod->fcb, *inout_cep, inout_n_frames,
+                               TRUE, TRUE, acmod->feat_buf);
+    acmod->n_feat_frame = nfr;
+    assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
+    *inout_cep += *inout_n_frames;
+    *inout_n_frames = 0;
+
+    return nfr;
+}
+
+static int
+acmod_process_full_raw(acmod_t *acmod,
+                       int16 const **inout_raw,
+                       size_t *inout_n_samps)
+{
+    int32 nfr, ntail;
+    mfcc_t **cepptr;
+
+    /* Write to logging file if any. */
+    if (*inout_n_samps + acmod->rawdata_pos < acmod->rawdata_size) {
+	memcpy(acmod->rawdata + acmod->rawdata_pos, *inout_raw, *inout_n_samps * sizeof(int16));
+	acmod->rawdata_pos += *inout_n_samps;
+    }
+    if (acmod->rawfh)
+        fwrite(*inout_raw, sizeof(int16), *inout_n_samps, acmod->rawfh);
+    /* Resize mfc_buf to fit. */
+    if (fe_process_frames(acmod->fe, NULL, inout_n_samps, NULL, &nfr, NULL) < 0)
+        return -1;
+    if (acmod->n_mfc_alloc < nfr + 1) {
+        ckd_free_2d(acmod->mfc_buf);
+        acmod->mfc_buf = ckd_calloc_2d(nfr + 1, fe_get_output_size(acmod->fe),
+                                       sizeof(**acmod->mfc_buf));
+        acmod->n_mfc_alloc = nfr + 1;
+    }
+    acmod->n_mfc_frame = 0;
+    acmod->mfc_outidx = 0;
+    fe_start_utt(acmod->fe);
+    if (fe_process_frames(acmod->fe, inout_raw, inout_n_samps,
+                          acmod->mfc_buf, &nfr, NULL) < 0)
+        return -1;
+    fe_end_utt(acmod->fe, acmod->mfc_buf[nfr], &ntail);
+    nfr += ntail;
+
+    cepptr = acmod->mfc_buf;
+    nfr = acmod_process_full_cep(acmod, &cepptr, &nfr);
+    acmod->n_mfc_frame = 0;
+    return nfr;
+}
+
+/**
+ * Process MFCCs that are in the internal buffer into features.
+ */
+static int32
+acmod_process_mfcbuf(acmod_t *acmod)
+{
+    mfcc_t **mfcptr;
+    int32 ncep;
+
+    ncep = acmod->n_mfc_frame;
+    /* Also do this in two parts because of the circular mfc_buf. */
+    if (acmod->mfc_outidx + ncep > acmod->n_mfc_alloc) {
+        int32 ncep1 = acmod->n_mfc_alloc - acmod->mfc_outidx;
+        int saved_state = acmod->state;
+
+        /* Make sure we don't end the utterance here. */
+        if (acmod->state == ACMOD_ENDED)
+            acmod->state = ACMOD_PROCESSING;
+        mfcptr = acmod->mfc_buf + acmod->mfc_outidx;
+        ncep1 = acmod_process_cep(acmod, &mfcptr, &ncep1, FALSE);
+        /* It's possible that not all available frames were filled. */
+        ncep -= ncep1;
+        acmod->n_mfc_frame -= ncep1;
+        acmod->mfc_outidx += ncep1;
+        acmod->mfc_outidx %= acmod->n_mfc_alloc;
+        /* Restore original state (could this really be the end) */
+        acmod->state = saved_state;
+    }
+    mfcptr = acmod->mfc_buf + acmod->mfc_outidx;
+    ncep = acmod_process_cep(acmod, &mfcptr, &ncep, FALSE);
+    acmod->n_mfc_frame -= ncep;
+    acmod->mfc_outidx += ncep;
+    acmod->mfc_outidx %= acmod->n_mfc_alloc;
+    return ncep;
+}
+
+int
+acmod_process_raw(acmod_t *acmod,
+                  int16 const **inout_raw,
+                  size_t *inout_n_samps,
+                  int full_utt)
+{
+    int32 ncep;
+    int32 out_frameidx;
+    int16 const *prev_audio_inptr;
+    
+    /* If this is a full utterance, process it all at once. */
+    if (full_utt)
+        return acmod_process_full_raw(acmod, inout_raw, inout_n_samps);
+
+    /* Append MFCCs to the end of any that are previously in there
+     * (in practice, there will probably be none) */
+    if (inout_n_samps && *inout_n_samps) {
+        int inptr;
+        int32 processed_samples;
+
+        prev_audio_inptr = *inout_raw;
+        /* Total number of frames available. */
+        ncep = acmod->n_mfc_alloc - acmod->n_mfc_frame;
+        /* Where to start writing them (circular buffer) */
+        inptr = (acmod->mfc_outidx + acmod->n_mfc_frame) % acmod->n_mfc_alloc;
+
+        /* Write them in two (or more) parts if there is wraparound. */
+        while (inptr + ncep > acmod->n_mfc_alloc) {
+            int32 ncep1 = acmod->n_mfc_alloc - inptr;
+            if (fe_process_frames(acmod->fe, inout_raw, inout_n_samps,
+                                  acmod->mfc_buf + inptr, &ncep1, &out_frameidx) < 0)
+                return -1;
+	    
+	    if (out_frameidx > 0)
+		acmod->utt_start_frame = out_frameidx;
+
+    	    processed_samples = *inout_raw - prev_audio_inptr;
+	    if (processed_samples + acmod->rawdata_pos < acmod->rawdata_size) {
+		memcpy(acmod->rawdata + acmod->rawdata_pos, prev_audio_inptr, processed_samples * sizeof(int16));
+		acmod->rawdata_pos += processed_samples;
+	    }
+            /* Write to logging file if any. */
+            if (acmod->rawfh) {
+                fwrite(prev_audio_inptr, sizeof(int16),
+                       processed_samples,
+                       acmod->rawfh);
+            }
+            prev_audio_inptr = *inout_raw;
+            
+            /* ncep1 now contains the number of frames actually
+             * processed.  This is a good thing, but it means we
+             * actually still might have some room left at the end of
+             * the buffer, hence the while loop.  Unfortunately it
+             * also means that in the case where we are really
+             * actually done, we need to get out totally, hence the
+             * goto. */
+            acmod->n_mfc_frame += ncep1;
+            ncep -= ncep1;
+            inptr += ncep1;
+            inptr %= acmod->n_mfc_alloc;
+            if (ncep1 == 0)
+        	goto alldone;
+        }
+
+        assert(inptr + ncep <= acmod->n_mfc_alloc);        
+        if (fe_process_frames(acmod->fe, inout_raw, inout_n_samps,
+                              acmod->mfc_buf + inptr, &ncep, &out_frameidx) < 0)
+            return -1;
+
+	if (out_frameidx > 0)
+	    acmod->utt_start_frame = out_frameidx;
+
+	
+	processed_samples = *inout_raw - prev_audio_inptr;
+	if (processed_samples + acmod->rawdata_pos < acmod->rawdata_size) {
+	    memcpy(acmod->rawdata + acmod->rawdata_pos, prev_audio_inptr, processed_samples * sizeof(int16));
+	    acmod->rawdata_pos += processed_samples;
+	}
+        if (acmod->rawfh) {
+            fwrite(prev_audio_inptr, sizeof(int16),
+                   processed_samples, acmod->rawfh);
+        }
+        prev_audio_inptr = *inout_raw;
+        acmod->n_mfc_frame += ncep;
+    alldone:
+        ;
+    }
+
+    /* Hand things off to acmod_process_cep. */
+    return acmod_process_mfcbuf(acmod);
+}
+
+int
+acmod_process_cep(acmod_t *acmod,
+                  mfcc_t ***inout_cep,
+                  int *inout_n_frames,
+                  int full_utt)
+{
+    int32 nfeat, ncep, inptr;
+    int orig_n_frames;
+
+    /* If this is a full utterance, process it all at once. */
+    if (full_utt)
+        return acmod_process_full_cep(acmod, inout_cep, inout_n_frames);
+
+    /* Write to log file. */
+    if (acmod->mfcfh)
+        acmod_log_mfc(acmod, *inout_cep, *inout_n_frames);
+
+    /* Maximum number of frames we're going to generate. */
+    orig_n_frames = ncep = nfeat = *inout_n_frames;
+
+    /* FIXME: This behaviour isn't guaranteed... */
+    if (acmod->state == ACMOD_ENDED)
+        nfeat += feat_window_size(acmod->fcb);
+    else if (acmod->state == ACMOD_STARTED)
+        nfeat -= feat_window_size(acmod->fcb);
+
+    /* Clamp number of features to fit available space. */
+    if (nfeat > acmod->n_feat_alloc - acmod->n_feat_frame) {
+        /* Grow it as needed - we have to grow it at the end of an
+         * utterance because we can't return a short read there. */
+        if (acmod->grow_feat || acmod->state == ACMOD_ENDED)
+            acmod_grow_feat_buf(acmod, acmod->n_feat_alloc + nfeat);
+        else
+            ncep -= (nfeat - (acmod->n_feat_alloc - acmod->n_feat_frame));
+    }
+
+    /* Where to start writing in the feature buffer. */
+    if (acmod->grow_feat) {
+        /* Grow to avoid wraparound if grow_feat == TRUE. */
+        inptr = acmod->feat_outidx + acmod->n_feat_frame;
+        while (inptr + nfeat >= acmod->n_feat_alloc)
+            acmod_grow_feat_buf(acmod, acmod->n_feat_alloc * 2);
+    }
+    else {
+        inptr = (acmod->feat_outidx + acmod->n_feat_frame) % acmod->n_feat_alloc;
+    }
+
+
+    /* FIXME: we can't split the last frame drop properly to be on the bounary,
+     *        so just return
+     */
+    if (inptr + nfeat > acmod->n_feat_alloc && acmod->state == ACMOD_ENDED) {
+        *inout_n_frames -= ncep;
+        *inout_cep += ncep;
+        return 0;
+    }
+
+    /* Write them in two parts if there is wraparound. */
+    if (inptr + nfeat > acmod->n_feat_alloc) {
+        int32 ncep1 = acmod->n_feat_alloc - inptr;
+
+        /* Make sure we don't end the utterance here. */
+        nfeat = feat_s2mfc2feat_live(acmod->fcb, *inout_cep,
+                                     &ncep1,
+                                     (acmod->state == ACMOD_STARTED),
+                                     FALSE,
+                                     acmod->feat_buf + inptr);
+        if (nfeat < 0)
+            return -1;
+        /* Move the output feature pointer forward. */
+        acmod->n_feat_frame += nfeat;
+        assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
+        inptr += nfeat;
+        inptr %= acmod->n_feat_alloc;
+        /* Move the input feature pointers forward. */
+        *inout_n_frames -= ncep1;
+        *inout_cep += ncep1;
+        ncep -= ncep1;
+    }
+
+    nfeat = feat_s2mfc2feat_live(acmod->fcb, *inout_cep,
+                                 &ncep,
+                                 (acmod->state == ACMOD_STARTED),
+                                 (acmod->state == ACMOD_ENDED),
+                                 acmod->feat_buf + inptr);
+    if (nfeat < 0)
+        return -1;
+    acmod->n_feat_frame += nfeat;
+    assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
+    /* Move the input feature pointers forward. */
+    *inout_n_frames -= ncep;
+    *inout_cep += ncep;
+    if (acmod->state == ACMOD_STARTED)
+        acmod->state = ACMOD_PROCESSING;
+    
+    return orig_n_frames - *inout_n_frames;
+}
+
+int
+acmod_process_feat(acmod_t *acmod,
+                   mfcc_t **feat)
+{
+    int i, inptr;
+
+    if (acmod->n_feat_frame == acmod->n_feat_alloc) {
+        if (acmod->grow_feat)
+            acmod_grow_feat_buf(acmod, acmod->n_feat_alloc * 2);
+        else
+            return 0;
+    }
+
+    if (acmod->grow_feat) {
+        /* Grow to avoid wraparound if grow_feat == TRUE. */
+        inptr = acmod->feat_outidx + acmod->n_feat_frame;
+        while (inptr + 1 >= acmod->n_feat_alloc)
+            acmod_grow_feat_buf(acmod, acmod->n_feat_alloc * 2);
+    }
+    else {
+        inptr = (acmod->feat_outidx + acmod->n_feat_frame) % acmod->n_feat_alloc;
+    }
+    for (i = 0; i < feat_dimension1(acmod->fcb); ++i)
+        memcpy(acmod->feat_buf[inptr][i],
+               feat[i], feat_dimension2(acmod->fcb, i) * sizeof(**feat));
+    ++acmod->n_feat_frame;
+    assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
+
+    return 1;
+}
+
+static int
+acmod_read_senfh_header(acmod_t *acmod)
+{
+    char **name, **val;
+    int32 swap;
+    int i;
+
+    if (bio_readhdr(acmod->insenfh, &name, &val, &swap) < 0)
+        goto error_out;
+    for (i = 0; name[i] != NULL; ++i) {
+        if (!strcmp(name[i], "n_sen")) {
+            if (atoi(val[i]) != bin_mdef_n_sen(acmod->mdef)) {
+                E_ERROR("Number of senones in senone file (%d) does not "
+                        "match mdef (%d)\n", atoi(val[i]),
+                        bin_mdef_n_sen(acmod->mdef));
+                goto error_out;
+            }
+        }
+
+        if (!strcmp(name[i], "logbase")) {
+            if (fabs(atof_c(val[i]) - logmath_get_base(acmod->lmath)) > 0.001) {
+                E_ERROR("Logbase in senone file (%f) does not match acmod "
+                        "(%f)\n", atof_c(val[i]),
+                        logmath_get_base(acmod->lmath));
+                goto error_out;
+            }
+        }
+    }
+    acmod->insen_swap = swap;
+    bio_hdrarg_free(name, val);
+    return 0;
+error_out:
+    bio_hdrarg_free(name, val);
+    return -1;
+}
+
+int
+acmod_set_insenfh(acmod_t *acmod, FILE *senfh)
+{
+    acmod->insenfh = senfh;
+    if (senfh == NULL) {
+        acmod->n_feat_frame = 0;
+        acmod->compallsen = cmd_ln_boolean_r(acmod->config, "-compallsen");
+        return 0;
+    }
+    acmod->compallsen = TRUE;
+    return acmod_read_senfh_header(acmod);
+}
+
+int
+acmod_rewind(acmod_t *acmod)
+{
+    /* If the feature buffer is circular, this is not possible. */
+    if (acmod->output_frame > acmod->n_feat_alloc) {
+        E_ERROR("Circular feature buffer cannot be rewound (output frame %d, "
+                "alloc %d)\n", acmod->output_frame, acmod->n_feat_alloc);
+        return -1;
+    }
+
+    /* Frames consumed + frames available */
+    acmod->n_feat_frame = acmod->output_frame + acmod->n_feat_frame;
+
+    /* Reset output pointers. */
+    acmod->feat_outidx = 0;
+    acmod->output_frame = 0;
+    acmod->senscr_frame = -1;
+    acmod->mgau->frame_idx = 0;
+
+    return 0;
+}
+
+int
+acmod_advance(acmod_t *acmod)
+{
+    /* Advance the output pointers. */
+    if (++acmod->feat_outidx == acmod->n_feat_alloc)
+        acmod->feat_outidx = 0;
+    --acmod->n_feat_frame;
+    ++acmod->mgau->frame_idx;
+
+    return ++acmod->output_frame;
+}
+
+int
+acmod_write_scores(acmod_t *acmod, int n_active, uint8 const *active,
+                   int16 const *senscr, FILE *senfh)
+{
+    int16 n_active2;
+
+    /* Uncompressed frame format:
+     *
+     * (2 bytes) n_active: Number of active senones
+     * If all senones active:
+     * (n_active * 2 bytes) scores of active senones
+     *
+     * Otherwise:
+     * (2 bytes) n_active: Number of active senones
+     * (n_active bytes) deltas to active senones
+     * (n_active * 2 bytes) scores of active senones
+     */
+    n_active2 = n_active;
+    if (fwrite(&n_active2, 2, 1, senfh) != 1)
+        goto error_out;
+    if (n_active == bin_mdef_n_sen(acmod->mdef)) {
+        if (fwrite(senscr, 2, n_active, senfh) != n_active)
+            goto error_out;
+    }
+    else {
+        int i, n;
+        if (fwrite(active, 1, n_active, senfh) != n_active)
+            goto error_out;
+        for (i = n = 0; i < n_active; ++i) {
+            n += active[i];
+            if (fwrite(senscr + n, 2, 1, senfh) != 1)
+                goto error_out;
+        }
+    }
+    return 0;
+error_out:
+    E_ERROR_SYSTEM("Failed to write frame to senone file");
+    return -1;
+}
+
+/**
+ * Internal version, used for reading previous frames in acmod_score()
+ */
+static int
+acmod_read_scores_internal(acmod_t *acmod)
+{
+    FILE *senfh = acmod->insenfh;
+    int16 n_active;
+    size_t rv;
+
+    if (acmod->n_feat_frame == acmod->n_feat_alloc) {
+        if (acmod->grow_feat)
+            acmod_grow_feat_buf(acmod, acmod->n_feat_alloc * 2);
+        else
+            return 0;
+    }
+
+    if (senfh == NULL)
+        return -1;
+    
+    if ((rv = fread(&n_active, 2, 1, senfh)) != 1)
+        goto error_out;
+
+    acmod->n_senone_active = n_active;
+    if (acmod->n_senone_active == bin_mdef_n_sen(acmod->mdef)) {
+        if ((rv = fread(acmod->senone_scores, 2,
+                        acmod->n_senone_active, senfh)) != acmod->n_senone_active)
+            goto error_out;
+    }
+    else {
+        int i, n;
+        
+        if ((rv = fread(acmod->senone_active, 1,
+                        acmod->n_senone_active, senfh)) != acmod->n_senone_active)
+            goto error_out;
+
+        for (i = 0, n = 0; i < acmod->n_senone_active; ++i) {
+            int j, sen = n + acmod->senone_active[i];
+            for (j = n + 1; j < sen; ++j)
+                acmod->senone_scores[j] = SENSCR_DUMMY;
+            
+            if ((rv = fread(acmod->senone_scores + sen, 2, 1, senfh)) != 1)
+                goto error_out;
+            
+            n = sen;
+        }
+
+        n++;
+        while (n < bin_mdef_n_sen(acmod->mdef))
+            acmod->senone_scores[n++] = SENSCR_DUMMY;
+    }
+    return 1;
+
+error_out:
+    if (ferror(senfh)) {
+        E_ERROR_SYSTEM("Failed to read frame from senone file");
+        return -1;
+    }
+    return 0;
+}
+
+int
+acmod_read_scores(acmod_t *acmod)
+{
+    int inptr, rv;
+
+    if (acmod->grow_feat) {
+        /* Grow to avoid wraparound if grow_feat == TRUE. */
+        inptr = acmod->feat_outidx + acmod->n_feat_frame;
+        /* Has to be +1, otherwise, next time acmod_advance() is
+         * called, this will wrap around. */
+        while (inptr + 1 >= acmod->n_feat_alloc)
+            acmod_grow_feat_buf(acmod, acmod->n_feat_alloc * 2);
+    }
+    else {
+        inptr = (acmod->feat_outidx + acmod->n_feat_frame) %
+                acmod->n_feat_alloc;
+    }
+
+    if ((rv = acmod_read_scores_internal(acmod)) != 1)
+        return rv;
+
+    /* Set acmod->senscr_frame appropriately so that these scores
+       get reused below in acmod_score(). */
+    acmod->senscr_frame = acmod->output_frame + acmod->n_feat_frame;
+
+    E_DEBUG(1,("Frame %d has %d active states\n",
+               acmod->senscr_frame, acmod->n_senone_active));
+
+    /* Increment the "feature frame counter" and record the file
+     * position for the relevant frame in the (possibly circular)
+     * buffer. */
+    ++acmod->n_feat_frame;
+    acmod->framepos[inptr] = ftell(acmod->insenfh);
+
+    return 1;
+}
+
+static int
+calc_frame_idx(acmod_t *acmod, int *inout_frame_idx)
+{
+    int frame_idx;
+
+    /* Calculate the absolute frame index to be scored. */
+    if (inout_frame_idx == NULL)
+        frame_idx = acmod->output_frame;
+    else if (*inout_frame_idx < 0)
+        frame_idx = acmod->output_frame + 1 + *inout_frame_idx;
+    else
+        frame_idx = *inout_frame_idx;
+
+    return frame_idx;
+}
+
+static int
+calc_feat_idx(acmod_t *acmod, int frame_idx)
+{
+    int n_backfr, feat_idx;
+
+    n_backfr = acmod->n_feat_alloc - acmod->n_feat_frame;
+    if (frame_idx < 0 || acmod->output_frame - frame_idx > n_backfr) {
+        E_ERROR("Frame %d outside queue of %d frames, %d alloc (%d > %d), "
+                "cannot score\n", frame_idx, acmod->n_feat_frame,
+                acmod->n_feat_alloc, acmod->output_frame - frame_idx,
+                n_backfr);
+        return -1;
+    }
+
+    /* Get the index in feat_buf/framepos of the frame to be scored. */
+    feat_idx = (acmod->feat_outidx + frame_idx - acmod->output_frame) %
+               acmod->n_feat_alloc;
+    if (feat_idx < 0)
+        feat_idx += acmod->n_feat_alloc;
+
+    return feat_idx;
+}
+
+mfcc_t **
+acmod_get_frame(acmod_t *acmod, int *inout_frame_idx)
+{
+    int frame_idx, feat_idx;
+
+    /* Calculate the absolute frame index requested. */
+    frame_idx = calc_frame_idx(acmod, inout_frame_idx);
+
+    /* Calculate position of requested frame in circular buffer. */
+    if ((feat_idx = calc_feat_idx(acmod, frame_idx)) < 0)
+        return NULL;
+
+    if (inout_frame_idx)
+        *inout_frame_idx = frame_idx;
+
+    return acmod->feat_buf[feat_idx];
+}
+
+int16 const *
+acmod_score(acmod_t *acmod, int *inout_frame_idx)
+{
+    int frame_idx, feat_idx;
+
+    /* Calculate the absolute frame index to be scored. */
+    frame_idx = calc_frame_idx(acmod, inout_frame_idx);
+
+    /* If all senones are being computed, or we are using a senone file,
+       then we can reuse existing scores. */
+    if ((acmod->compallsen || acmod->insenfh)
+        && frame_idx == acmod->senscr_frame) {
+        if (inout_frame_idx)
+            *inout_frame_idx = frame_idx;
+        return acmod->senone_scores;
+    }
+
+    /* Calculate position of requested frame in circular buffer. */
+    if ((feat_idx = calc_feat_idx(acmod, frame_idx)) < 0)
+        return NULL;
+
+    /*
+     * If there is an input senone file locate the appropriate frame and read
+     * it.
+     */
+    if (acmod->insenfh) {
+        fseek(acmod->insenfh, acmod->framepos[feat_idx], SEEK_SET);
+        if (acmod_read_scores_internal(acmod) < 0)
+            return NULL;
+    }
+    else {
+        /* Build active senone list. */
+        acmod_flags2list(acmod);
+
+        /* Generate scores for the next available frame */
+        ps_mgau_frame_eval(acmod->mgau,
+                           acmod->senone_scores,
+                           acmod->senone_active,
+                           acmod->n_senone_active,
+                           acmod->feat_buf[feat_idx],
+                           frame_idx,
+                           acmod->compallsen);
+    }
+
+    if (inout_frame_idx)
+        *inout_frame_idx = frame_idx;
+    acmod->senscr_frame = frame_idx;
+
+    /* Dump scores to the senone dump file if one exists. */
+    if (acmod->senfh) {
+        if (acmod_write_scores(acmod, acmod->n_senone_active,
+                               acmod->senone_active,
+                               acmod->senone_scores,
+                               acmod->senfh) < 0)
+            return NULL;
+        E_DEBUG(1,("Frame %d has %d active states\n", frame_idx,
+                   acmod->n_senone_active));
+    }
+
+    return acmod->senone_scores;
+}
+
+int
+acmod_best_score(acmod_t *acmod, int *out_best_senid)
+{
+    int i, best;
+
+    best = SENSCR_DUMMY;
+    if (acmod->compallsen) {
+        for (i = 0; i < bin_mdef_n_sen(acmod->mdef); ++i) {
+            if (acmod->senone_scores[i] < best) {
+                best = acmod->senone_scores[i];
+                *out_best_senid = i;
+            }
+        }
+    }
+    else {
+        int16 *senscr;
+        senscr = acmod->senone_scores;
+        for (i = 0; i < acmod->n_senone_active; ++i) {
+            senscr += acmod->senone_active[i];
+            if (*senscr < best) {
+                best = *senscr;
+                *out_best_senid = i;
+            }
+        }
+    }
+    return best;
+}
+
+
+void
+acmod_clear_active(acmod_t *acmod)
+{
+    if (acmod->compallsen)
+        return;
+    bitvec_clear_all(acmod->senone_active_vec, bin_mdef_n_sen(acmod->mdef));
+    acmod->n_senone_active = 0;
+}
+
+#define MPX_BITVEC_SET(a,h,i)                                   \
+    if (hmm_mpx_ssid(h,i) != BAD_SSID)                          \
+        bitvec_set((a)->senone_active_vec, hmm_mpx_senid(h,i))
+#define NONMPX_BITVEC_SET(a,h,i)                                        \
+    bitvec_set((a)->senone_active_vec,                                  \
+               hmm_nonmpx_senid(h,i))
+
+void
+acmod_activate_hmm(acmod_t *acmod, hmm_t *hmm)
+{
+    int i;
+
+    if (acmod->compallsen)
+        return;
+    if (hmm_is_mpx(hmm)) {
+        switch (hmm_n_emit_state(hmm)) {
+        case 5:
+            MPX_BITVEC_SET(acmod, hmm, 4);
+            MPX_BITVEC_SET(acmod, hmm, 3);
+        case 3:
+            MPX_BITVEC_SET(acmod, hmm, 2);
+            MPX_BITVEC_SET(acmod, hmm, 1);
+            MPX_BITVEC_SET(acmod, hmm, 0);
+            break;
+        default:
+            for (i = 0; i < hmm_n_emit_state(hmm); ++i) {
+                MPX_BITVEC_SET(acmod, hmm, i);
+            }
+        }
+    }
+    else {
+        switch (hmm_n_emit_state(hmm)) {
+        case 5:
+            NONMPX_BITVEC_SET(acmod, hmm, 4);
+            NONMPX_BITVEC_SET(acmod, hmm, 3);
+        case 3:
+            NONMPX_BITVEC_SET(acmod, hmm, 2);
+            NONMPX_BITVEC_SET(acmod, hmm, 1);
+            NONMPX_BITVEC_SET(acmod, hmm, 0);
+            break;
+        default:
+            for (i = 0; i < hmm_n_emit_state(hmm); ++i) {
+                NONMPX_BITVEC_SET(acmod, hmm, i);
+            }
+        }
+    }
+}
+
+int32
+acmod_flags2list(acmod_t *acmod)
+{
+    int32 w, l, n, b, total_dists, total_words, extra_bits;
+    bitvec_t *flagptr;
+
+    total_dists = bin_mdef_n_sen(acmod->mdef);
+    if (acmod->compallsen) {
+        acmod->n_senone_active = total_dists;
+        return total_dists;
+    }
+    total_words = total_dists / BITVEC_BITS;
+    extra_bits = total_dists % BITVEC_BITS;
+    w = n = l = 0;
+    for (flagptr = acmod->senone_active_vec; w < total_words; ++w, ++flagptr) {
+        if (*flagptr == 0)
+            continue;
+        for (b = 0; b < BITVEC_BITS; ++b) {
+            if (*flagptr & (1UL << b)) {
+                int32 sen = w * BITVEC_BITS + b;
+                int32 delta = sen - l;
+                /* Handle excessive deltas "lossily" by adding a few
+                   extra senones to bridge the gap. */
+                while (delta > 255) {
+                    acmod->senone_active[n++] = 255;
+                    delta -= 255;
+                }
+                acmod->senone_active[n++] = delta;
+                l = sen;
+            }
+        }
+    }
+
+    for (b = 0; b < extra_bits; ++b) {
+        if (*flagptr & (1UL << b)) {
+            int32 sen = w * BITVEC_BITS + b;
+            int32 delta = sen - l;
+            /* Handle excessive deltas "lossily" by adding a few
+               extra senones to bridge the gap. */
+            while (delta > 255) {
+                acmod->senone_active[n++] = 255;
+                delta -= 255;
+            }
+            acmod->senone_active[n++] = delta;
+            l = sen;
+        }
+    }
+
+    acmod->n_senone_active = n;
+    E_DEBUG(1, ("acmod_flags2list: %d active in frame %d\n",
+                acmod->n_senone_active, acmod->output_frame));
+    return n;
+}
+
+int32
+acmod_stream_offset(acmod_t *acmod)
+{
+    return acmod->utt_start_frame;
+}
+
+void
+acmod_start_stream(acmod_t *acmod)
+{
+    fe_start_stream(acmod->fe);
+    acmod->utt_start_frame = 0;
+}
+
+void
+acmod_set_rawdata_size(acmod_t *acmod, int32 size)
+{	
+    assert(size >= 0);
+    acmod->rawdata_size = size;
+    if (acmod->rawdata_size > 0) {
+	ckd_free(acmod->rawdata);
+	acmod->rawdata = ckd_calloc(size, sizeof(int16));
+    }
+}
+
+void
+acmod_get_rawdata(acmod_t *acmod, int16 **buffer, int32 *size)
+{
+    if (buffer) {
+	*buffer = acmod->rawdata;
+    }
+    if (size) {
+	*size = acmod->rawdata_pos;
+    }
+}
+