Ticket #6414: tests_libs_sphinx.patch

src/tests/libs/sphinx/test_hash/_hash_delete3.res

@@ +1 @@
+Hash with chaining representation of the hash table
+|key:-bla|len:4|val=8|->NULL
+|key:-hmmdump|len:8|val=1|->|key:-subvq|len:6|val=7|->|key:-outlatdir|len:10|val=3|->NULL
+|key:-lminmemory|len:11|val=6|->NULL
+|key:-lm|len:3|val=4|->NULL
+|key:-beam|len:5|val=5|->NULL
+The total number of keys =7

src/tests/libs/sphinx/test_hash/_hash_delete4.res

@@ +1 @@
+Hash with chaining representation of the hash table
+|key:-bla|len:4|val=8|->NULL
+|key:-subvq|len:6|val=7|->|key:-outlatdir|len:10|val=3|->NULL
+|key:-svq4svq|len:8|val=2|->|key:-lminmemory|len:11|val=6|->NULL
+|key:-lm|len:3|val=4|->NULL
+|key:-beam|len:5|val=5|->NULL
+The total number of keys =7

src/tests/libs/sphinx/test_hash/_hash_delete5.res

@@ +1 @@
+Failed as expected

src/tests/libs/sphinx/test_hash/test_hash_iter.c

@@ +1 @@
+/**
+ * @file test_hash_iter.c Test hash table iterators
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+#include "hash_table.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int
+main(int argc, char *argv[])
+{
+    hash_table_t *h;
+    hash_iter_t *itor;
+
+    /* Test insertion */
+    TEST_ASSERT(h = hash_table_new(42, FALSE));
+    TEST_EQUAL((void*)0xdeadbeef, hash_table_enter(h, "foo", (void*)0xdeadbeef));
+    TEST_EQUAL((void*)0xdeadbeef, hash_table_enter(h, "foo", (void*)0xd0d0feed));
+    TEST_EQUAL((void*)0xcafec0de, hash_table_enter(h, "bar", (void*)0xcafec0de));
+    TEST_EQUAL((void*)0xeeefeeef, hash_table_enter(h, "baz", (void*)0xeeefeeef));
+    TEST_EQUAL((void*)0xbabababa, hash_table_enter(h, "quux", (void*)0xbabababa));
+
+    /* Now test iterators. */
+    for (itor = hash_table_iter(h); itor; itor = hash_table_iter_next(itor)) {
+        printf("%s %p\n", itor->ent->key, itor->ent->val);
+        if (0 == strcmp(itor->ent->key, "foo")) {
+            TEST_EQUAL(itor->ent->val, (void*)0xdeadbeef);
+        }
+        else if (0 == strcmp(itor->ent->key, "bar")) {
+            TEST_EQUAL(itor->ent->val, (void*)0xcafec0de);
+        }
+        else if (0 == strcmp(itor->ent->key, "baz")) {
+            TEST_EQUAL(itor->ent->val, (void*)0xeeefeeef);
+        }
+        else if (0 == strcmp(itor->ent->key, "quux")) {
+            TEST_EQUAL(itor->ent->val, (void*)0xbabababa);
+        }
+    }
+
+    return 0;
+}

src/tests/libs/sphinx/test_hash/deletehash.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <hash_table.h>
+#include <err.h>
+
+/* Explore a more complicated case for deletion */
+int
+main(int argc, char **argv)
+{
+    hash_table_t *ht;
+    void *val;
+
+    if (argc != 2) {
+        printf("deletehash <key>\n");
+        exit(-1);
+    }
+
+    ht = hash_table_new(75, 0);
+
+    if (hash_table_enter(ht, "-hmmdump", (void *)1) != (void *)1) {
+        E_FATAL("Insertion of -hmmdump failed\n");
+    }
+
+    if (hash_table_enter(ht, "-svq4svq", (void *)2) != (void *)2) {
+        E_FATAL("Insertion of -svq4svq failed\n");
+    }
+
+    if (hash_table_enter(ht, "-outlatdir", (void *)3) != (void *)3) {
+        E_FATAL("Insertion of -svq4svq failed\n");
+    }
+
+    if (hash_table_enter(ht, "-lm", (void *)4) != (void *)4) {
+        E_FATAL("Insertion of -lm failed\n");
+    }
+
+    if (hash_table_enter(ht, "-beam", (void *)5) != (void *)5) {
+        E_FATAL("Insertion of -beam failed\n");
+    }
+
+    if (hash_table_enter(ht, "-lminmemory", (void *)6) != (void *)6) {
+        E_FATAL("Insertion of -lminmemory failed\n");
+    }
+
+    if (hash_table_enter(ht, "-subvq", (void *)7) != (void *)7) {
+        E_FATAL("Insertion of -outlatdir failed\n");
+    }
+
+    if (hash_table_enter(ht, "-bla", (void *)8) != (void *)8) {
+        E_FATAL("Insertion of -bla failed\n");
+    }
+
+    /*  hash_table_display(ht,1); */
+    if (hash_table_delete(ht, argv[1]) == NULL) {
+        E_INFOCONT("Failed as expected\n");
+        return 0;
+    }
+    else {
+        hash_table_display(ht, 1);
+    }
+
+    /* Test emptying */
+    hash_table_empty(ht);
+    if (hash_table_lookup(ht, "-beam", &val) == 0) {
+        E_FATAL("Emptying hash table failed\n");
+    }
+
+    hash_table_free(ht);
+    ht = NULL;
+    return 0;
+}
+
+
+#if 0
+E_INFO("Hash table in the command line\n");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -lm\n");
+hash_table_delete(ht, "-lm");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -lm\n");
+
+hash_table_delete(ht, "-lm");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -svq4svq\n");
+hash_table_delete(ht, "-svq4svq");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -beam\n");
+hash_table_delete(ht, "-beam");
+hash_table_display(ht, 1);
+#endif

src/tests/libs/sphinx/test_hash/displayhash.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <hash_table.h>
+#include <err.h>
+
+/* Insert -hmmdump, -lm, -svq4svq, -beam, -lminmemory into a hash and display it. */
+int
+main(int argc, char **argv)
+{
+    hash_table_t *ht;
+    ht = hash_table_new(75, 0);
+
+    if (hash_table_enter(ht, "-hmmdump", (void *)1) != (void *)1) {
+        E_FATAL("Insertion of -hmmdump failed\n");
+    }
+
+    if (hash_table_enter(ht, "-svq4svq", (void *)1) != (void *)1) {
+        E_FATAL("Insertion of -svq4svq failed\n");
+    }
+
+    if (hash_table_enter(ht, "-lm", (void *)1) != (void *)1) {
+        E_FATAL("Insertion of -lm failed\n");
+    }
+
+    if (hash_table_enter(ht, "-beam", (void *)1) != (void *)1) {
+        E_FATAL("Insertion of -beam failed\n");
+    }
+
+    if (hash_table_enter(ht, "-lminmemory", (void *)1) != (void *)1) {
+        E_FATAL("Insertion of -lminmemory failed\n");
+    }
+
+    hash_table_display(ht, 1);
+
+    hash_table_free(ht);
+    ht = NULL;
+    return 0;
+}
+
+
+#if 0
+E_INFO("Hash table in the command line\n");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -lm\n");
+hash_table_delete(ht, "-lm");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -lm\n");
+
+hash_table_delete(ht, "-lm");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -svq4svq\n");
+hash_table_delete(ht, "-svq4svq");
+hash_table_display(ht, 1);
+
+E_INFO("After deletion of -beam\n");
+hash_table_delete(ht, "-beam");
+hash_table_display(ht, 1);
+#endif

src/tests/libs/sphinx/test_hash/display.res

@@ +1 @@
+Hash with chaining representation of the hash table
+|key:-hmmdump|len:8|val=1|->NULL
+|key:-svq4svq|len:8|val=1|->|key:-lminmemory|len:11|val=1|->NULL
+|key:-lm|len:3|val=1|->NULL
+|key:-beam|len:5|val=1|->NULL
+The total number of keys =5

src/tests/libs/sphinx/test_hash/_hash_delete1.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./deletehash -lm > _hash_delete1.out 2>&1 
+compare_table delete1 _hash_delete1.out $tests/unit/test_hash/_hash_delete1.res
+rm -f _hash_delete1.out

src/tests/libs/sphinx/test_hash/_hash_delete2.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./deletehash -subvq > _hash_delete2.out 2>&1 
+compare_table delete2 _hash_delete2.out $tests/unit/test_hash/_hash_delete2.res
+rm -f _hash_delete2.out
+ No newline at end of file

src/tests/libs/sphinx/test_hash/_hash_delete3.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./deletehash -svq4svq > _hash_delete3.out 2>&1 
+compare_table delete3 _hash_delete3.out $tests/unit/test_hash/_hash_delete3.res
+rm -f _hash_delete3.out
+ No newline at end of file

src/tests/libs/sphinx/test_hash/_hash_delete4.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./deletehash -hmmdump > _hash_delete4.out 2>&1 
+compare_table delete4 _hash_delete4.out $tests/unit/test_hash/_hash_delete4.res
+rm -f _hash_delete4.out
+ No newline at end of file

src/tests/libs/sphinx/test_hash/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_hash ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest deletehash : deletehash.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest displayhash : displayhash.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_hash_iter : test_hash_iter.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_hash/_hash_delete5.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./deletehash -foo > _hash_delete5.out 2>&1 
+compare_table delete5 _hash_delete5.out $tests/unit/test_hash/_hash_delete5.res
+rm -f _hash_delete5.out
+ No newline at end of file

src/tests/libs/sphinx/test_hash/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define EPSILON 0.001
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)

src/tests/libs/sphinx/test_hash/_hash_delete1.res

@@ +1 @@
+Hash with chaining representation of the hash table
+|key:-bla|len:4|val=8|->NULL
+|key:-hmmdump|len:8|val=1|->|key:-subvq|len:6|val=7|->|key:-outlatdir|len:10|val=3|->NULL
+|key:-svq4svq|len:8|val=2|->|key:-lminmemory|len:11|val=6|->NULL
+|key:-beam|len:5|val=5|->NULL
+The total number of keys =7

src/tests/libs/sphinx/test_hash/_hash_delete2.res

@@ +1 @@
+Hash with chaining representation of the hash table
+|key:-bla|len:4|val=8|->NULL
+|key:-hmmdump|len:8|val=1|->|key:-outlatdir|len:10|val=3|->NULL
+|key:-svq4svq|len:8|val=2|->|key:-lminmemory|len:11|val=6|->NULL
+|key:-lm|len:3|val=4|->NULL
+|key:-beam|len:5|val=5|->NULL
+The total number of keys =7

src/tests/libs/sphinx/sphinx_lmtools/sphinx_lm_convert.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 2009 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 sphinx_lm_convert.c
+ * Language model conversion tool.
+ */
+#include <logmath.h>
+#include <ngram_model.h>
+#include <cmd_ln.h>
+#include <ckd_alloc.h>
+#include <err.h>
+#include <pio.h>
+#include <strfuncs.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+static const arg_t defn[] = {
+  { "-help",
+    ARG_BOOLEAN,
+    "no",
+    "Shows the usage of the tool"},
+
+  { "-logbase",
+    ARG_FLOAT64,
+    "1.0001",
+    "Base in which all log-likelihoods calculated" },
+
+  { "-i",
+    REQARG_STRING,
+    NULL,
+    "Input language model file (required)"},
+
+  { "-o",
+    REQARG_STRING,
+    NULL,
+    "Output language model file (required)"},
+
+  { "-ifmt",
+    ARG_STRING,
+    NULL,
+    "Input language model format (will guess if not specified)"},
+
+  { "-ofmt",
+    ARG_STRING,
+    NULL,
+    "Output language model file (will guess if not specified)"},
+
+  { "-ienc",
+    ARG_STRING,
+    NULL,
+    "Input language model text encoding (no conversion done if not specified)"},
+
+  { "-oenc",
+    ARG_STRING,
+    "utf8",
+    "Output language model text encoding"},
+
+  { "-case",
+    ARG_STRING,
+    NULL,
+    "Ether 'lower' or 'upper' - case fold to lower/upper case (NOT UNICODE AWARE)" },
+
+  { "-mmap",
+    ARG_BOOLEAN,
+    "no",
+    "Use memory-mapped I/O for reading binary LM files"},
+
+  { "-debug",
+    ARG_INT32,
+    NULL,
+    "Verbosity level for debugging messages"
+  },
+
+  { NULL, 0, NULL, NULL }
+};
+
+int
+main(int argc, char *argv[])
+{
+    cmd_ln_t *config;
+    ngram_model_t *lm = NULL;
+    logmath_t *lmath;
+        int itype, otype;
+        char const *kase;
+
+    if ((config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE)) == NULL)
+        return 1;
+
+        err_set_debug_level(cmd_ln_int32_r(config, "-debug"));
+
+    /* Create log math object. */
+    if ((lmath = logmath_init
+         (cmd_ln_float64_r(config, "-logbase"), 0, 0)) == NULL) {
+        E_FATAL("Failed to initialize log math\n");
+    }
+
+    /* Load the input language model. */
+        if (cmd_ln_str_r(config, "-ifmt")) {
+            if ((itype = ngram_str_to_type(cmd_ln_str_r(config, "-ifmt")))
+                == NGRAM_INVALID) {
+                E_ERROR("Invaild input type %s\n", cmd_ln_str_r(config, "-ifmt"));
+                goto error_out;
+            }
+            lm = ngram_model_read(config, cmd_ln_str_r(config, "-i"),
+                                  itype, lmath);
+        }
+        else {
+            lm = ngram_model_read(config, cmd_ln_str_r(config, "-i"),
+                                  NGRAM_AUTO, lmath);
+    }
+
+        /* Guess or set the output language model type. */
+        if (cmd_ln_str_r(config, "-ofmt")) {
+            if ((otype = ngram_str_to_type(cmd_ln_str_r(config, "-ofmt")))
+                == NGRAM_INVALID) {
+                E_ERROR("Invaild output type %s\n", cmd_ln_str_r(config, "-ofmt"));
+                goto error_out;
+            }
+        }
+        else {
+            otype = ngram_file_name_to_type(cmd_ln_str_r(config, "-o"));
+        }
+
+        /* Recode the language model if desired. */
+        if (cmd_ln_str_r(config, "-ienc")) {
+            if (ngram_model_recode(lm, cmd_ln_str_r(config, "-ienc"),
+                                   cmd_ln_str_r(config, "-oenc")) != 0) {
+                E_ERROR("Failed to recode language model from %s to %s\n",
+                        cmd_ln_str_r(config, "-ienc"),
+                        cmd_ln_str_r(config, "-oenc"));
+                goto error_out;
+            }
+        }
+
+        /* Case fold if requested. */
+        if ((kase = cmd_ln_str_r(config, "-case"))) {
+            if (0 == strcmp(kase, "lower")) {
+                ngram_model_casefold(lm, NGRAM_LOWER);
+            }
+            else if (0 == strcmp(kase, "upper")) {
+                ngram_model_casefold(lm, NGRAM_UPPER);
+            }
+            else {
+                E_ERROR("Unknown value for -case: %s\n", kase);
+                goto error_out;
+            }
+        }
+
+        /* Write the output language model. */
+        if (ngram_model_write(lm, cmd_ln_str_r(config, "-o"), otype) != 0) {
+            E_ERROR("Failed to write language model in format %s to %s\n",
+                    ngram_type_to_str(otype), cmd_ln_str_r(config, "-o"));
+            goto error_out;
+        }
+
+        /* That's all folks! */
+        ngram_model_free(lm);
+    return 0;
+
+error_out:
+        ngram_model_free(lm);
+    return 1;
+}

src/tests/libs/sphinx/sphinx_lmtools/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx sphinx_lmtools ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libssphinxbase ;
+
+SimpleTest sphinx_lm_eval : sphinx_lm_eval.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest sphinx_lm_convert : sphinx_lm_convert.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/sphinx_lmtools/sphinx_lm_eval.c

@@ +1 @@
+/* -*- 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 sphinx_lm_eval.c
+ * Language model evaluation tool.
+ */
+#include <logmath.h>
+#include <ngram_model.h>
+#include <cmd_ln.h>
+#include <ckd_alloc.h>
+#include <err.h>
+#include <pio.h>
+#include <strfuncs.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+static const arg_t defn[] = {
+  { "-help",
+    ARG_BOOLEAN,
+    "no",
+    "Shows the usage of the tool"},
+
+  { "-logbase",
+    ARG_FLOAT64,
+    "1.0001",
+    "Base in which all log-likelihoods calculated" },
+
+  { "-lm",
+    ARG_STRING,
+    NULL,
+    "Language model file"},
+
+  { "-probdef",
+    ARG_STRING,
+    NULL,
+    "Probability definition file for classes in LM"},
+
+  { "-lmctlfn",
+    ARG_STRING,
+    NULL,
+    "Control file listing a set of language models"},
+
+  { "-lmname",
+    ARG_STRING,
+    NULL,
+    "Name of language model in -lmctlfn to use for all utterances" },
+
+  { "-lsn",
+    ARG_STRING,
+    NULL,
+    "Transcription file to evaluate"},
+
+  { "-text",
+    ARG_STRING,
+    "Text string to evaluate"},
+
+  { "-mmap",
+    ARG_BOOLEAN,
+    "no",
+    "Use memory-mapped I/O for reading binary LM files"},
+
+  { "-lw",
+    ARG_FLOAT32,
+    "1.0",
+    "Language model weight" },
+
+  { "-wip",
+    ARG_FLOAT32,
+    "1.0",
+    "Word insertion probability" },
+
+  { "-uw",
+    ARG_FLOAT32,
+    "1.0",
+    "Unigram probability weight (interpolated with uniform distribution)"},
+
+  /* FIXME: Support -lmstartsym, -lmendsym, -lmctlfn, -ctl_lm */
+  { NULL, 0, NULL, NULL }
+};
+
+static int
+calc_entropy(ngram_model_t *lm, char **words, int32 n,
+         int32 *out_n_ccs, int32 *out_n_oovs)
+{
+    int32 *wids;
+    int32 startwid;
+    int32 i, ch, nccs, noovs, unk;
+
+        if (n == 0)
+            return 0;
+
+        unk = ngram_unknown_wid(lm);
+
+    /* Reverse this array into an array of word IDs. */
+    wids = ckd_calloc(n, sizeof(*wids));
+    for (i = 0; i < n; ++i)
+        wids[n-i-1] = ngram_wid(lm, words[i]);
+    /* Skip <s> as it's a context cue (HACK, this should be configurable). */
+    startwid = ngram_wid(lm, "<s>");
+
+    /* Now evaluate the list of words in reverse using the
+     * remainder of the array as the history. */
+    ch = noovs = nccs = 0;
+    for (i = 0; i < n; ++i) {
+        int32 n_used;
+        int32 prob;
+
+        /* Skip <s> as it's a context cue (HACK, this should be configurable). */
+        if (wids[i] == startwid) {
+            ++nccs;
+            continue;
+        }
+        /* Skip and count OOVs. */
+        if (wids[i] == NGRAM_INVALID_WID || wids[i] == unk) {
+            ++noovs;
+            continue;
+        }
+        /* Sum up information for each N-gram */
+        prob = ngram_ng_score(lm,
+                      wids[i], wids + i + 1,
+                      n - i - 1, &n_used);
+        ch -= prob;
+    }
+
+    if (out_n_ccs) *out_n_ccs = nccs;
+    if (out_n_oovs) *out_n_oovs = noovs;
+
+    /* Calculate cross-entropy CH = - 1/N sum log P(W|H) */
+        n -= (nccs + noovs);
+        if (n <= 0)
+            return 0;
+    return ch / n;
+}
+
+static void
+evaluate_file(ngram_model_t *lm, logmath_t *lmath, const char *lsnfn)
+{
+    FILE *fh;
+        lineiter_t *litor;
+    int32 nccs, noovs, nwords;
+    float64 ch, log_to_log2;;
+
+    if ((fh = fopen(lsnfn, "r")) == NULL)
+        E_FATAL_SYSTEM("failed to open transcript file %s", lsnfn);
+
+    /* We have to keep ch in floating-point to avoid overflows, so
+     * we might as well use log2. */
+    log_to_log2 = log(logmath_get_base(lmath)) / log(2);
+    nccs = noovs = nwords = 0;
+    ch = 0.0;
+        for (litor = lineiter_start(fh); litor; litor = lineiter_next(litor)) {
+        char **words;
+        int32 n, tmp_ch, tmp_noovs, tmp_nccs;
+
+        n = str2words(litor->buf, NULL, 0);
+        if (n < 0)
+            E_FATAL("str2words(line, NULL, 0) = %d, should not happen\n", n);
+        if (n == 0) /* Do nothing! */
+            continue;
+        words = ckd_calloc(n, sizeof(*words));
+        str2words(litor->buf, words, n);
+
+        /* Remove any utterance ID (FIXME: has to be a single "word") */
+        if (words[n-1][0] == '('
+            && words[n-1][strlen(words[n-1])-1] == ')')
+            n = n - 1;
+
+        tmp_ch = calc_entropy(lm, words, n, &tmp_nccs, &tmp_noovs);
+
+        ch += (float64) tmp_ch * (n - tmp_nccs - tmp_noovs) * log_to_log2;
+        nccs += tmp_nccs;
+        noovs += tmp_noovs;
+        nwords += n;
+        
+        ckd_free(words);
+    }
+
+    ch /= (nwords - nccs - noovs);
+    printf("cross-entropy: %f bits\n", ch);
+
+    /* Calculate perplexity pplx = exp CH */
+    printf("perplexity: %f\n", pow(2.0, ch));
+
+    /* Report OOVs and CCs */
+    printf("%d words evaluated\n", nwords);
+    printf("%d OOVs (%.2f%%), %d context cues removed\n",
+           noovs, (double)noovs / nwords * 100, nccs);
+}
+
+static void
+evaluate_string(ngram_model_t *lm, logmath_t *lmath, const char *text)
+{
+    char *textfoo;
+    char **words;
+    int32 n, ch, noovs, nccs;
+
+    /* Split it into an array of strings. */
+    textfoo = ckd_salloc(text);
+    n = str2words(textfoo, NULL, 0);
+    if (n < 0)
+        E_FATAL("str2words(textfoo, NULL, 0) = %d, should not happen\n", n);
+    if (n == 0) /* Do nothing! */
+        return;
+    words = ckd_calloc(n, sizeof(*words));
+    str2words(textfoo, words, n);
+
+    ch = calc_entropy(lm, words, n, &nccs, &noovs);
+
+    printf("input: %s\n", text);
+    printf("cross-entropy: %f bits\n",
+           ch * log(logmath_get_base(lmath)) / log(2));
+
+    /* Calculate perplexity pplx = exp CH */
+    printf("perplexity: %f\n", logmath_exp(lmath, ch));
+
+    /* Report OOVs and CCs */
+    printf("%d words evaluated\n", n);
+    printf("%d OOVs, %d context cues removed\n",
+          noovs, nccs);
+
+    ckd_free(textfoo);
+    ckd_free(words);
+}
+
+int
+main(int argc, char *argv[])
+{
+    cmd_ln_t *config;
+    ngram_model_t *lm = NULL;
+    logmath_t *lmath;
+    const char *lmfn, *probdefn, *lsnfn, *text;
+
+    if ((config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE)) == NULL)
+        return 1;
+
+    /* Create log math object. */
+    if ((lmath = logmath_init
+         (cmd_ln_float64_r(config, "-logbase"), 0, 0)) == NULL) {
+        E_FATAL("Failed to initialize log math\n");
+    }
+
+    /* Load the language model. */
+    lmfn = cmd_ln_str_r(config, "-lm");
+    if (lmfn == NULL
+        || (lm = ngram_model_read(config, lmfn,
+                      NGRAM_AUTO, lmath)) == NULL) {
+        E_FATAL("Failed to load language model from %s\n",
+            cmd_ln_str_r(config, "-lm"));
+    }
+        if ((probdefn = cmd_ln_str_r(config, "-probdef")) != NULL)
+            ngram_model_read_classdef(lm, probdefn);
+        ngram_model_apply_weights(lm,
+                                  cmd_ln_float32_r(config, "-lw"),
+                                  cmd_ln_float32_r(config, "-wip"),
+                                  cmd_ln_float32_r(config, "-uw"));
+
+    /* Now evaluate some text. */
+    lsnfn = cmd_ln_str_r(config, "-lsn");
+    text = cmd_ln_str_r(config, "-text");
+    if (lsnfn) {
+        evaluate_file(lm, lmath, lsnfn);
+    }
+    else if (text) {
+        evaluate_string(lm, lmath, text);
+    }
+
+    return 0;
+}

src/tests/libs/sphinx/sphinx_fe/sphinx_wave2feat.h

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1996-2004 Carnegie Mellon University.  All rights 
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * This work was supported in part by funding from the Defense Advanced 
+ * Research Projects Agency and the National Science Foundation of the 
+ * United States of America, and the CMU Sphinx Speech Consortium.
+ *
+ * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND 
+ * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
+ * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ====================================================================
+ *
+ */
+#ifndef __SPHINX_FE_H__
+#define __SPHINX_FE_H__
+
+/**
+ * Waveform to feature converter object.
+ */
+typedef struct sphinx_wave2feat_s sphinx_wave2feat_t;
+
+/**
+ * Initialize waveform to feature converter.
+ */
+sphinx_wave2feat_t *sphinx_wave2feat_init(cmd_ln_t *config);
+
+/**
+ * Release a waveform to feature converter.
+ */
+int sphinx_wave2feat_free(sphinx_wave2feat_t *w2f);
+
+/**
+ * Retain a waveform to feature converter.
+ */
+sphinx_wave2feat_t *sphinx_wave2feat_retain(sphinx_wave2feat_t *w2f);
+
+/**
+ * Convert one file.
+ */
+int sphinx_wave2feat_convert_file(sphinx_wave2feat_t *w2f,
+                  char const *infile, char const *outfile);
+
+#endif /* __SPHINX_FE_H__ */

src/tests/libs/sphinx/sphinx_fe/sphinx_fe.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1996-2004 Carnegie Mellon University.  All rights 
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * This work was supported in part by funding from the Defense Advanced 
+ * Research Projects Agency and the National Science Foundation of the 
+ * United States of America, and the CMU Sphinx Speech Consortium.
+ *
+ * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND 
+ * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
+ * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ====================================================================
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "fe.h"
+#include "strfuncs.h"
+#include "pio.h"
+#include "filename.h"
+#include "cmd_ln.h"
+#include "err.h"
+#include "ckd_alloc.h"
+#include "byteorder.h"
+
+#include "sphinx_wave2feat.h"
+#include "cmd_ln_defn.h"
+
+typedef struct audio_type_s {
+    char const *name;
+    int (*detect)(sphinx_wave2feat_t *wtf, char const *infile);
+    int (*decode)(sphinx_wave2feat_t *wtf);
+} audio_type_t;
+
+typedef struct output_type_s {
+    char const *name;
+    int (*output_header)(sphinx_wave2feat_t *wtf, int nfloat);
+    int (*output_frames)(sphinx_wave2feat_t *wtf, mfcc_t **frames, int nfr);
+} output_type_t;
+
+struct sphinx_wave2feat_s {
+    int refcount;     /**< Reference count. */
+    cmd_ln_t *config; /**< Configuration parameters. */
+    fe_t *fe;         /**< Front end object. */
+    char *infile;     /**< Path to input file. */
+    char *outfile;    /**< Path to output file. */
+    FILE *infh;       /**< Input file handle. */
+    FILE *outfh;      /**< Output file handle. */
+    short *audio;     /**< Audio buffer. */
+    mfcc_t **feat;    /**< Feature buffer. */
+    int blocksize;    /**< Size of audio buffer. */
+    int featsize;     /**< Size of feature buffer. */
+    int veclen;       /**< Length of each output vector. */
+    int in_veclen;    /**< Length of each input vector (for cep<->spec). */
+    int byteswap;     /**< Whether byteswapping is necessary. */
+    output_type_t const *ot;/**< Output type object. */
+};
+
+/** RIFF 44-byte header structure for MS wav files. */
+typedef struct RIFFHeader{
+    char rifftag[4];      /* "RIFF" string */
+    int32 TotalLength;      /* Total length */
+    char wavefmttag[8];   /* "WAVEfmt " string (note space after 't') */
+    int32 RemainingLength;  /* Remaining length */
+    int16 data_format;    /* data format tag, 1 = PCM */
+    int16 numchannels;    /* Number of channels in file */
+    int32 SamplingFreq;     /* Sampling frequency */
+    int32 BytesPerSec;      /* Average bytes/sec */
+    int16 BlockAlign;     /* Block align */
+    int16 BitsPerSample;  /* 8 or 16 bit */
+    char datatag[4];      /* "data" string */
+    int32 datalength;       /* Raw data length */
+} MSWAV_hdr;
+
+/**
+ * Detect RIFF file and parse its header if detected.
+ *
+ * @return TRUE if it's a RIFF file, FALSE if not, -1 if an error occurred.
+ */
+static int
+detect_riff(sphinx_wave2feat_t *wtf, char const *infile)
+{
+    FILE *fh;
+    MSWAV_hdr hdr;
+
+    if ((fh = fopen(infile, "rb")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open %s", infile);
+        return -1;
+    }
+    if (fread(&hdr, sizeof(hdr), 1, fh) != 1) {
+        E_ERROR_SYSTEM("Failed to read RIFF header");
+        fclose(fh);
+        return -1;
+    }
+    /* Make sure it is actually a RIFF file. */
+    if (0 != memcmp(hdr.rifftag, "RIFF", 4))
+        return FALSE;
+
+    /* Get relevant information. */
+    cmd_ln_set_int32_r(wtf->config, "-nchans", hdr.numchannels);
+    cmd_ln_set_float32_r(wtf->config, "-samprate", hdr.SamplingFreq);
+    wtf->infile = ckd_salloc(infile);
+    wtf->infh = fh;
+
+    return TRUE;
+}
+
+/**
+ * Detect NIST file and parse its header if detected.
+ *
+ * @return TRUE if it's a NIST file, FALSE if not, -1 if an error occurred.
+ */
+static int
+detect_nist(sphinx_wave2feat_t *wtf, char const *infile)
+{
+    char nist[7];
+    lineiter_t *li;
+    FILE *fh;
+
+    if ((fh = fopen(infile, "rb")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open %s", infile);
+        return -1;
+    }
+    if (fread(&nist, 1, 7, fh) != 7) {
+        E_ERROR_SYSTEM("Failed to read NIST header");
+        fclose(fh);
+        return -1;
+    }
+    /* Is this actually a NIST file? */
+    if (0 != strncmp(nist, "NIST_1A", 7)) {
+        fclose(fh);
+        return FALSE;
+    }
+    /* Rewind, parse lines. */
+    fseek(fh, 0, SEEK_SET);
+    for (li = lineiter_start(fh); li; li = lineiter_next(li)) {
+        char **words;
+        int nword;
+
+        string_trim(li->buf, STRING_BOTH);
+        if (strlen(li->buf) == 0)
+            break;
+        nword = str2words(li->buf, NULL, 0);
+        if (nword != 3)
+            continue;
+        words = ckd_calloc(nword, sizeof(*words));
+        str2words(li->buf, words, nword);
+        if (0 == strcmp(words[0], "sample_rate")) {
+            cmd_ln_set_float32_r(wtf->config, "-samprate", atof_c(words[2]));
+        }
+        if (0 == strcmp(words[0], "channel_count")) {
+            cmd_ln_set_float32_r(wtf->config, "-nchans", atoi(words[2]));
+        }
+        if (0 == strcmp(words[0], "sample_byte_format")) {
+            cmd_ln_set_str_r(wtf->config, "-input_endian",
+                             (0 == strcmp(words[2], "10")) ? "big" : "little");
+        }
+        /* FIMXE: Warn about shorten-compressed data. */
+        ckd_free(words);
+    }
+    fseek(fh, 1024, SEEK_SET);
+    wtf->infile = ckd_salloc(infile);
+    wtf->infh = fh;
+    return TRUE;
+}
+
+
+/**
+ * Default "detection" function, just opens the file and keeps the
+ * default configuration parameters.
+ *
+ * @return TRUE, or -1 on error.
+ */
+static int
+detect_raw(sphinx_wave2feat_t *wtf, char const *infile)
+{
+    FILE *fh;
+
+    if ((fh = fopen(infile, "rb")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open %s", infile);
+        return -1;
+    }
+    wtf->infile = ckd_salloc(infile);
+    wtf->infh = fh;
+    return TRUE;
+}
+
+/**
+ * "Detect" Sphinx MFCC files, meaning verify their lousy headers, and
+ * set up some parameters from the config object.
+ *
+ * @return TRUE, or -1 on error.
+ */
+static int
+detect_sphinx_mfc(sphinx_wave2feat_t *wtf, char const *infile)
+{
+    FILE *fh;
+    int32 len;
+    long flen;
+
+    if ((fh = fopen(infile, "rb")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open %s", infile);
+        return -1;
+    }
+    if (fread(&len, 4, 1, fh) != 1) {
+        E_ERROR_SYSTEM("Failed to read header from %s\n", infile);
+        return -1;
+    }
+    fseek(fh, 0, SEEK_END);
+    flen = ftell(fh);
+
+    /* figure out whether to byteswap */
+    flen = (flen / 4) - 1;
+    if (flen != len) {
+        /* First make sure this is an endianness problem, otherwise fail. */
+        SWAP_INT32(&len);
+        if (flen != len) {
+            SWAP_INT32(&len);
+            E_ERROR("Mismatch in header/file lengths: 0x%08x vs 0x%08x\n",
+                    len, flen);
+            return -1;
+        }
+        /* Set the input endianness to the opposite of the machine endianness... */
+        cmd_ln_set_str_r(wtf->config, "-input_endian",
+                         (0 == strcmp("big", cmd_ln_str_r(wtf->config, "-mach_endian"))
+                          ? "little" : "big"));
+    }
+    
+    fseek(fh, 4, SEEK_SET);
+    wtf->infile = ckd_salloc(infile);
+    wtf->infh = fh;
+    if (cmd_ln_boolean_r(wtf->config, "-spec2cep")) {
+        wtf->in_veclen = cmd_ln_int32_r(wtf->config, "-nfilt");
+    }
+    else if (cmd_ln_boolean_r(wtf->config, "-cep2spec")) {
+        wtf->in_veclen = cmd_ln_int32_r(wtf->config, "-ncep");
+        wtf->veclen = cmd_ln_int32_r(wtf->config, "-nfilt");
+    }
+    else {
+        /* Should not happen. */
+        E_ERROR("Sphinx MFCC file reading requested but -spec2cep/-cep2spec not given\n");
+        assert(FALSE);
+    }
+            
+    return TRUE;
+}
+
+/**
+ * Process PCM audio from a filehandle.  Assume that wtf->infh is
+ * positioned just after the file header.
+ */
+static int
+decode_pcm(sphinx_wave2feat_t *wtf)
+{
+    size_t nsamp;
+    int32 nfr;
+    int nfloat, n;
+
+    fe_start_utt(wtf->fe);
+    nfloat = 0;
+    while ((nsamp = fread(wtf->audio, 2, wtf->blocksize, wtf->infh)) != 0) {
+        size_t nvec;
+        int16 const *inspeech;
+
+        /* Byteswap stuff here if necessary. */
+        if (wtf->byteswap) {
+            for (n = 0; n < nsamp; ++n)
+                SWAP_INT16(wtf->audio + n);
+        }
+            
+        inspeech = wtf->audio;
+        nvec = wtf->featsize;
+        /* Consume all samples. */
+        while (nsamp) {
+            nfr = nvec;
+            fe_process_frames(wtf->fe, &inspeech, &nsamp, wtf->feat, &nfr);
+            if (nfr) {
+                if ((n = (*wtf->ot->output_frames)(wtf, wtf->feat, nfr)) < 0)
+                    return -1;
+                nfloat += n;
+            }
+        }
+        inspeech = wtf->audio;
+    }
+    /* Now process any leftover audio frames. */
+    fe_end_utt(wtf->fe, wtf->feat[0], &nfr);
+    if (nfr) {
+        if ((n = (*wtf->ot->output_frames)(wtf, wtf->feat, nfr)) < 0)
+            return -1;
+        nfloat += n;
+    }
+
+    fclose(wtf->infh);
+    wtf->infh = NULL;
+    return nfloat;
+}
+
+/**
+ * Process Sphinx MFCCs/logspectra from a filehandle.  Assume that
+ * wtf->infh is positioned just after the file header.
+ */
+static int
+decode_sphinx_mfc(sphinx_wave2feat_t *wtf)
+{
+    int nfloat = 0, n;
+    int featsize = wtf->featsize;
+
+    /* If the input vector length is less than the output length, we
+     * need to do this one frame at a time, because there's empty
+     * space at the end of each vector in wtf->feat. */
+    if (wtf->in_veclen < wtf->veclen)
+        featsize = 1;
+    while ((n = fread(wtf->feat[0], sizeof(**wtf->feat),
+                      featsize * wtf->in_veclen, wtf->infh)) != 0) {
+        int i, nfr = n / wtf->in_veclen;
+        if (n % wtf->in_veclen) {
+            E_ERROR("Size of file %d not a multiple of veclen %d\n",
+                    n, wtf->in_veclen);
+            return -1;
+        }
+        /* Byteswap stuff here if necessary. */
+        if (wtf->byteswap) {
+            for (i = 0; i < n; ++i)
+                SWAP_FLOAT32(wtf->feat[0] + i);
+        }
+        fe_float_to_mfcc(wtf->fe, (float32 **)wtf->feat, wtf->feat, nfr);
+        for (i = 0; i < nfr; ++i) {
+            if (cmd_ln_boolean_r(wtf->config, "-spec2cep")) {
+                if (0 == strcmp(cmd_ln_str_r(wtf->config, "-transform"), "legacy"))
+                    fe_logspec_to_mfcc(wtf->fe, wtf->feat[i], wtf->feat[i]);
+                else
+                    fe_logspec_dct2(wtf->fe, wtf->feat[i], wtf->feat[i]);
+            }
+            else if (cmd_ln_boolean_r(wtf->config, "-cep2spec")) {
+                fe_mfcc_dct3(wtf->fe, wtf->feat[i], wtf->feat[i]);
+            }
+        }
+        if ((n = (*wtf->ot->output_frames)(wtf, wtf->feat, nfr)) < 0)
+            return -1;
+        nfloat += n;
+    }
+
+    fclose(wtf->infh);
+    wtf->infh = NULL;
+    return nfloat;
+}
+
+static const audio_type_t types[] = {
+    { "-mswav", &detect_riff, &decode_pcm },
+    { "-nist", &detect_nist, &decode_pcm },
+#ifdef HAVE_SNDFILE
+    { "-sndfile", &detect_sndfile, &decode_sndfile },
+#endif
+    { "-raw", &detect_raw, &decode_pcm }
+};
+static const int ntypes = sizeof(types)/sizeof(types[0]);
+static const audio_type_t mfcc_type = {
+    "sphinx_mfc", &detect_sphinx_mfc, &decode_sphinx_mfc
+};
+
+/**
+ * Output sphinx format "header"
+ *
+ * @return 0 for success, <0 for error.
+ */
+static int
+output_header_sphinx(sphinx_wave2feat_t *wtf, int32 nfloat)
+{
+    if (fwrite(&nfloat, 4, 1, wtf->outfh) != 1) {
+        E_ERROR_SYSTEM("Failed to write to %s", wtf->outfile);
+        return -1;
+    }
+    return 0;
+}
+
+/**
+ * Output frames in sphinx format.
+ *
+ * @return 0 for success, <0 for error.
+ */
+static int
+output_frames_sphinx(sphinx_wave2feat_t *wtf, mfcc_t **frames, int nfr)
+{
+    int i, nfloat = 0;
+
+    fe_mfcc_to_float(wtf->fe, frames, (float32 **)frames, nfr);
+    for (i = 0; i < nfr; ++i) {
+        if (fwrite(frames[i], sizeof(float32), wtf->veclen, wtf->outfh) != wtf->veclen) {
+            E_ERROR_SYSTEM("Writing %d values to %s failed",
+                           wtf->veclen, wtf->outfile);
+            return -1;
+        }
+        nfloat += wtf->veclen;
+    }
+    return nfloat;
+}
+
+typedef enum htk_feature_kind_e {
+    WAVEFORM = 0,   /* PCM audio (rarely used) */
+    LPC = 1,        /* LPC filter coefficients */
+    LPCREFC = 2,    /* LPC reflection coefficients */
+    LPCEPSTRA = 3,  /* LPC-based cepstral coefficients */
+    LPCDELCEP = 4,  /* LPCC plus deltas */
+    IREFC = 5,      /* 16-bit integer LPC reflection coefficients */
+    MFCC = 6,       /* MFCCs */
+    FBANK = 7,      /* Log mel spectrum */
+    MELSPEC = 8,    /* Linear mel spectrum */
+    USER = 9,       /* User defined */
+    DISCRETE = 10,  /* Vector quantized data */
+    PLP = 11        /* PLP coefficients */
+} htk_feature_kind_t;
+
+typedef enum htk_feature_flag_e {
+    _E = 0000100, /* has energy */
+    _N = 0000200, /* absolute energy supressed */
+    _D = 0000400, /* has delta coefficients */
+    _A = 0001000, /* has acceleration (delta-delta) coefficients */
+    _C = 0002000, /* is compressed */
+    _Z = 0004000, /* has zero mean static coefficients (i.e. CMN) */
+    _K = 0010000, /* has CRC checksum */
+    _O = 0020000, /* has 0th cepstral coefficient */
+    _V = 0040000, /* has VQ data */
+    _T = 0100000  /* has third differential coefficients */
+} htk_feature_flag_t;
+
+/**
+ * Output HTK format header.
+ */
+static int
+output_header_htk(sphinx_wave2feat_t *wtf, int32 nfloat)
+{
+    int32 samp_period;
+    int16 samp_size;
+    int16 param_kind;
+    int swap = FALSE;
+
+    /* HTK files are big-endian. */
+    if (0 == strcmp("little", cmd_ln_str_r(wtf->config, "-mach_endian")))
+        swap = TRUE;
+    /* Same file size thing as in Sphinx files (I think) */
+    if (swap) SWAP_INT32(&nfloat);
+    if (fwrite(&nfloat, 4, 1, wtf->outfh) != 1)
+        return -1;
+    /* Sample period in 100ns units. */
+    samp_period = (int32)(1e+7 / cmd_ln_float32_r(wtf->config, "-frate"));
+    if (swap) SWAP_INT32(&samp_period);
+    if (fwrite(&samp_period, 4, 1, wtf->outfh) != 1)
+        return -1;
+    /* Sample size - veclen * sizeof each sample. */
+    samp_size = wtf->veclen * 4;
+    if (swap) SWAP_INT16(&samp_size);
+    if (fwrite(&samp_size, 2, 1, wtf->outfh) != 1)
+        return -1;
+    /* Format and flags. */
+    if (cmd_ln_boolean_r(wtf->config, "-logspec")
+        || cmd_ln_boolean_r(wtf->config, "-cep2spec"))
+        param_kind = FBANK; /* log mel-filter bank outputs */
+    else
+        param_kind = MFCC | _O; /* MFCC + CEP0 (note reordering...) */
+    if (swap) SWAP_INT16(&param_kind);
+    if (fwrite(&param_kind, 2, 1, wtf->outfh) != 1)
+        return -1;
+
+    return 0;
+}
+
+/**
+ * Output frames in HTK format.
+ */
+static int
+output_frames_htk(sphinx_wave2feat_t *wtf, mfcc_t **frames, int nfr)
+{
+    int i, j, swap, htk_reorder, nfloat = 0;
+
+    fe_mfcc_to_float(wtf->fe, frames, (float32 **)frames, nfr);
+    /* This is possibly inefficient, but probably not a big deal. */
+    swap = (0 == strcmp("little", cmd_ln_str_r(wtf->config, "-mach_endian")));
+    htk_reorder = (0 == strcmp("htk", wtf->ot->name)
+                   && !(cmd_ln_boolean_r(wtf->config, "-logspec")
+                        || cmd_ln_boolean_r(wtf->config, "-cep2spec")));
+    for (i = 0; i < nfr; ++i) {
+        if (htk_reorder) {
+            mfcc_t c0 = frames[i][0];
+            memmove(frames[i] + 1, frames[i], (wtf->veclen - 1) * 4);
+            frames[i][wtf->veclen - 1] = c0;
+        }
+        if (swap)
+            for (j = 0; j < wtf->veclen; ++j)
+                SWAP_FLOAT32(frames[i] + j);
+        if (fwrite(frames[i], sizeof(float32), wtf->veclen, wtf->outfh) != wtf->veclen) {
+            E_ERROR_SYSTEM("Writing %d values to %s failed",
+                           wtf->veclen, wtf->outfile);
+            return -1;
+        }
+        nfloat += wtf->veclen;
+    }
+    return nfloat;
+}
+
+/**
+ * Output frames in text format.
+ */
+static int
+output_frames_text(sphinx_wave2feat_t *wtf, mfcc_t **frames, int nfr)
+{
+    int i, j, nfloat = 0;
+
+    fe_mfcc_to_float(wtf->fe, frames, (float32 **)frames, nfr);
+    for (i = 0; i < nfr; ++i) {
+        for (j = 0; j < wtf->veclen; ++j) {
+            fprintf(wtf->outfh, "%.5g", frames[i][j]);
+            if (j == wtf->veclen - 1)
+                fprintf(wtf->outfh, "\n");
+            else
+                fprintf(wtf->outfh, " ");
+        }
+        nfloat += wtf->veclen;
+    }
+    return nfloat;
+}
+
+static const output_type_t outtypes[] = {
+    { "sphinx", &output_header_sphinx, &output_frames_sphinx },
+    { "htk", &output_header_htk, &output_frames_htk },
+    { "text", NULL, &output_frames_text }
+};
+static const int nouttypes = sizeof(outtypes)/sizeof(outtypes[0]);
+
+sphinx_wave2feat_t *
+sphinx_wave2feat_init(cmd_ln_t *config)
+{
+    sphinx_wave2feat_t *wtf;
+    int i;
+
+    wtf = ckd_calloc(1, sizeof(*wtf));
+    wtf->refcount = 1;
+    wtf->config = cmd_ln_retain(config);
+    wtf->fe = fe_init_auto_r(wtf->config);
+    wtf->ot = outtypes; /* Default (sphinx) type. */
+    for (i = 0; i < nouttypes; ++i) {
+        output_type_t const *otype = &outtypes[i];
+        if (0 == strcmp(cmd_ln_str_r(config, "-ofmt"), otype->name)) {
+            wtf->ot = otype;
+            break;
+        }
+    }
+    if (i == nouttypes) {
+        E_ERROR("Unknown output type: '%s'\n",
+                cmd_ln_str_r(config, "-ofmt"));
+        sphinx_wave2feat_free(wtf);
+        return NULL;
+    }
+
+    return wtf;
+}
+
+int
+sphinx_wave2feat_free(sphinx_wave2feat_t *wtf)
+{
+    if (wtf == NULL)
+        return 0;
+    if (--wtf->refcount > 0)
+        return wtf->refcount;
+
+    ckd_free(wtf->audio);
+    ckd_free_2d(wtf->feat);
+    ckd_free(wtf->infile);
+    ckd_free(wtf->outfile);
+    if (wtf->infh)
+        fclose(wtf->infh);
+    if (wtf->outfh)
+        fclose(wtf->outfh);
+    cmd_ln_free_r(wtf->config);
+    fe_free(wtf->fe);
+    ckd_free(wtf);
+
+    return 0;
+}
+
+sphinx_wave2feat_t *
+sphinx_wave2feat_retain(sphinx_wave2feat_t *wtf)
+{
+    ++wtf->refcount;
+    return wtf;
+}
+
+static audio_type_t const *
+detect_audio_type(sphinx_wave2feat_t *wtf, char const *infile)
+{
+    audio_type_t const *atype;
+    int i;
+
+    /* Special case audio type for Sphinx MFCC inputs. */
+    if (cmd_ln_boolean_r(wtf->config, "-spec2cep")
+        || cmd_ln_boolean_r(wtf->config, "-cep2spec")) {
+        int rv = mfcc_type.detect(wtf, infile);
+        if (rv == -1)
+            return NULL;
+        return &mfcc_type;
+    }
+
+    /* Try to use the type of infile given on the command line. */
+    for (i = 0; i < ntypes; ++i) {
+        int rv;
+        atype = &types[i];
+        if (cmd_ln_boolean_r(wtf->config, atype->name)) {
+            rv = (*atype->detect)(wtf, infile);
+            if (rv == -1)
+                return NULL;
+            break;
+        }
+    }
+    if (i == ntypes) {
+        /* Detect file type of infile and get parameters. */
+        for (i = 0; i < ntypes; ++i) {
+            int rv;
+            atype = &types[i];
+            rv = (*atype->detect)(wtf, infile);
+            if (rv == -1)
+                return NULL;
+            else if (rv == TRUE)
+            break;
+        }
+        if (i == ntypes)
+            atype = NULL;
+    }
+    return atype;
+}
+
+int
+sphinx_wave2feat_convert_file(sphinx_wave2feat_t *wtf,
+                              char const *infile, char const *outfile)
+{
+    int minfft, nfft, nfloat, veclen;
+    audio_type_t const *atype;
+    int fshift, fsize;
+
+    if (cmd_ln_boolean_r(wtf->config, "-verbose"))
+        E_INFO("Converting %s to %s\n", infile, outfile);
+
+    /* Detect input file type. */
+    if ((atype = detect_audio_type(wtf, infile)) == NULL)
+        return -1;
+
+    /* Determine whether to byteswap input. */
+    wtf->byteswap = strcmp(cmd_ln_str_r(wtf->config, "-mach_endian"),
+                           cmd_ln_str_r(wtf->config, "-input_endian"));
+
+    /* Make sure the FFT size is sufficiently large. */
+    minfft = (int)(cmd_ln_float32_r(wtf->config, "-samprate")
+                   * cmd_ln_float32_r(wtf->config, "-wlen") + 0.5);
+    for (nfft = 1; nfft < minfft; nfft <<= 1)
+        ;
+    if (nfft > cmd_ln_int32_r(wtf->config, "-nfft")) {
+        E_WARN("Value of -nfft = %d is too small, increasing to %d\n",
+               cmd_ln_int32_r(wtf->config, "-nfft"), nfft);
+        cmd_ln_set_int32_r(wtf->config, "-nfft", nfft);
+        fe_free(wtf->fe);
+        wtf->fe = fe_init_auto_r(wtf->config);
+    }
+
+    /* Get the output frame size (if not already set). */
+    if (wtf->veclen == 0)
+        wtf->veclen = fe_get_output_size(wtf->fe);
+
+    /* Set up the input and output buffers. */
+    fe_get_input_size(wtf->fe, &fshift, &fsize);
+    /* Want to get at least a whole frame plus shift in here. */
+    wtf->blocksize = cmd_ln_int32_r(wtf->config, "-blocksize");
+    if (wtf->blocksize < fsize + fshift) {
+        E_INFO("Block size of %d too small, increasing to %d\n",
+               wtf->blocksize, fsize + fshift);
+        wtf->blocksize = fsize + fshift;
+    }
+    wtf->audio = ckd_calloc(wtf->blocksize, sizeof(*wtf->audio));
+    wtf->featsize = (wtf->blocksize - fsize) / fshift;
+
+    /* Use the maximum of the input and output frame sizes to allocate this. */
+    veclen = wtf->veclen;
+    if (wtf->in_veclen > veclen) veclen = wtf->in_veclen;
+    wtf->feat = ckd_calloc_2d(wtf->featsize, veclen, sizeof(**wtf->feat));
+
+    /* Let's go! */
+    if ((wtf->outfh = fopen(outfile, "wb")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open %s for writing", outfile);
+        return -1;
+    }
+    /* Write an empty header, which we'll fill in later. */
+    if (wtf->ot->output_header &&
+        (*wtf->ot->output_header)(wtf, 0) < 0) {
+        E_ERROR_SYSTEM("Failed to write empty header to %s\n", outfile);
+        goto error_out;
+    }
+    wtf->outfile = ckd_salloc(outfile);
+
+    if ((nfloat = (*atype->decode)(wtf)) < 0)
+        return -1;
+
+    if (wtf->ot->output_header) {
+        if (fseek(wtf->outfh, 0, SEEK_SET) < 0) {
+            E_ERROR_SYSTEM("Failed to seek to beginning of %s\n", outfile);
+            goto error_out;
+        }
+        if ((*wtf->ot->output_header)(wtf, nfloat) < 0) {
+            E_ERROR_SYSTEM("Failed to write header to %s\n", outfile);
+            goto error_out;
+        }
+    }
+    fclose(wtf->outfh);
+    wtf->outfh = NULL;
+
+    return 0;
+error_out:
+    if (wtf->outfh) {
+        fclose(wtf->outfh);
+        wtf->outfh = NULL;
+    }
+    return -1;
+}
+
+void
+build_filenames(cmd_ln_t *config, char const *basename,
+                char **out_infile, char **out_outfile)
+{
+    char const *di, *do_, *ei, *eo;
+
+    di = cmd_ln_str_r(config, "-di");
+    do_ = cmd_ln_str_r(config, "-do");
+    ei = cmd_ln_str_r(config, "-ei");
+    eo = cmd_ln_str_r(config, "-eo");
+
+    *out_infile = string_join(di ? di : "",
+                              di ? "/" : "",
+                              basename,
+                              ei ? "." : "",
+                              ei ? ei : "",
+                              NULL);
+    *out_outfile = string_join(do_ ? do_ : "",
+                               do_ ? "/" : "",
+                               basename,
+                               eo ? "." : "",
+                               eo ? eo : "",
+                              NULL);
+    /* Build output directory structure if possible/requested (it is
+     * by default). */
+    if (cmd_ln_boolean_r(config, "-build_outdirs")) {
+        char *dirname = ckd_salloc(*out_outfile);
+        path2dirname(*out_outfile, dirname);
+        build_directory(dirname);
+        ckd_free(dirname);
+    }
+}
+
+static int
+run_control_file(sphinx_wave2feat_t *wtf, char const *ctlfile)
+{
+    lineiter_t *li;
+    FILE *ctlfh;
+    int nskip, runlen, npart;
+
+    if ((ctlfh = fopen(ctlfile, "r")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open control file %s", ctlfile);
+        return -1;
+    }
+    nskip = cmd_ln_int32_r(wtf->config, "-nskip");
+    runlen = cmd_ln_int32_r(wtf->config, "-runlen");
+    if ((npart = cmd_ln_int32_r(wtf->config, "-npart"))) {
+        /* Count lines in the file. */
+        int nlines, partlen, part;
+        part = cmd_ln_int32_r(wtf->config, "-part");
+        for (nlines = 0, li = lineiter_start(ctlfh); li; li = lineiter_next(li))
+            ++nlines;
+        fseek(ctlfh, 0, SEEK_SET);
+        partlen = nlines / npart;
+        nskip = partlen * (part - 1);
+        if (part == npart)
+            runlen = -1;
+        else
+            runlen = partlen;
+    }
+    if (runlen != -1)
+        E_INFO("Processing %d utterances at position %d\n", runlen, nskip);
+    else
+        E_INFO("Processing all remaining utterances at position %d\n", nskip);
+    for (li = lineiter_start(ctlfh); li; li = lineiter_next(li)) {
+        char *infile, *outfile;
+        int rv;
+
+        if (nskip-- > 0)
+            continue;
+        if (runlen == 0)
+            break;
+        --runlen;
+
+        string_trim(li->buf, STRING_BOTH);
+        build_filenames(wtf->config, li->buf, &infile, &outfile);
+        rv = sphinx_wave2feat_convert_file(wtf, infile, outfile);
+        ckd_free(infile);
+        ckd_free(outfile);
+        if (rv != 0) {
+            lineiter_free(li);
+            fclose(ctlfh);
+            return rv;
+        }
+    }
+    return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+    sphinx_wave2feat_t *wtf;
+    cmd_ln_t *config;
+    int rv;
+
+    /* Initialize config. */
+    if ((config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE)) == NULL)
+        return 2;
+
+    /* Parse an argument file if there's one in there. */
+    if (cmd_ln_str_r(config, "-argfile"))
+        config = cmd_ln_parse_file_r(config, defn,
+                                     cmd_ln_str_r(config, "-argfile"), FALSE);
+    if (config == NULL) {
+        E_ERROR("Command line parsing failed\n");
+        return 1;
+    }
+    if ((wtf = sphinx_wave2feat_init(config)) == NULL) {
+        E_ERROR("Failed to initialize wave2feat object\n");
+        return 1;
+    }
+
+    /* If there's a control file run through it, otherwise we will do
+     * a single file (which is what run_control_file will do
+     * internally too) */
+    if (cmd_ln_str_r(config, "-c"))
+        rv = run_control_file(wtf, cmd_ln_str_r(config, "-c"));
+    else
+        rv = sphinx_wave2feat_convert_file(wtf, cmd_ln_str_r(config, "-i"),
+                                           cmd_ln_str_r(config, "-o"));
+
+    sphinx_wave2feat_free(wtf);
+    return rv;
+}

src/tests/libs/sphinx/sphinx_fe/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx sphinx_fe ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest sphinx_fe : sphinx_fe.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/sphinx_fe/cmd_ln_defn.h

@@ +1 @@
+/* ====================================================================
+ * Copyright (c) 1998-2000 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: cmd_ln_defn.h
+ * 
+ * Description: 
+ *      Command line argument definition
+ *
+ * Author: 
+ *      
+ *********************************************************************/
+
+#ifndef CMD_LN_DEFN_H
+#define CMD_LN_DEFN_H
+
+#include "cmd_ln.h"
+#include "fe.h"
+
+const char helpstr[] =
+  "Description: \n\
+Extract acoustic features form from audio file.\n\
+\n\
+The main parameters that affect the final output, with typical values, are:\n\
+\n\
+samprate, typically 8000, 11025, or 16000\n\
+lowerf, 130, 200, 130, for the respective sampling rates above\n\
+upperf, 3700, 5200, 6800, for the respective sampling rates above\n\
+nfilt, 31, 37, 40, for the respective sampling rates above\n\
+nfft, 256 or 512\n\
+format, raw or nist or mswav\n\
+\"";
+
+const char examplestr[] =
+  "Example: \n\
+This example creates a cepstral file named \"output.mfc\" from an input audio file named \"input.raw\", which is a raw audio file (no header information), which was originally sampled at 16kHz. \n\
+\n\
+sphinx_fe -i  input.raw \n\
+        -o   output.mfc \n\
+        -input_endian little \n\
+        -samprate  16000 \n\
+        -lowerf    130 \n\
+        -upperf    6800 \n\
+        -nfilt     40 \n\
+        -nfft      512";
+
+static arg_t defn[] = {
+  { "-help",
+    ARG_BOOLEAN,
+    "no",
+    "Shows the usage of the tool"},
+  
+  { "-example",
+    ARG_BOOLEAN,
+    "no",
+    "Shows example of how to use the tool"},
+
+  waveform_to_cepstral_command_line_macro(),
+
+  { "-argfile",
+    ARG_STRING,
+    NULL,
+    "Argument file (e.g. feat.params from an acoustic model) to read parameters from.  This will override anything set in other command line arguments." },
+  
+  { "-i",
+    ARG_STRING,
+    NULL,
+    "Single audio input file" },
+  
+  { "-o",
+    ARG_STRING,
+    NULL,
+    "Single cepstral output file" },
+  
+  { "-c",
+    ARG_STRING,
+    NULL,
+    "Control file for batch processing" },
+  
+  { "-nskip",
+    ARG_INT32,
+    "0",
+    "If a control file was specified, the number of utterances to skip at the head of the file" },
+  
+  { "-runlen",
+    ARG_INT32,
+    "-1",
+    "If a control file was specified, the number of utterances to process, or -1 for all" },
+
+  { "-part",
+    ARG_INT32,
+    "0",
+    "Index of the part to run (supersedes -nskip and -runlen if non-zero)" },
+  
+  { "-npart",
+    ARG_INT32,
+    "0",
+    "Number of parts to run in (supersedes -nskip and -runlen if non-zero)" },
+  
+  { "-di",
+    ARG_STRING,
+    NULL,
+    "Input directory, input file names are relative to this, if defined" },
+  
+  { "-ei",
+    ARG_STRING,
+    NULL,
+    "Input extension to be applied to all input files" },
+  
+  { "-do",
+    ARG_STRING,
+    NULL,
+    "Output directory, output files are relative to this" },
+  
+  { "-eo",
+    ARG_STRING,
+    NULL,
+    "Output extension to be applied to all output files" },
+  
+  { "-build_outdirs",
+    ARG_BOOLEAN,
+    "yes",
+    "Create missing subdirectories in output directory" },
+
+  { "-nist",
+    ARG_BOOLEAN,
+    "no",
+    "Defines input format as NIST sphere" },
+  
+  { "-raw",
+    ARG_BOOLEAN,
+    "no",
+    "Defines input format as raw binary data" },
+  
+  { "-mswav",
+    ARG_BOOLEAN,
+    "no",
+    "Defines input format as Microsoft Wav (RIFF)" },
+  
+  { "-nchans",
+    ARG_INT32,
+    "1",
+    "Number of channels of data (interlaced samples assumed)" },
+  
+  { "-whichchan",
+    ARG_INT32,
+    "1",
+    "Channel to process" },
+  
+  { "-ofmt",
+    ARG_STRING,
+    "sphinx",
+    "Format of output files - one of sphinx, htk, text." },
+  
+  { "-mach_endian",
+    ARG_STRING,
+#ifdef WORDS_BIGENDIAN
+    "big",
+#else
+    "little",
+#endif
+    "Endianness of machine, big or little" },
+  
+  { "-blocksize",
+    ARG_INT32,
+    "2048",
+    "Number of samples to read at a time." },
+
+  { "-spec2cep",
+    ARG_BOOLEAN,
+    "no",
+    "Input is log spectral files, output is cepstral files" },
+
+  { "-cep2spec",
+    ARG_BOOLEAN,
+    "no",
+    "Input is cepstral files, output is log spectral files" },
+
+  { NULL, 0, NULL, NULL }
+};
+
+    
+#define CMD_LN_DEFN_H
+
+#endif /* CMD_LN_DEFN_H */ 
+
 
+/*
+ * Log record.  Maintained by RCS.
+ *
+ * $Log: cmd_ln_defn.h,v $
+ * Revision 1.7  2006/02/25 00:53:48  egouvea
+ * Added the flag "-seed". If dither is being used and the seed is less
+ * than zero, the random number generator is initialized with time(). If
+ * it is at least zero, it's initialized with the provided seed. This way
+ * we have the benefit of having dither, and the benefit of being
+ * repeatable.
+ *
+ * This is consistent with what sphinx3 does. Well, almost. The random
+ * number generator is still what the compiler provides.
+ *
+ * Also, moved fe_init_params to fe_interface.c, so one can initialize a
+ * variable of type param_t with meaningful values.
+ *
+ * Revision 1.6  2006/02/17 00:31:34  egouvea
+ * Removed switch -melwarp. Changed the default for window length to
+ * 0.025625 from 0.256 (so that a window at 16kHz sampling rate has
+ * exactly 410 samples). Cleaned up include's. Replaced some E_FATAL()
+ * with E_WARN() and return.
+ *
+ * Revision 1.5  2006/02/16 00:18:26  egouvea
+ * Implemented flexible warping function. The user can specify at run
+ * time which of several shapes they want to use. Currently implemented
+ * are an affine function (y = ax + b), an inverse linear (y = a/x) and a
+ * piecewise linear (y = ax, up to a frequency F, and then it "breaks" so
+ * Nyquist frequency matches in both scales.
+ *
+ * Added two switches, -warp_type and -warp_params. The first specifies
+ * the type, which valid values:
+ *
+ * -inverse or inverse_linear
+ * -linear or affine
+ * -piecewise or piecewise_linear
+ *
+ * The inverse_linear is the same as implemented by EHT. The -mel_warp
+ * switch was kept for compatibility (maybe remove it in the
+ * future?). The code is compatible with EHT's changes: cepstra created
+ * from code after his changes should be the same as now. Scripts that
+ * worked with his changes should work now without changes. Tested a few
+ * cases, same results.
+ *
+ * Revision 1.4  2006/02/14 20:56:54  eht
+ * Implement an argument -melwarp that changes the standard mel-scale
+ * equation from:
+ *      M(f) = 2595 * log10( 1 + f/700 )
+ * to:
+ *      M(f,w) = 2595 * log10( 1 + f/(700*w))
+ *
+ * So, 1.0 means no warp,  w > 1.0 means linear compression w < 1.0 means
+ * linear expansion.
+ *
+ * Implement argument -nskip and -runlen arguments so that a subset of the
+ * utterances in the control file can be executed.  Allows a simple
+ * distribution of wave2feat processing over N processors.
+ *
+ * Revision 1.3  2005/05/19 21:21:55  egouvea
+ * Bug #1176394: example bug
+ *
+ * Revision 1.2  2004/11/23 04:14:06  egouvea
+ * Fixed bug in cmd_ln.c in which a wrong boolean argument led into an
+ * infinite loop, and fixed the help and example strings, getting rid of
+ * spaces, so that the appearance is better.
+ *
+ * Revision 1.1  2004/09/09 17:59:30  egouvea
+ * Adding missing files to wave2feat
+ *
+ *
+ *

src/tests/libs/sphinx/test_ad/test_ad_read.c

@@ +1 @@
+/* -*- c-basic-offset: 4 -*- */
+#ifdef HAVE_CONFIG
+#include <config.h>
+#endif
+
+#include "ad.h"
+#include "cont_ad.h"
+#include "byteorder.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+
+#ifndef WORDS_BIGENDIAN
+#define WORDS_BIGENDIAN 0
+#endif
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+FILE *infp;
+
+static int32
+file_ad_read(ad_rec_t * r, int16 * buf, int32 max)
+{
+    int32 i, k;
+
+    k = fread(buf, sizeof(int16), max, infp);
+    if (WORDS_BIGENDIAN) {
+        for (i = 0; i < k; i++) {
+        SWAP_INT16(&buf[i]);
+        }
+    }
+
+    return ((k > 0) ? k : -1);
+}
+
+int
+main(int argc, char *argv[])
+{
+    cont_ad_t *cont;
+    ad_rec_t ad;
+    int16 buf[512];
+    int listening;
+
+    ad.sps = 16000;
+    ad.bps = 2;
+
+    TEST_ASSERT(infp = fopen(TESTDATADIR "/chan3.raw", "rb"));
+    TEST_ASSERT(cont = cont_ad_init(&ad, file_ad_read));
+
+    printf("Calibrating ...");
+    fflush(stdout);
+    if (cont_ad_calib(cont) < 0)
+        printf(" failed; file too short?\n");
+    else
+        printf(" done after %ld samples\n", ftell(infp) / 2);
+    rewind(infp);
+
+    listening = FALSE;
+    while (1) {
+    int k = cont_ad_read(cont, buf, 512);
+    /* End of file. */
+    if (k < 0) {
+        if (listening) {
+        printf("End of file at %.3f seconds\n",
+               (double)(cont->read_ts - k) / 16000);
+        }
+        break;
+    }
+
+    if (cont->state == CONT_AD_STATE_SIL) {
+        /* Has there been enough silence to cut the utterance? */
+        if (listening && cont->seglen > 8000) {
+        printf("End of utterance at %.3f seconds\n",
+               (double)(cont->read_ts - k - cont->seglen) / 16000);
+        listening = FALSE;
+        }
+    }
+    else {
+        if (!listening) {
+        printf("Start of utterance at %.3f seconds\n",
+               (double)(cont->read_ts - k) / 16000);
+        listening = TRUE;
+        }
+    }
+    }
+
+    cont_ad_close(cont);
+    fclose(infp);
+    return 0;
+}

src/tests/libs/sphinx/test_ad/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_ad ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_ad_copy : test_ad_copy.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a  ;
+SimpleTest test_ad_read : test_ad_read.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a  ;
+
+

src/tests/libs/sphinx/test_ad/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define EPSILON 0.01
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_ad/test_ad_copy.c

@@ +1 @@
+/* -*- c-basic-offset: 4 -*- */
+#ifdef HAVE_CONFIG
+#include <config.h>
+#endif
+
+#include "ad.h"
+#include "cont_ad.h"
+#include "ckd_alloc.h"
+#include "byteorder.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#ifndef WORDS_BIGENDIAN
+#define WORDS_BIGENDIAN 0
+#endif
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+int
+main(int argc, char *argv[])
+{
+    cont_ad_t *cont;
+    FILE *infp;
+    int16 buf[512];
+    int listening;
+    int k, n_calib_samp;
+    int16 *calib, *cptr;
+
+    TEST_ASSERT(infp = fopen(TESTDATADIR "/chan3.raw", "rb"));
+    TEST_ASSERT(cont = cont_ad_init(NULL, NULL));
+
+    n_calib_samp = cont_ad_calib_size(cont);
+    calib = ckd_malloc(n_calib_samp * 2);
+    printf("Reading %d calibration samples\n", n_calib_samp);
+    TEST_ASSERT(fread(calib, 2, n_calib_samp, infp) == n_calib_samp);
+    printf("Calibrating...\n");
+    TEST_EQUAL(0, cont_ad_calib_loop(cont, calib, n_calib_samp));
+    printf("Calibrated!\n");
+
+    listening = FALSE;
+    cptr = calib;
+    while (1) {
+    /* Use up the calibration samples first. */
+    if (n_calib_samp) {
+        k = n_calib_samp;
+        if (k > 512)
+        k = 512;
+        memcpy(buf, cptr, 512 * 2);
+        cptr += k;
+        n_calib_samp -= k;
+        if (k < 512)
+        k = fread(buf + k, 2, 512-k, infp);
+    }
+    else {
+        k = fread(buf, 2, 512, infp);
+    }
+
+    /* End of file. */
+    if (k < 256) { /* FIXME: It should do something useful with fewer samples. */
+        if (listening) {
+        printf("End of file at %.3f seconds\n",
+               (double)(cont->read_ts - k) / 16000);
+        }
+        break;
+    }
+
+    k = cont_ad_read(cont, buf, k);
+
+    if (cont->state == CONT_AD_STATE_SIL) {
+        /* Has there been enough silence to cut the utterance? */
+        if (listening && cont->seglen > 8000) {
+        printf("End of utterance at %.3f seconds\n",
+               (double)(cont->read_ts - k - cont->seglen) / 16000);
+        listening = FALSE;
+        }
+    }
+    else {
+        if (!listening) {
+        printf("Start of utterance at %.3f seconds\n",
+               (double)(cont->read_ts - k) / 16000);
+        listening = TRUE;
+        }
+    }
+    }
+
+    ckd_free(calib);
+    cont_ad_close(cont);
+    fclose(infp);
+    return 0;
+}

src/tests/libs/sphinx/testfuncs.sh

@@ +1 @@
+# Utility functions and parameters for regression tests
+
+# Predefined directories you may need
+# Stupid broken CMU Facilities autoconf doesn't do @abs_top_srcdir@
+builddir=../"@top_builddir@"
+sourcedir=../"@top_srcdir@"
+tests=$sourcedir/test
+
+# Automatically report failures on exit
+failures=""
+trap "report_failures" 0
+
+run_program() {
+    program="$1"
+    shift
+    $builddir/libtool --mode=execute "$builddir/src/$program/$program" $@
+}
+
+pass() {
+    title="$1"
+    echo "$title PASSED"
+}
+
+fail() {
+    title="$1"
+    echo "$title FAILED"
+    failures="$failures,$title"
+}
+
+assert() {
+    title="$1"
+    shift
+    if $@ >/dev/null 2>&1; then
+    pass "$title"
+    else
+    fail "$title"
+    fi
+}
+
+compare_table() {
+    title="$1"
+    shift
+    if perl "$tests/compare_table.pl" $@ | grep SUCCESS >/dev/null 2>&1; then
+    pass "$title"
+    else
+    fail "$title"
+    fi 
+}
+
+report_failures() {
+    if test x"$failures" = x; then
+    echo "All sub-tests passed"
+    exit 0
+    else
+    echo "Sub-tests failed:$failures" | sed -e 's/,/\n/g'
+    exit 1
+    fi
+}

src/tests/libs/sphinx/test_alloc/test_ckd_alloc_abort.c

@@ +1 @@
+#include <stdio.h>
+
+#include <ckd_alloc.h>
+
+#include "test_macros.h"
+
+int
+main(int argc, char *argv[])
+{
+    int *alloc1;
+    int bad_alloc_did_not_fail = FALSE;
+
+    ckd_set_jump(NULL, TRUE);
+    /* Guaranteed to fail, we hope!. */
+    alloc1 = ckd_calloc(-1,-1);
+    TEST_ASSERT(bad_alloc_did_not_fail);
+
+    return 0;
+}

src/tests/libs/sphinx/test_alloc/test_ckd_alloc_fail.c

@@ +1 @@
+#include <stdio.h>
+
+#include <ckd_alloc.h>
+
+#include "test_macros.h"
+
+int
+main(int argc, char *argv[])
+{
+    int *alloc1;
+    int bad_alloc_did_not_fail = FALSE;
+
+    ckd_set_jump(NULL, FALSE);
+    /* Guaranteed to fail, we hope!. */
+    alloc1 = ckd_calloc(-1,-1);
+    TEST_ASSERT(bad_alloc_did_not_fail);
+
+    return 0;
+}

src/tests/libs/sphinx/test_alloc/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_alloc ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libssphinxbase ;
+
+SimpleTest test_ckd_alloc : test_ckd_alloc.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_ckd_alloc_abort : test_ckd_alloc_abort.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_ckd_alloc_catch : test_ckd_alloc_catch.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_ckd_alloc_fail : test_ckd_alloc_fail.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_listelem_alloc : test_listelem_alloc.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_alloc/test_listelem_alloc.c

@@ +1 @@
+#include <stdio.h>
+#include <string.h>
+
+#include <listelem_alloc.h>
+
+#include "test_macros.h"
+
+struct bogus {
+    char const *str;
+    long foobie;
+};
+
+int
+main(int argc, char *argv[])
+{
+    listelem_alloc_t *le;
+    struct bogus *bogus1, *bogus2;
+    int i;
+
+    TEST_ASSERT(le = listelem_alloc_init(sizeof(struct bogus)));
+    bogus1 = listelem_malloc(le);
+    bogus1->str = "hello";
+    bogus1->foobie = 42;
+    bogus2 = listelem_malloc(le);
+    bogus2->str = "goodbye";
+    bogus2->foobie = 69;
+    TEST_EQUAL(bogus1->foobie, 42);
+    TEST_EQUAL(0, strcmp(bogus1->str, "hello"));
+    listelem_free(le, bogus1);
+    listelem_free(le, bogus2);
+    listelem_alloc_free(le);
+
+    TEST_ASSERT(le = listelem_alloc_init(sizeof(struct bogus)));
+    listelem_stats(le);
+    for (i = 0; i < 60; ++i)
+        bogus1 = listelem_malloc(le);
+    listelem_stats(le);
+    listelem_alloc_free(le);
+
+    return 0;
+}

src/tests/libs/sphinx/test_alloc/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define EPSILON 0.01
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_alloc/test_ckd_alloc_abort.sh

@@ +1 @@
+#!/bin/sh
+
+. ../testfuncs.sh
+
+ulimit -c 0
+if ./test_ckd_alloc_abort; then
+    fail expected_failure
+else
+    pass expected_failure
+fi
+

src/tests/libs/sphinx/test_alloc/test_ckd_alloc.c

@@ +1 @@
+#include <stdio.h>
+
+#include <ckd_alloc.h>
+
+#include "test_macros.h"
+
+int
+main(int argc, char *argv[])
+{
+    int *alloc1;
+    int **alloc2;
+    int ***alloc3;
+    int i;
+
+    TEST_ASSERT(alloc1 = ckd_calloc(3*3*3, sizeof(*alloc1)));
+    TEST_ASSERT(alloc2 = ckd_calloc_2d(3, 3, sizeof(**alloc2)));
+    TEST_ASSERT(alloc3 = ckd_calloc_3d(3, 3, 3, sizeof(***alloc3)));
+
+    for (i = 0; i < 27; ++i) {
+        TEST_EQUAL(alloc1[i], 0);
+        alloc1[i] = i + 1;
+    }
+    for (i = 0; i < 27; ++i)
+        TEST_EQUAL(alloc1[i], i+1);
+
+    for (i = 0; i < 3; ++i) {
+        int j;
+        for (j = 0; j < 3; ++j) {
+            TEST_EQUAL(alloc2[i][j], 0);
+            alloc2[i][j] = i * 3 + j + 1;
+        }
+    }
+    /* Verify that row-major ordering is in use. */
+    for (i = 0; i < 9; ++i) {
+        TEST_EQUAL(alloc2[0][i], i+1);
+        TEST_EQUAL(alloc2[0][i], alloc1[i]);
+    }
+    for (i = 0; i < 3; ++i) {
+        int j;
+        for (j = 0; j < 3; ++j) {
+            TEST_EQUAL(alloc2[i][j], i * 3 + j + 1);
+        }
+    }
+    /* Now test alloc_ptr. */
+    ckd_free_2d(alloc2);
+    alloc2 = ckd_alloc_2d_ptr(3, 3, alloc1, sizeof(*alloc1));
+    for (i = 0; i < 9; ++i) {
+        TEST_EQUAL(alloc2[0][i], i+1);
+        TEST_EQUAL(alloc2[0][i], alloc1[i]);
+    }
+    for (i = 0; i < 3; ++i) {
+        int j;
+        for (j = 0; j < 3; ++j) {
+            TEST_EQUAL(alloc2[i][j], i * 3 + j + 1);
+        }
+    }
+    ckd_free_2d_ptr(alloc2);
+
+    for (i = 0; i < 3; ++i) {
+        int j;
+        for (j = 0; j < 3; ++j) {
+            int k;
+            for (k = 0; k < 3; ++k) {
+                TEST_EQUAL(alloc3[i][j][k], 0);
+                alloc3[i][j][k] = i * 3 * 3 + j * 3 + k + 1;
+            }
+        }
+    }
+    /* Verify that row-major ordering is in use. */
+    for (i = 0; i < 27; ++i) {
+        TEST_EQUAL(alloc3[0][0][i], i+1);
+        TEST_EQUAL(alloc3[0][0][i], alloc1[i]);
+    }
+    for (i = 0; i < 3; ++i) {
+        int j;
+        for (j = 0; j < 3; ++j) {
+            int k;
+            for (k = 0; k < 3; ++k) {
+                TEST_EQUAL(alloc3[i][j][k], i * 3 * 3 + j * 3 + k + 1);
+            }
+        }
+    }
+    /* Now test alloc_ptr. */
+    ckd_free_3d(alloc3);
+    alloc3 = ckd_alloc_3d_ptr(3, 3, 3, alloc1, sizeof(*alloc1));
+    for (i = 0; i < 27; ++i) {
+        TEST_EQUAL(alloc3[0][0][i], i+1);
+        TEST_EQUAL(alloc3[0][0][i], alloc1[i]);
+    }
+    for (i = 0; i < 3; ++i) {
+        int j;
+        for (j = 0; j < 3; ++j) {
+            int k;
+            for (k = 0; k < 3; ++k) {
+                TEST_EQUAL(alloc3[i][j][k], i * 3 * 3 + j * 3 + k + 1);
+            }
+        }
+    }
+    ckd_free_3d_ptr(alloc3);
+    ckd_free(alloc1);
+
+    return 0;
+}

src/tests/libs/sphinx/test_alloc/test_ckd_alloc_catch.c

@@ +1 @@
+#include <stdio.h>
+
+#include <ckd_alloc.h>
+
+#include "test_macros.h"
+
+int
+main(int argc, char *argv[])
+{
+    int *alloc1;
+    jmp_buf env;
+
+    ckd_set_jump(&env, FALSE);
+    if (setjmp(env)) {
+        printf("Successfully caught bad allocation!\n");
+    }
+    else {
+        int failed_to_catch_bad_alloc = FALSE;
+
+        /* Guaranteed to fail, we hope!. */
+        alloc1 = ckd_calloc(-1,-1);
+        TEST_ASSERT(failed_to_catch_bad_alloc);
+    }
+
+    return 0;
+}

src/tests/libs/sphinx/test_alloc/test_ckd_alloc_fail.sh

@@ +1 @@
+#!/bin/sh
+
+. ../testfuncs.sh
+
+./test_ckd_alloc_fail
+if [ $? = 255 ]; then
+    pass expected_failure
+else
+    fail expected_failure
+fi
+

src/tests/libs/sphinx/test_fe/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_fe ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_fe : test_fe.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_pitch : test_pitch.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_fe/test_pitch.c

@@ +1 @@
+#include <stdio.h>
+
+#include "yin.h"
+#include "ckd_alloc.h"
+
+#include "test_macros.h"
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+int
+main(int argc, char *argv[])
+{
+    /* This is 11025Hz data (yikes) */
+    static const int frame_shift = 110, frame_size = 265;
+    FILE *raw;
+    yin_t *pe;
+    int16 *buf;
+    size_t nsamp, start;
+    uint16 period, bestdiff;
+    int nfr;
+
+    /* To make life easier, read the whole thing. */
+    TEST_ASSERT(raw = fopen(TESTDATADIR "/chan3.raw", "rb"));
+    fseek(raw, 0, SEEK_END);
+    nsamp = ftell(raw) / 2;
+    buf = ckd_calloc(nsamp, 2);
+    fseek(raw, 0, SEEK_SET);
+    TEST_EQUAL(nsamp, fread(buf, 2, nsamp, raw));
+    fclose(raw);
+
+    TEST_ASSERT(pe = yin_init(frame_size, 0.1, 0.2, 2));
+    yin_start(pe);
+    nfr = 0;
+    for (start = 0; start + frame_size < nsamp; start += frame_shift) {
+        yin_write(pe, buf + start);
+        if (yin_read(pe, &period, &bestdiff)) {
+            if (bestdiff < 0.2 * 32768)
+                printf("%d ", period ? 11025/period : 0);
+            else
+                printf("0 ");
+            ++nfr;
+        }
+    }
+    yin_end(pe);
+    while (yin_read(pe, &period, &bestdiff)) {
+        if (bestdiff < 0.2 * 32768)
+            printf("%d ", period ? 11025/period : 0);
+        else
+            printf("0 ");
+        ++nfr;
+    }
+    printf("\n");
+    yin_free(pe);
+    ckd_free(buf);
+
+    return 0;
+}

src/tests/libs/sphinx/test_fe/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define EPSILON 0.01
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_fe/test_fe.c

@@ +1 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "fe.h"
+#include "cmd_ln.h"
+#include "ckd_alloc.h"
+
+#include "test_macros.h"
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+int
+main(int argc, char *argv[])
+{
+    static const arg_t fe_args[] = {
+        waveform_to_cepstral_command_line_macro(),
+        { NULL, 0, NULL, NULL }
+    };
+    FILE *raw;
+    cmd_ln_t *config;
+    fe_t *fe;
+    int16 buf[1024];
+    int16 const *inptr;
+    int32 frame_shift, frame_size;
+    mfcc_t **cepbuf1, **cepbuf2, **cptr;
+    int32 nfr, i;
+    size_t nsamp;
+
+    TEST_ASSERT(config = cmd_ln_parse_r(NULL, fe_args, argc, argv, FALSE));
+    TEST_ASSERT(fe = fe_init_auto_r(config));
+
+    TEST_EQUAL(fe_get_output_size(fe), DEFAULT_NUM_CEPSTRA);
+
+    fe_get_input_size(fe, &frame_shift, &frame_size);
+    TEST_EQUAL(frame_shift, DEFAULT_FRAME_SHIFT);
+    TEST_EQUAL(frame_size, (int)(DEFAULT_WINDOW_LENGTH*DEFAULT_SAMPLING_RATE));
+
+    TEST_ASSERT(raw = fopen(TESTDATADIR "/chan3.raw", "rb"));
+
+    TEST_EQUAL(0, fe_start_utt(fe));
+    TEST_EQUAL(1024, fread(buf, sizeof(int16), 1024, raw));
+
+    nsamp = 1024;
+    TEST_ASSERT(fe_process_frames(fe, NULL, &nsamp, NULL, &nfr) >= 0);
+    TEST_EQUAL(1024, nsamp);
+    TEST_EQUAL(4, nfr);
+
+    cepbuf1 = ckd_calloc_2d(5, DEFAULT_NUM_CEPSTRA, sizeof(**cepbuf1));
+    inptr = &buf[0];
+    nfr = 1;
+
+    printf("frame_size %d frame_shift %d\n", frame_size, frame_shift);
+    /* Process the first frame. */
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[0], &nfr) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, nfr);
+    TEST_EQUAL(nfr, 1);
+
+    /* Note that this next one won't actually consume any frames
+     * of input, because it already got sufficient overflow
+     * samples last time around.  This is implementation-dependent
+     * so we shouldn't actually test for it. */
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[1], &nfr) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, nfr);
+    TEST_EQUAL(nfr, 1);
+
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[2], &nfr) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, nfr);
+    TEST_EQUAL(nfr, 1);
+
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, &cepbuf1[3], &nfr) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, nfr);
+    TEST_EQUAL(nfr, 1);
+
+    TEST_ASSERT(fe_end_utt(fe, cepbuf1[4], &nfr) >= 0);
+    printf("nfr %d\n", nfr);
+    TEST_EQUAL(nfr, 1);
+
+    /* What we *should* test is that the output we get by
+     * processing one frame at a time is exactly the same as what
+     * we get from doing them all at once.  So let's do that */
+    cepbuf2 = ckd_calloc_2d(5, DEFAULT_NUM_CEPSTRA, sizeof(**cepbuf2));
+    inptr = &buf[0];
+    nfr = 5;
+    nsamp = 1024;
+    TEST_EQUAL(0, fe_start_utt(fe));
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cepbuf2, &nfr) >= 0);
+    printf("nfr %d\n", nfr);
+    TEST_EQUAL(nfr, 4);
+    nfr = 1;
+    TEST_ASSERT(fe_end_utt(fe, cepbuf2[4], &nfr) >= 0);
+    printf("nfr %d\n", nfr);
+    TEST_EQUAL(nfr, 1);
+
+    for (i = 0; i < 5; ++i) {
+        int j;
+        printf("%d: ", i);
+        for (j = 0; j < DEFAULT_NUM_CEPSTRA; ++j) {
+            printf("%.2f,%.2f ",
+                   MFCC2FLOAT(cepbuf1[i][j]),
+                   MFCC2FLOAT(cepbuf2[i][j]));
+            TEST_EQUAL_FLOAT(cepbuf1[i][j], cepbuf2[i][j]);
+        }
+        printf("\n");
+    }
+
+    /* Now, also test to make sure that even if we feed data in
+     * little tiny bits we can still make things work. */
+    memset(cepbuf2[0], 0, 5 * DEFAULT_NUM_CEPSTRA * sizeof(**cepbuf2));
+    inptr = &buf[0];
+    cptr = &cepbuf2[0];
+    nfr = 5;
+    i = 5;
+    nsamp = 256;
+    TEST_EQUAL(0, fe_start_utt(fe));
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, i);
+    cptr += i;
+    nfr -= i;
+    i = nfr;
+    nsamp = 256;
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, i);
+    cptr += i;
+    nfr -= i;
+    i = nfr;
+    nsamp = 256;
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, i);
+    cptr += i;
+    nfr -= i;
+    i = nfr;
+    nsamp = 256;
+    TEST_ASSERT(fe_process_frames(fe, &inptr, &nsamp, cptr, &i) >= 0);
+    printf("inptr %ld nsamp %ld nfr %d\n", inptr - buf, nsamp, i);
+    cptr += i;
+    nfr -= i;
+    TEST_ASSERT(fe_end_utt(fe, *cptr, &nfr) >= 0);
+    printf("nfr %d\n", nfr);
+    TEST_EQUAL(nfr, 1);
+
+    for (i = 0; i < 5; ++i) {
+        int j;
+        printf("%d: ", i);
+        for (j = 0; j < DEFAULT_NUM_CEPSTRA; ++j) {
+            printf("%.2f,%.2f ",
+                   MFCC2FLOAT(cepbuf1[i][j]),
+                   MFCC2FLOAT(cepbuf2[i][j]));
+            TEST_EQUAL_FLOAT(cepbuf1[i][j], cepbuf2[i][j]);
+        }
+        printf("\n");
+    }
+
+    /* And now, finally, test fe_process_utt() */
+    inptr = &buf[0];
+    i = 0;
+    TEST_EQUAL(0, fe_start_utt(fe));
+    TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
+    printf("i %d nfr %d\n", i, nfr);
+    if (nfr)
+        memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
+    ckd_free_2d(cptr);
+    i += nfr;
+    inptr += 256;
+    TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
+    printf("i %d nfr %d\n", i, nfr);
+    if (nfr)
+        memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
+    ckd_free_2d(cptr);
+    i += nfr;
+    inptr += 256;
+    TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
+    printf("i %d nfr %d\n", i, nfr);
+    if (nfr)
+        memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
+    ckd_free_2d(cptr);
+    i += nfr;
+    inptr += 256;
+    TEST_ASSERT(fe_process_utt(fe, inptr, 256, &cptr, &nfr) >= 0);
+    printf("i %d nfr %d\n", i, nfr);
+    if (nfr)
+        memcpy(cepbuf2[i], cptr[0], nfr * DEFAULT_NUM_CEPSTRA * sizeof(**cptr));
+    ckd_free_2d(cptr);
+    i += nfr;
+    inptr += 256;
+    TEST_ASSERT(fe_end_utt(fe, cepbuf2[i], &nfr) >= 0);
+    printf("i %d nfr %d\n", i, nfr);
+    TEST_EQUAL(nfr, 1);
+
+    for (i = 0; i < 5; ++i) {
+        int j;
+        printf("%d: ", i);
+        for (j = 0; j < DEFAULT_NUM_CEPSTRA; ++j) {
+            printf("%.2f,%.2f ",
+                   MFCC2FLOAT(cepbuf1[i][j]),
+                   MFCC2FLOAT(cepbuf2[i][j]));
+            TEST_EQUAL_FLOAT(cepbuf1[i][j], cepbuf2[i][j]);
+        }
+        printf("\n");
+    }
+
+    ckd_free_2d(cepbuf1);
+    ckd_free_2d(cepbuf2);
+    fclose(raw);
+    fe_free(fe);
+
+    return 0;
+}

src/tests/libs/sphinx/test_logmath/test_log_int16.c

@@ +1 @@
+#include <logmath.h>
+
+#include "test_macros.h"
+
+#define LOG_EPSILON 1500
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    int32 rv;
+
+    lmath = logmath_init(1.0001, 0, 1);
+    TEST_ASSERT(lmath);
+    printf("log(1e-150) = %d\n", logmath_log(lmath, 1e-150));
+    TEST_EQUAL_LOG(logmath_log(lmath, 1e-150), -3454050);
+    printf("exp(log(1e-150)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-150)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-150)), 1e-150);
+    printf("log(1e-48) = %d\n", logmath_log(lmath, 1e-48));
+    printf("exp(log(1e-48)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-48)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-48)), 1e-48);
+    printf("log(42) = %d\n", logmath_log(lmath, 42));
+    TEST_EQUAL_LOG(logmath_log(lmath, 42), 37378);
+    printf("exp(log(42)) = %f\n",logmath_exp(lmath, logmath_log(lmath, 42)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 42)), 42);
+    printf("log(1e-3 + 5e-3) = %d l+ %d = %d\n",
+           logmath_log(lmath, 1e-3),
+           logmath_log(lmath, 5e-3),
+           logmath_add(lmath, logmath_log(lmath, 1e-3),
+               logmath_log(lmath, 5e-3)));
+    printf("log(1e-3 + 5e-3) = %e + %e = %e\n",
+           logmath_exp(lmath, logmath_log(lmath, 1e-3)),
+           logmath_exp(lmath, logmath_log(lmath, 5e-3)),
+           logmath_exp(lmath, logmath_add(lmath, logmath_log(lmath, 1e-3),
+                          logmath_log(lmath, 5e-3))));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 5e-48)),
+               logmath_log(lmath, 6e-48));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 42)),
+               logmath_log(lmath, 42));
+
+    rv = logmath_write(lmath, "tmp.logadd");
+    TEST_EQUAL(rv, 0);
+    logmath_free(lmath);
+    lmath = logmath_read("tmp.logadd");
+    TEST_ASSERT(lmath);
+    printf("log(1e-150) = %d\n", logmath_log(lmath, 1e-150));
+    TEST_EQUAL_LOG(logmath_log(lmath, 1e-150), -3454050);
+    printf("exp(log(1e-150)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-150)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-150)), 1e-150);
+    printf("log(1e-48) = %d\n", logmath_log(lmath, 1e-48));
+    printf("exp(log(1e-48)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-48)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-48)), 1e-48);
+    printf("log(42) = %d\n", logmath_log(lmath, 42));
+    TEST_EQUAL_LOG(logmath_log(lmath, 42), 37378);
+    printf("exp(log(42)) = %f\n",logmath_exp(lmath, logmath_log(lmath, 42)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 42)), 41.99);
+    printf("log(1e-3 + 5e-3) = %d l+ %d = %d\n",
+           logmath_log(lmath, 1e-3),
+           logmath_log(lmath, 5e-3),
+           logmath_add(lmath, logmath_log(lmath, 1e-3),
+               logmath_log(lmath, 5e-3)));
+    printf("log(1e-3 + 5e-3) = %e + %e = %e\n",
+           logmath_exp(lmath, logmath_log(lmath, 1e-3)),
+           logmath_exp(lmath, logmath_log(lmath, 5e-3)),
+           logmath_exp(lmath, logmath_add(lmath, logmath_log(lmath, 1e-3),
+                          logmath_log(lmath, 5e-3))));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 5e-48)),
+               logmath_log(lmath, 6e-48));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 42)),
+               logmath_log(lmath, 42));
+
+    return 0;
+}

src/tests/libs/sphinx/test_logmath/test_log_int8.c

@@ +1 @@
+#include <logmath.h>
+
+#include "test_macros.h"
+
+#define LOG_EPSILON 1500
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    int32 rv;
+
+    lmath = logmath_init(1.003, 0, 1);
+    TEST_ASSERT(lmath);
+    printf("log(1e-48) = %d\n", logmath_log(lmath, 1e-48));
+    TEST_EQUAL_LOG(logmath_log(lmath, 1e-48), -36896);
+    printf("exp(log(1e-48)) = %e\n",logmath_exp(lmath, -36896));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, -36896), 1e-48);
+    printf("log(42) = %d\n", logmath_log(lmath, 42));
+    TEST_EQUAL_LOG(logmath_log(lmath, 42), 1247);
+    printf("exp(log(42)) = %f\n",logmath_exp(lmath, 1247));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, 1247), 41.9);
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 5e-48)),
+               logmath_log(lmath, 6e-48));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 42)), 1247);
+
+    rv = logmath_write(lmath, "tmp.logadd");
+    TEST_EQUAL(rv, 0);
+    logmath_free(lmath);
+    lmath = logmath_read("tmp.logadd");
+    TEST_ASSERT(lmath);
+    TEST_EQUAL_LOG(logmath_log(lmath, 1e-48), -36896);
+    TEST_EQUAL_LOG(logmath_log(lmath, 42), 1247);
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 5e-48)),
+               logmath_log(lmath, 6e-48));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 42)), 1247);
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_logmath/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_logmath ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_log_int16 : test_log_int16.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_log_int8 : test_log_int8.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_log_shifted : test_log_shifted.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_logmath/test_log_shifted.c

@@ +1 @@
+#include <logmath.h>
+
+#include "test_macros.h"
+
+#define LOG_EPSILON 1500
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    int32 rv;
+
+    lmath = logmath_init(1.0001, 8, 1);
+    TEST_ASSERT(lmath);
+    printf("log(1e-150) = %d\n", logmath_log(lmath, 1e-150));
+    TEST_EQUAL_LOG(logmath_log(lmath, 1e-150), -13493);
+    printf("exp(log(1e-150)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-150)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-150)), 1e-150);
+    printf("log(1e-48) = %d\n", logmath_log(lmath, 1e-48));
+    printf("exp(log(1e-48)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-48)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-48)), 1e-48);
+    printf("log(42) = %d\n", logmath_log(lmath, 42));
+    TEST_EQUAL_LOG(logmath_log(lmath, 42), 146);
+    printf("exp(log(42)) = %f\n",logmath_exp(lmath, logmath_log(lmath, 42)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 42)), 41.99);
+    printf("log(1e-3 + 5e-3) = %d l+ %d = %d\n",
+           logmath_log(lmath, 1e-3),
+           logmath_log(lmath, 5e-3),
+           logmath_add(lmath, logmath_log(lmath, 1e-3),
+               logmath_log(lmath, 5e-3)));
+    printf("log(1e-3 + 5e-3) = %e + %e = %e\n",
+           logmath_exp(lmath, logmath_log(lmath, 1e-3)),
+           logmath_exp(lmath, logmath_log(lmath, 5e-3)),
+           logmath_exp(lmath, logmath_add(lmath, logmath_log(lmath, 1e-3),
+                          logmath_log(lmath, 5e-3))));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 5e-48)),
+               logmath_log(lmath, 6e-48));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 42)),
+               logmath_log(lmath, 42));
+
+    rv = logmath_write(lmath, "tmp.logadd");
+    TEST_EQUAL(rv, 0);
+    logmath_free(lmath);
+    lmath = logmath_read("tmp.logadd");
+    TEST_ASSERT(lmath);
+    printf("log(1e-150) = %d\n", logmath_log(lmath, 1e-150));
+    TEST_EQUAL_LOG(logmath_log(lmath, 1e-150), -13493);
+    printf("exp(log(1e-150)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-150)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-150)), 1e-150);
+    printf("log(1e-48) = %d\n", logmath_log(lmath, 1e-48));
+    printf("exp(log(1e-48)) = %e\n",logmath_exp(lmath, logmath_log(lmath, 1e-48)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 1e-48)), 1e-48);
+    printf("log(42) = %d\n", logmath_log(lmath, 42));
+    TEST_EQUAL_LOG(logmath_log(lmath, 42), 146);
+    printf("exp(log(42)) = %f\n",logmath_exp(lmath, logmath_log(lmath, 42)));
+    TEST_EQUAL_FLOAT(logmath_exp(lmath, logmath_log(lmath, 42)), 41.99);
+    printf("log(1e-3 + 5e-3) = %d l+ %d = %d\n",
+           logmath_log(lmath, 1e-3),
+           logmath_log(lmath, 5e-3),
+           logmath_add(lmath, logmath_log(lmath, 1e-3),
+               logmath_log(lmath, 5e-3)));
+    printf("log(1e-3 + 5e-3) = %e + %e = %e\n",
+           logmath_exp(lmath, logmath_log(lmath, 1e-3)),
+           logmath_exp(lmath, logmath_log(lmath, 5e-3)),
+           logmath_exp(lmath, logmath_add(lmath, logmath_log(lmath, 1e-3),
+                          logmath_log(lmath, 5e-3))));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 5e-48)),
+               logmath_log(lmath, 6e-48));
+    TEST_EQUAL_LOG(logmath_add(lmath, logmath_log(lmath, 1e-48),
+                   logmath_log(lmath, 42)),
+               logmath_log(lmath, 42));
+
+    return 0;
+}

src/tests/libs/sphinx/test_logmath/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define EPSILON 0.01
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/sphinx_cepview/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx sphinx_cepview ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+
+SimpleTest sphinx_cepview : main_cepview.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/sphinx_cepview/main_cepview.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1994-2001 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.
+ *
+ * ====================================================================
+ *
+ * 
+ * HISTORY
+ * 
+ * circa 1994   P J Moreno at Carnegie Mellon
+ *      Created.
+ *
+ * For history information, please use 'cvs log'
+ * $Log$
+ * Revision 1.11  2006/02/24  04:06:43  arthchan2003
+ * Merged from branch SPHINX3_5_2_RCI_IRII_BRANCH: Changed commands to macro.  Used E_INFO instead of printf in displaying no. of friends
+ * 
+ *
+ * Revision 1.10  2005/08/18 21:18:09  egouvea
+ * Added E_INFO displaying information about how many columns are being printed, and how many frames
+ *
+ * Revision 1.9.4.2  2005/09/07 23:51:05  arthchan2003
+ * Fixed keyword expansion problem
+ *
+ * Revision 1.9.4.1  2005/07/18 23:21:23  arthchan2003
+ * Tied command-line arguments with marcos
+ *
+ * Revision 1.10  2005/08/18 21:18:09  egouvea
+ * Added E_INFO displaying information about how many columns are being printed, and how many frames
+ *
+ * Revision 1.9  2005/06/22 05:38:45  arthchan2003
+ * Add
+ *
+ * Revision 1.2  2005/03/30 00:43:41  archan
+ *
+ * Add $Log$
+ * Revision 1.11  2006/02/24  04:06:43  arthchan2003
+ * Merged from branch SPHINX3_5_2_RCI_IRII_BRANCH: Changed commands to macro.  Used E_INFO instead of printf in displaying no. of friends
+ * 
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strfuncs.h>
+
+#ifdef _WIN32
+#pragma warning (disable: 4996) 
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "prim_type.h"
+#include "cmd_ln.h"
+#include "ckd_alloc.h"
+#include "info.h"
+#include "err.h"
+#include "bio.h"
+
+/* Silvio Moioli: switched to stat_reply that's Windows CE friendly. */
+#include "pio.h"
+
+/** \file main_cepview.c
+    \brief Main driver of cepview
+ */
+#define IO_ERR  (-1)
+#define IO_SUCCESS  (0)
+
+#define SHOW_ALL "-1"
+
+/* Default cepstral vector size */
+#define NUM_COEFF  "13"
+
+/* Default display size, i.e., number of coefficients displayed, less
+ * than the vector size so we display one frame per line.
+ */
+#define DISPLAY_SIZE "10"
+#define STR_MAX_INT "2147483647"
+
+static arg_t arg[] = {
+
+    {"-logfn",
+     ARG_STRING,
+     NULL,
+     "Log file (default stdout/stderr)"},
+    {"-i",
+     ARG_INT32,
+     NUM_COEFF,
+     "Number of coefficients in the feature vector."},
+    {"-d",
+     ARG_INT32,
+     DISPLAY_SIZE,
+     "Number of displayed coefficients."},
+    {"-header",
+     ARG_INT32,
+     "0",
+     "Whether header is shown."},
+    {"-describe",
+     ARG_INT32,
+     "0",
+     "Whether description will be shown."},
+    {"-b",
+     ARG_INT32,
+     "0",
+     "The beginning frame 0-based."},
+    {"-e",
+     ARG_INT32,
+     "2147483647",
+     "The ending frame."},
+    {"-f",
+     ARG_STRING,
+     NULL,
+     "Input feature file."},
+    {NULL, ARG_INT32, NULL, NULL}
+};
+
+int read_cep(char const *file, float ***cep, int *nframes, int numcep);
+
+int
+main(int argc, char *argv[])
+{
+    int i, j, offset;
+    int32 noframe, vsize, dsize, column;
+    int32 frm_begin, frm_end;
+    int is_header, is_describe;
+    float *z, **cep;
+    char const *cepfile;
+
+    print_appl_info(argv[0]);
+    cmd_ln_appl_enter(argc, argv, "default.arg", arg);
+
+    vsize = cmd_ln_int32("-i");
+    dsize = cmd_ln_int32("-d");
+    frm_begin = cmd_ln_int32("-b");
+    frm_end = cmd_ln_int32("-e");
+    is_header = cmd_ln_int32("-header");
+    is_describe = cmd_ln_int32("-describe");
+
+    if (vsize < 0)
+        E_FATAL("-i : Input vector size should be larger than 0.\n");
+    if (dsize < 0)
+        E_FATAL("-d : Column size should be larger than 0\n");
+    if (frm_begin < 0)
+        E_FATAL("-b : Beginning frame should be larger than 0\n");
+    /* The following condition is redundant
+     * if (frm_end < 0) E_FATAL("-e : Ending frame should be larger than 0\n");
+     */
+    if (frm_begin >= frm_end)
+        E_FATAL
+            ("Ending frame (-e) should be larger than beginning frame (-b).\n");
+
+    if ((cepfile = cmd_ln_str("-f")) == NULL) {
+        E_FATAL("Input file was not specified with (-f)\n");
+    }
+    if (read_cep(cepfile, &cep, &noframe, vsize) == IO_ERR)
+        E_FATAL("ERROR opening %s for reading\n", cepfile);
+
+    z = cep[0];
+
+    offset = 0;
+    column = (vsize > dsize) ? dsize : vsize;
+    frm_end = (frm_end > noframe) ? noframe : frm_end;
+
+    E_INFO("Displaying %d out of %d columns per frame\n", column, vsize);
+    E_INFO("Total %d frames\n\n", noframe);
+
+    /* This part should be moved to a special library if this file is
+       longer than 300 lines. */
+
+    if (is_header) {
+        if (is_describe) {
+            printf("\n%6s", "frame#:");
+        }
+
+        for (j = 0; j < column; ++j) {
+            printf("%3s%3d%s ", "c[", j, "]");
+        }
+        printf("\n");
+    }
+
+    offset += frm_begin * vsize;
+    for (i = frm_begin; i < frm_end; ++i) {
+        if (is_describe) {
+            printf("%6d:", i);
+        }
+        for (j = 0; j < column; ++j)
+            printf("%7.3f ", z[offset + j]);
+        printf("\n");
+
+        offset += vsize;
+    }
+    fflush(stdout);
+    cmd_ln_appl_exit();
+    ckd_free_2d(cep);
+
+    return (IO_SUCCESS);
+
+}
+
+int
+read_cep(char const *file, float ***cep, int *numframes, int cepsize)
+{
+    FILE *fp;
+    int n_float;
+    struct stat statbuf;
+    int i, n, byterev, sf, ef;
+    float32 **mfcbuf;
+
+    if (stat_retry(file, &statbuf) < 0) {
+        printf("stat(%s) failed\n", file);
+        return IO_ERR;
+    }
+
+    if ((fp = fopen(file, "rb")) == NULL) {
+        printf("fopen(%s, rb) failed\n", file);
+        return IO_ERR;
+    }
+
+    /* Read #floats in header */
+    if (fread(&n_float, sizeof(int), 1, fp) != 1) {
+        fclose(fp);
+        return IO_ERR;
+    }
+
+    /* Check if n_float matches file size */
+    byterev = FALSE;
+    if ((int) (n_float * sizeof(float) + 4) != statbuf.st_size) {
+        n = n_float;
+        SWAP_INT32(&n);
+
+        if ((int) (n * sizeof(float) + 4) != statbuf.st_size) {
+            printf
+                ("Header size field: %d(%08x); filesize: %d(%08x)\n",
+                 n_float, n_float, (int) statbuf.st_size,
+                 (int) statbuf.st_size);
+            fclose(fp);
+            return IO_ERR;
+        }
+
+        n_float = n;
+        byterev = TRUE;
+    }
+    if (n_float <= 0) {
+        printf("Header size field: %d\n", n_float);
+        fclose(fp);
+        return IO_ERR;
+    }
+
+    /* n = #frames of input */
+    n = n_float / cepsize;
+    if (n * cepsize != n_float) {
+        printf("Header size field: %d; not multiple of %d\n",
+               n_float, cepsize);
+        fclose(fp);
+        return IO_ERR;
+    }
+    sf = 0;
+    ef = n;
+
+    mfcbuf = (float **) ckd_calloc_2d(n, cepsize, sizeof(float32));
+
+    /* Read mfc data and byteswap if necessary */
+    n_float = n * cepsize;
+    if ((int) fread(mfcbuf[0], sizeof(float), n_float, fp) != n_float) {
+        printf("Error reading mfc data\n");
+        fclose(fp);
+        return IO_ERR;
+    }
+    if (byterev) {
+        for (i = 0; i < n_float; i++)
+            SWAP_FLOAT32(&(mfcbuf[0][i]));
+    }
+    fclose(fp);
+
+    *numframes = n;
+    *cep = mfcbuf;
+    return IO_SUCCESS;
+}
+
+/** Silvio Moioli: Windows CE/Mobile entry point added. */
+#if defined(_WIN32_WCE)
+#pragma comment(linker,"/entry:mainWCRTStartup")
+
+//Windows Mobile has the Unicode main only
+int wmain(int32 argc, wchar_t *wargv[]) {
+    char** argv;
+    size_t wlen;
+    size_t len;
+    int i;
+
+    argv = malloc(argc*sizeof(char*));
+    for (i=0; i<argc; i++){
+        wlen = lstrlenW(wargv[i]);
+        len = wcstombs(NULL, wargv[i], wlen);
+        argv[i] = malloc(len+1);
+        wcstombs(argv[i], wargv[i], wlen);
+    }
+
+    //assuming ASCII parameters
+    return main(argc, argv);
+}
+#endif

src/tests/libs/sphinx/test_cmdln/_test_parse_multiple.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+testname=`basename $0 .test`
+./cmdln_parse_multiple -a 42 -d 4.5 > $testname.out 2>/dev/null
+compare_table defaults $testname.out $tests/unit/test_cmdln/$testname.res
+rm -f $testname.out

src/tests/libs/sphinx/test_cmdln/_test_parse_badargs.res

@@ +1 @@
+ERROR: Bad argument value for -a: foobar
+ERROR: cmd_ln_parse_r failed
+ERROR: cmd_ln_parse failed, forced exit

src/tests/libs/sphinx/test_cmdln/cmdln_parse_multiple.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "cmd_ln.h"
+#include "ckd_alloc.h"
+
+const arg_t defs[] = {
+    { "-a", ARG_INT32, "42", "This is the first argument." },
+    { "-b", ARG_STRING, NULL, "This is the second argument." },
+    { "-c", ARG_BOOLEAN, "no", "This is the third argument." },
+    { "-d", ARG_FLOAT64, "1e-50", "This is the fourth argument." },
+    { NULL, 0, NULL, NULL }
+};
+
+static char *orig_argv[] = {
+    "foobie",
+    "-a", "69"
+};
+static int orig_argc = sizeof(orig_argv) / sizeof(orig_argv[0]);
+
+int
+main(int argc, char *argv[])
+{
+    cmd_ln_parse(defs, orig_argc, orig_argv, TRUE);
+    cmd_ln_parse(defs, argc, argv, FALSE);
+    printf("%d %s %d %f\n",
+           cmd_ln_int32("-a"),
+           cmd_ln_str("-b") ? cmd_ln_str("-b") : "(null)",
+           cmd_ln_boolean("-c"),
+           cmd_ln_float64("-d"));
+    cmd_ln_free();
+           
+    return 0;
+}

src/tests/libs/sphinx/test_cmdln/_test_parse_goodargs.res

@@ +1 @@
+36 hello 1 4.500000

src/tests/libs/sphinx/test_cmdln/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_cmdln ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest cmdln_parse : cmdln_parse.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest cmdln_parse_multiple : cmdln_parse_multiple.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest cmdln_parse_r : cmdln_parse_r.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_cmdln/_test_parse_defaults.res

@@ +1 @@
+-a  42  This is the first argument.
+-b      This is the second argument.
+-c  no  This is the third argument.
+-d  1e-50   This is the fourth argument.

src/tests/libs/sphinx/test_cmdln/_test_parse_defaults_r.res

@@ +1 @@
+-a  42  42
+-b      
+-c  no  no
+-d  1e-50   1.000000e-50
+-a  42  42
+-b      foobie
+-c  no  no
+-d  1e-50   1.000000e-50

src/tests/libs/sphinx/test_cmdln/cmdln_parse.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "cmd_ln.h"
+#include "ckd_alloc.h"
+
+const arg_t defs[] = {
+    { "-a", ARG_INT32, "42", "This is the first argument." },
+    { "-b", ARG_STRING, NULL, "This is the second argument." },
+    { "-c", ARG_BOOLEAN, "no", "This is the third argument." },
+    { "-d", ARG_FLOAT64, "1e-50", "This is the fourth argument." },
+    { NULL, 0, NULL, NULL }
+};
+
+int
+main(int argc, char *argv[])
+{
+    cmd_ln_parse(defs, argc, argv, TRUE);
+    printf("%d %s %d %f\n",
+           cmd_ln_int32("-a"),
+           cmd_ln_str("-b") ? cmd_ln_str("-b") : "(null)",
+           cmd_ln_boolean("-c"),
+           cmd_ln_float64("-d"));
+           
+    cmd_ln_free();
+
+    return 0;
+}

src/tests/libs/sphinx/test_cmdln/_test_parse_badargs.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+testname=`basename $0 .test`
+./cmdln_parse -a foobar > $testname.out 2>&1 && exit 1
+sed -ne 's,^ERROR:.*line [0-9]*:,ERROR:,p' < $testname.out > $testname.tmp.out \
+    && mv $testname.tmp.out $testname.out
+compare_table defaults $testname.out $tests/unit/test_cmdln/$testname.res 100
+rm -f $testname.out

src/tests/libs/sphinx/test_cmdln/cmdln_parse_r.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "cmd_ln.h"
+#include "ckd_alloc.h"
+
+const arg_t defs[] = {
+    { "-a", ARG_INT32, "42", "This is the first argument." },
+    { "-b", ARG_STRING, NULL, "This is the second argument." },
+    { "-c", ARG_BOOLEAN, "no", "This is the third argument." },
+    { "-d", ARG_FLOAT64, "1e-50", "This is the fourth argument." },
+    { NULL, 0, NULL, NULL }
+};
+
+int
+main(int argc, char *argv[])
+{
+    cmd_ln_t *config;
+
+    config = cmd_ln_parse_r(NULL, defs, argc, argv, TRUE);
+    if (config == NULL)
+        return 1;
+    printf("%ld %s %d %f\n",
+           cmd_ln_int32_r(config, "-a"),
+           cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)",
+           cmd_ln_boolean_r(config, "-c"),
+           cmd_ln_float64_r(config, "-d"));
+    cmd_ln_free_r(config);
+
+    config = cmd_ln_init(NULL, NULL, FALSE,
+                         "-b", "foobie", NULL);
+    if (config == NULL)
+        return 1;
+    cmd_ln_free_r(config);
+
+    config = cmd_ln_init(NULL, defs, TRUE,
+                         "-b", "foobie", NULL);
+    if (config == NULL)
+        return 1;
+    printf("%ld %s %d %f\n",
+           cmd_ln_int32_r(config, "-a"),
+           cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)",
+           cmd_ln_boolean_r(config, "-c"),
+           cmd_ln_float64_r(config, "-d"));
+    cmd_ln_free_r(config);
+
+    config = cmd_ln_init(NULL, NULL, FALSE,
+                         "-b", "foobie", NULL);
+    if (config == NULL)
+        return 1;
+    printf("%s\n",
+           cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)");
+    cmd_ln_set_str_r(config, "-b", "blatz");
+    printf("%s\n",
+           cmd_ln_str_r(config, "-b") ? cmd_ln_str_r(config, "-b") : "(null)");
+    cmd_ln_free_r(config);
+           
+    return 0;
+}

src/tests/libs/sphinx/test_cmdln/_test_parse_goodargs.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+testname=`basename $0 .test`
+./cmdln_parse -a 36 -b hello -c yes -d 4.5 > $testname.out 2>/dev/null
+compare_table defaults $testname.out $tests/unit/test_cmdln/$testname.res
+rm -f $testname.out

src/tests/libs/sphinx/test_cmdln/_test_parse_multiple.res

@@ +1 @@
+42 (null) 0 4.500000

src/tests/libs/sphinx/test_cmdln/_test_parse_defaults.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+testname=`basename $0 .test`
+./cmdln_parse > $testname.out 2>&1 || true
+sed -ne 's,^-,-,p' < $testname.out > $testname.tmp.out \
+    && mv $testname.tmp.out $testname.out
+compare_table defaults $testname.out $tests/unit/test_cmdln/$testname.res 100
+rm -f $testname.out

src/tests/libs/sphinx/test_cmdln/_test_parse_defaults_r.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+testname=`basename $0 .test`
+./cmdln_parse_r -a 42 > $testname.out 2>&1
+sed -ne 's,^-,-,p' < $testname.out > $testname.tmp.out \
+    && mv $testname.tmp.out $testname.out
+compare_table defaults $testname.out $tests/unit/test_cmdln/$testname.res 100
+rm -f $testname.out

src/tests/libs/sphinx/sphinx_adtools/sphinx_pitch.c

@@ +1 @@
+/* -*- 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.
+ *
+ * ====================================================================
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <cmd_ln.h>
+#include <yin.h>
+#include <ckd_alloc.h>
+#include <byteorder.h>
+#include <strfuncs.h>
+#include <err.h>
+#include <pio.h>
+
+#ifndef WORDS_BIGENDIAN
+#define WORDS_BIGENDIAN 0
+#endif
+
+static arg_t defn[] = {
+  { "-i",
+    ARG_STRING,
+    NULL,
+    "Single audio input file" },
+
+  { "-o",
+    ARG_STRING,
+    NULL,
+    "Single text output file (standard output will be used if not given)" },
+  
+  { "-c",
+    ARG_STRING,
+    NULL,
+    "Control file for batch processing" },
+  
+  { "-nskip",
+    ARG_INT32,
+    "0",
+    "If a control file was specified, the number of utterances to skip at the head of the file" },
+  
+  { "-runlen",
+    ARG_INT32,
+    "-1",
+    "If a control file was specified, the number of utterances to process (see -nskip too)" },
+  
+  { "-di",
+    ARG_STRING,
+    NULL,
+    "Input directory, input file names are relative to this, if defined" },
+  
+  { "-ei",
+    ARG_STRING,
+    NULL,
+    "Input extension to be applied to all input files" },
+  
+  { "-do",
+    ARG_STRING,
+    NULL,
+    "Output directory, output files are relative to this" },
+  
+  { "-eo",
+    ARG_STRING,
+    NULL,
+    "Output extension to be applied to all output files" },
+  
+  { "-nist",
+    ARG_BOOLEAN,
+    "no",
+    "Defines input format as NIST sphere" },
+  
+  { "-raw",
+    ARG_BOOLEAN,
+    "no",
+    "Defines input format as raw binary data" },
+  
+  { "-mswav",
+    ARG_BOOLEAN,
+    "no",
+    "Defines input format as Microsoft Wav (RIFF)" },
+
+  { "-samprate",
+    ARG_INT32,
+    "0",
+    "Sampling rate of audio data (will be determined automatically if 0)" },
+
+  { "-input_endian",
+    ARG_STRING,
+    NULL,
+    "Endianness of audio data (will be determined automatically if not given)" },
+
+  { "-fshift",
+    ARG_FLOAT32,
+    "0.01",
+    "Frame shift: number of seconds between each analysis frame." },
+
+  { "-flen",
+    ARG_FLOAT32,
+    "0.025",
+    "Number of seconds in each analysis frame (needs to be greater than twice the longest period you wish to detect - to detect down to 80Hz you need a frame length of 2.0/80 = 0.025)." },
+
+  { "-smooth_window",
+    ARG_INT32,
+    "2",
+    "Number of frames on either side of the current frame to use for smoothing." },
+
+  { "-voice_thresh",
+    ARG_FLOAT32,
+    "0.1",
+    "Threshold of normalized difference under which to search for the fundamental period." },
+
+  { "-search_range",
+    ARG_FLOAT32,
+    "0.2",
+    "Fraction of the best local estimate to use as a search range for smoothing." },
+
+  { NULL, 0, NULL, NULL }
+};
+
+static int extract_pitch(const char *in, const char *out);
+static int run_control_file(const char *ctl);
+
+int
+main(int argc, char *argv[])
+{
+    cmd_ln_parse(defn, argc, argv, TRUE);
+
+    /* Run a control file if requested. */
+    if (cmd_ln_str("-c")) {
+        if (run_control_file(cmd_ln_str("-c")) < 0)
+            return 1;
+    }
+    else {
+        if (extract_pitch(cmd_ln_str("-i"), cmd_ln_str("-o")) < 0)
+            return 1;
+    }
+
+    cmd_ln_free();
+    return 0;
+}
+
+static int
+guess_file_type(char const *file, FILE *infh)
+{
+    char header[4];
+
+    fseek(infh, 0, SEEK_SET);
+    if (fread(header, 1, 4, infh) != 4) {
+        E_ERROR_SYSTEM("Failed to read 4 byte header");
+        return -1;
+    }
+    if (0 == memcmp(header, "RIFF", 4)) {
+        E_INFO("%s appears to be a WAV file\n", file);
+        cmd_ln_set_boolean("-mswav", TRUE);
+        cmd_ln_set_boolean("-nist", FALSE);
+        cmd_ln_set_boolean("-raw", FALSE);
+    }
+    else if (0 == memcmp(header, "NIST", 4)) {
+        E_INFO("%s appears to be a NIST SPHERE file\n", file);
+        cmd_ln_set_boolean("-mswav", FALSE);
+        cmd_ln_set_boolean("-nist", TRUE);
+        cmd_ln_set_boolean("-raw", FALSE);
+    }
+    else {
+        E_INFO("%s appears to be raw data\n", file);
+        cmd_ln_set_boolean("-mswav", FALSE);
+        cmd_ln_set_boolean("-nist", FALSE);
+        cmd_ln_set_boolean("-raw", TRUE);
+    }
+    fseek(infh, 0, SEEK_SET);
+    return 0;
+}
+
+#define TRY_FREAD(ptr, size, nmemb, stream)                             \
+    if (fread(ptr, size, nmemb, stream) != (nmemb)) {                   \
+        E_ERROR_SYSTEM("Failed to read %d bytes", size * nmemb);       \
+        goto error_out;                                                 \
+    }
+
+static int
+read_riff_header(FILE *infh)
+{
+    char id[4];
+    int32 intval, header_len;
+    int16 shortval;
+
+    /* RIFF files are little-endian by definition. */
+    cmd_ln_set_str("-input_endian", "little");
+
+    /* Read in all the header chunks and etcetera. */
+    TRY_FREAD(id, 1, 4, infh);
+    /* Total file length (we don't care) */
+    TRY_FREAD(&intval, 4, 1, infh);
+    /* 'WAVE' */
+    TRY_FREAD(id, 1, 4, infh);
+    if (0 != memcmp(id, "WAVE", 4)) {
+        E_ERROR("This is not a WAVE file\n");
+        goto error_out;
+    }
+    /* 'fmt ' */
+    TRY_FREAD(id, 1, 4, infh);
+    if (0 != memcmp(id, "fmt ", 4)) {
+        E_ERROR("Format chunk missing\n");
+        goto error_out;
+    }
+    /* Length of 'fmt ' chunk */
+    TRY_FREAD(&intval, 4, 1, infh);
+    if (WORDS_BIGENDIAN) SWAP_INT32(&intval);
+    header_len = intval;
+
+    /* Data format. */
+    TRY_FREAD(&shortval, 2, 1, infh);
+    if (WORDS_BIGENDIAN) SWAP_INT16(&shortval);
+    if (shortval != 1) { /* PCM */
+        E_ERROR("WAVE file is not in PCM format\n");
+        goto error_out;
+    }
+
+    /* Number of channels. */
+    TRY_FREAD(&shortval, 2, 1, infh);
+    if (WORDS_BIGENDIAN) SWAP_INT16(&shortval);
+    if (shortval != 1) { /* PCM */
+        E_ERROR("WAVE file is not single channel\n");
+        goto error_out;
+    }
+
+    /* Sampling rate (finally!) */
+    TRY_FREAD(&intval, 4, 1, infh);
+    if (WORDS_BIGENDIAN) SWAP_INT32(&intval);
+    if (cmd_ln_int32("-samprate") == 0)
+        cmd_ln_set_int32("-samprate", intval);
+    else if (cmd_ln_int32("-samprate") != intval) {
+        E_WARN("WAVE file sampling rate %d != -samprate %d\n",
+               intval, cmd_ln_int32("-samprate"));
+    }
+
+    /* Average bytes per second (we don't care) */
+    TRY_FREAD(&intval, 4, 1, infh);
+
+    /* Block alignment (we don't care) */
+    TRY_FREAD(&shortval, 2, 1, infh);
+
+    /* Bits per sample (must be 16) */
+    TRY_FREAD(&shortval, 2, 1, infh);
+    if (WORDS_BIGENDIAN) SWAP_INT16(&shortval);
+    if (shortval != 16) {
+        E_ERROR("WAVE file is not 16-bit\n");
+        goto error_out;
+    }
+
+    /* Any extra parameters. */
+    if (header_len > 16)
+        fseek(infh, header_len - 16, SEEK_CUR);
+
+    /* Now skip to the 'data' chunk. */
+    while (1) {
+        TRY_FREAD(id, 1, 4, infh);
+        if (0 == memcmp(id, "data", 4)) {
+            /* Total number of bytes of data (we don't care). */
+            TRY_FREAD(&intval, 4, 1, infh);
+            break;
+        }
+        else {
+            /* Some other stuff... */
+            /* Number of bytes of ... whatever */
+            TRY_FREAD(&intval, 4, 1, infh);
+            if (WORDS_BIGENDIAN) SWAP_INT32(&intval);
+            fseek(infh, intval, SEEK_CUR);
+        }
+    }
+
+    /* We are ready to rumble. */
+    return 0;
+error_out:
+    return -1;
+}
+
+static int
+read_nist_header(FILE *infh)
+{
+    char hdr[1024];
+    char *line, *c;
+
+    TRY_FREAD(hdr, 1, 1024, infh);
+    hdr[1023] = '\0';
+
+    /* Roughly parse it to find the sampling rate and byte order
+     * (don't bother with other stuff) */
+    if ((line = strstr(hdr, "sample_rate")) == NULL) {
+        E_ERROR("No sampling rate in NIST header!\n");
+        goto error_out;
+    }
+    c = strchr(line, '\n');
+    if (c) *c = '\0';
+    c = strrchr(line, ' ');
+    if (c == NULL) {
+        E_ERROR("Could not find sampling rate!\n");
+        goto error_out;
+    }
+    ++c;
+    if (cmd_ln_int32("-samprate") == 0)
+        cmd_ln_set_int32("-samprate", atoi(c));
+    else if (cmd_ln_int32("-samprate") != atoi(c)) {
+        E_WARN("NIST file sampling rate %d != -samprate %d\n",
+               atoi(c), cmd_ln_int32("-samprate"));
+    }
+
+    if (line + strlen(line) < hdr + 1023)
+        line[strlen(line)] = ' ';
+    if ((line = strstr(hdr, "sample_byte_format")) == NULL) {
+        E_ERROR("No sample byte format in NIST header!\n");
+        goto error_out;
+    }
+    c = strchr(line, '\n');
+    if (c) *c = '\0';
+    c = strrchr(line, ' ');
+    if (c == NULL) {
+        E_ERROR("Could not find sample byte order!\n");
+        goto error_out;
+    }
+    ++c;
+    if (0 == memcmp(c, "01", 2)) {
+        cmd_ln_set_str("-input_endian", "little");
+    }
+    else if (0 == memcmp(c, "10", 2)) {
+        cmd_ln_set_str("-input_endian", "big");
+    }
+    else {
+        E_ERROR("Unknown byte order %s\n", c);
+        goto error_out;
+    }
+
+    /* We are ready to rumble. */
+    return 0;
+error_out:
+    return -1;
+}
+
+static int
+extract_pitch(const char *in, const char *out)
+{
+    FILE *infh = NULL, *outfh = NULL;
+    size_t flen, fshift, nsamps;
+    int16 *buf = NULL;
+    yin_t *yin = NULL;
+    uint16 period, bestdiff;
+    int32 sps;
+
+    if (out) {
+        if ((outfh = fopen(out, "w")) == NULL) {
+            E_ERROR_SYSTEM("Failed to open %s for writing", outfh);
+            goto error_out;
+        }
+    }
+    else {
+        outfh = stdout;
+    }
+    if ((infh = fopen(in, "rb")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open %s for reading", infh);
+        goto error_out;
+    }
+
+    /* If we weren't told what the file type is, weakly try to
+     * determine it (actually it's pretty obvious) */
+    if (!(cmd_ln_boolean("-raw")
+          || cmd_ln_boolean("-mswav")
+          || cmd_ln_boolean("-nist"))) {
+        if (guess_file_type(in, infh) < 0)
+            goto error_out;
+    }
+    
+    /* Grab the sampling rate and byte order from the header and also
+     * make sure this is 16-bit linear PCM. */
+    if (cmd_ln_boolean("-mswav")) {
+        if (read_riff_header(infh) < 0)
+            goto error_out;
+    }
+    else if (cmd_ln_boolean("-nist")) {
+        if (read_nist_header(infh) < 0)
+            goto error_out;
+    }
+    else if (cmd_ln_boolean("-raw")) {
+        /* Just use some defaults for sampling rate and endian. */
+        if (cmd_ln_str("-input_endian") == NULL) {
+            if (WORDS_BIGENDIAN)
+                cmd_ln_set_str("-input_endian", "big");
+            else
+                cmd_ln_set_str("-input_endian", "little");
+        }
+        if (cmd_ln_int32("-samprate") == 0)
+            cmd_ln_set_int32("-samprate", 16000);
+    }
+
+    /* Now read frames and write pitch estimates. */
+    sps = cmd_ln_int32("-samprate");
+    flen = (size_t)(0.5 + sps * cmd_ln_float32("-flen"));
+    fshift = (size_t)(0.5 + sps * cmd_ln_float32("-fshift"));
+    yin = yin_init(flen, cmd_ln_float32("-voice_thresh"),
+                   cmd_ln_float32("-search_range"),
+                   cmd_ln_int32("-smooth_window"));
+    if (yin == NULL) {
+        E_ERROR("Failed to initialize YIN\n");
+        goto error_out;
+    }
+    buf = ckd_calloc(flen, sizeof(*buf));
+    /* Read the first full frame of data. */
+    if (fread(buf, sizeof(*buf), flen, infh) != flen) {
+        /* Fail silently, which is probably okay. */
+    }
+    yin_start(yin);
+    nsamps = 0;
+    while (!feof(infh)) {
+        /* Process a frame of data. */
+        yin_write(yin, buf);
+        if (yin_read(yin, &period, &bestdiff)) {
+            fprintf(outfh, "%.3f %.2f %.2f\n",
+                    /* Time point. */
+                    (double)nsamps/sps,
+                    /* "Probability" of voicing. */
+                    bestdiff > 32768 ? 0.0 : 1.0 - (double)bestdiff / 32768,
+                    /* Pitch (possibly bogus) */
+                    period == 0 ? sps : (double)sps / period);
+            nsamps += fshift;
+        }
+        /* Shift it back and get the next frame's overlap. */
+        memmove(buf, buf + fshift, (flen - fshift) * sizeof(*buf));
+        if (fread(buf + flen - fshift, sizeof(*buf), fshift, infh) != fshift) {
+            /* Fail silently (FIXME: really?) */
+        }
+    }
+    yin_end(yin);
+    /* Process trailing frames of data. */
+    while (yin_read(yin, &period, &bestdiff)) {
+            fprintf(outfh, "%.3f %.2f %.2f\n",
+                    /* Time point. */
+                    (double)nsamps/sps,
+                    /* "Probability" of voicing. */
+                    bestdiff > 32768 ? 0.0 : 1.0 - (double)bestdiff / 32768,
+                    /* Pitch (possibly bogus) */
+                    period == 0 ? sps : (double)sps / period);
+    }
+
+    if (yin)
+        yin_free(yin);
+    ckd_free(buf);
+    fclose(infh);
+    if (outfh != stdout)
+        fclose(outfh);
+    return 0;
+
+error_out:
+    yin_free(yin);
+    ckd_free(buf);
+    if (infh) fclose(infh);
+    if (outfh && outfh != stdout) fclose(outfh);
+    return -1;
+}
+
+static int
+run_control_file(const char *ctl)
+{
+    FILE *ctlfh;
+    char *line;
+    char *di, *dout, *ei, *eio;
+    size_t len;
+    int rv, guess_type, guess_sps, guess_endian;
+    int32 skip, runlen;
+
+    skip = cmd_ln_int32("-nskip");
+    runlen = cmd_ln_int32("-runlen");
+
+    /* Whether to guess file types */
+    guess_type = !(cmd_ln_boolean("-raw")
+                   || cmd_ln_boolean("-mswav")
+                   || cmd_ln_boolean("-nist"));
+    /* Whether to guess sampling rate */
+    guess_sps = (cmd_ln_int32("-samprate") == 0);
+    /* Whether to guess endian */
+    guess_endian = (cmd_ln_str("-input_endian") == NULL);
+
+    if ((ctlfh = fopen(ctl, "r")) == NULL) {
+        E_ERROR_SYSTEM("Failed to open control file %s", ctl);
+        return -1;
+    }
+    if (cmd_ln_str("-di"))
+        di = string_join(cmd_ln_str("-di"), "/", NULL);
+    else
+        di = ckd_salloc("");
+    if (cmd_ln_str("-do"))
+        dout = string_join(cmd_ln_str("-do"), "/", NULL);
+    else
+        dout = ckd_salloc("");
+    if (cmd_ln_str("-ei"))
+        ei = string_join(".", cmd_ln_str("-ei"), NULL);
+    else
+        ei = ckd_salloc("");
+    if (cmd_ln_str("-eo"))
+        eio = string_join(".", cmd_ln_str("-eo"), NULL);
+    else
+        eio = ckd_salloc("");
+    rv = 0;
+    while ((line = fread_line(ctlfh, &len)) != NULL) {
+        char *infile, *outfile;
+
+        if (skip-- > 0) {
+            ckd_free(line);
+            continue;
+        }
+        if (runlen == 0) {
+            ckd_free(line);
+            break;
+        }
+        --runlen;
+
+        if (line[len-1] == '\n')
+            line[len-1] = '\0';
+
+        infile = string_join(di, line, ei, NULL);
+        outfile = string_join(dout, line, eio, NULL);
+
+        /* Reset various guessed information */
+        if (guess_type) {
+            cmd_ln_set_boolean("-nist", FALSE);
+            cmd_ln_set_boolean("-mswav", FALSE);
+            cmd_ln_set_boolean("-raw", FALSE);
+        }
+        if (guess_sps)
+            cmd_ln_set_int32("-samprate", 0);
+        if (guess_endian)
+            cmd_ln_set_str("-input_endian", NULL);
+
+        rv = extract_pitch(infile, outfile);
+
+        ckd_free(infile);
+        ckd_free(outfile);
+        ckd_free(line);
+
+        if (rv != 0)
+            break;
+    }
+    ckd_free(di);
+    ckd_free(dout);
+    ckd_free(ei);
+    ckd_free(eio);
+    fclose(ctlfh);
+    return rv;
+}

src/tests/libs/sphinx/sphinx_adtools/cont_fileseg.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1999-2001 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.
+ *
+ * ====================================================================
+ *
+ */
+/*
+ * cont_fileseg.c -- Read input file, filter silence regions, and segment into utterances.
+ * 
+ * HISTORY
+ * 
+ * $Log: cont_fileseg.c,v $
+ * Revision 1.1.1.1  2006/05/23 18:45:02  dhuggins
+ * re-importation
+ *
+ * Revision 1.13  2005/06/30 00:28:46  rkm
+ * Kept within-utterance silences in rawmode
+ *
+ * 
+ * 28-Jun-2005  M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ *      Modified to use new state variables in cont_ad_t.
+ * 
+ * Revision 1.12  2005/05/31 15:54:38  rkm
+ * *** empty log message ***
+ *
+ * Revision 1.11  2005/05/24 20:56:58  rkm
+ * Added min/max-noise parameters to cont_fileseg
+ *
+ * Revision 1.10  2005/05/13 23:28:43  egouvea
+ * Changed null device to system dependent one: NUL for windows, /dev/null for everything else
+ * 
+ * $Log: cont_fileseg.c,v $
+ * Revision 1.1.1.1  2006/05/23 18:45:02  dhuggins
+ * re-importation
+ *
+ * Revision 1.13  2005/06/30 00:28:46  rkm
+ * Kept within-utterance silences in rawmode
+ *
+ * Revision 1.12  2005/05/31 15:54:38  rkm
+ * *** empty log message ***
+ *
+ * Revision 1.11  2005/05/24 20:56:58  rkm
+ * Added min/max-noise parameters to cont_fileseg
+ *
+ * Revision 1.9  2005/02/13 01:29:48  rkm
+ * Fixed cont_ad_read to never cross sil/speech boundary, and rawmode
+ *
+ * Revision 1.8  2005/02/01 22:21:13  rkm
+ * Added raw data logging, and raw data pass-through mode to cont_ad
+ *
+ * Revision 1.7  2004/07/16 00:57:11  egouvea
+ * Added Ravi's implementation of FSG support.
+ *
+ * Revision 1.3  2004/06/25 14:58:05  rkm
+ * *** empty log message ***
+ *
+ * Revision 1.2  2004/06/23 20:32:08  rkm
+ * Exposed several cont_ad config parameters
+ *
+ * 
+ * 27-Jun-96    M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ *      Created.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+
+#include <prim_type.h>
+#include <ad.h>
+#include <cont_ad.h>
+#include <err.h>
+
+static FILE *infp;              /* File being segmented */
+static int32 swap;
+
+/* Max size read by file_ad_read function on each invocation, for debugging */
+static int32 max_ad_read_size;
+
+#if defined(WIN32) && !defined(GNUWINCE)
+#define NULL_DEVICE "NUL"
+#else
+#define NULL_DEVICE "/dev/null"
+#endif
+
+
+/*
+ * Need to provide cont_ad_init with a read function to read the input file.
+ * This is it.  The ad_rec_t *r argument is ignored since there is no A/D
+ * device involved.
+ */
+static int32
+file_ad_read(ad_rec_t * r, int16 * buf, int32 max)
+{
+    int32 i, k;
+
+    if (max > max_ad_read_size)
+        max = max_ad_read_size;
+
+    k = fread(buf, sizeof(int16), max, infp);
+    if (swap) {
+        for (i = 0; i < k; i++) {
+            buf[i] = ((buf[i] >> 8) & 0x00ff) | ((buf[i] << 8) & 0xff00);
+        }
+    }
+
+    return ((k > 0) ? k : -1);
+}
+
+
+static void
+usagemsg(char *pgm)
+{
+    E_INFO("Usage: %s \\\n", pgm);
+    E_INFOCONT("\t[-? | -h] \\\n");
+    E_INFOCONT("\t[-d | -debug] \\\n");
+    E_INFOCONT("\t[-sps <sampling-rate> (16000)] \\\n");
+    E_INFOCONT("\t[-b | -byteswap] \\\n");
+    E_INFOCONT
+        ("\t[{-s | -silsep} <length-silence-separator(sec) (0.5)]> \\\n");
+    E_INFOCONT("\t[-w | -writeseg] \\\n");
+    E_INFOCONT("\t[-min-noise <min-noise>] \\\n");
+    E_INFOCONT("\t[-max-noise <max-noise>] \\\n");
+    E_INFOCONT("\t[-delta-sil <delta-sil>] \\\n");
+    E_INFOCONT("\t[-delta-speech <delta-speech>] \\\n");
+    E_INFOCONT("\t[-sil-onset <sil-onset>] \\\n");
+    E_INFOCONT("\t[-speech-onset <speech-onset>] \\\n");
+    E_INFOCONT("\t[-adapt-rate <adapt-rate>] \\\n");
+    E_INFOCONT("\t[-max-adreadsize <ad_read_blksize>] \\\n");
+    E_INFOCONT("\t[-c <copy-input-file>] \\\n");
+    E_INFOCONT("\t[-r | -rawmode] \\\n");
+    E_INFOCONT("\t-i <input-file>\n");
+
+    exit(0);
+}
+
+/*
+ * Read specified input file, segment it into utterances wherever a silence segment of
+ * a given minimum duration is encountered.  Filter out long silences.
+ * Utterances are written to files named 00000000.raw, 00000001.raw, 00000002.raw, etc.
+ */
+int
+main(int32 argc, char **argv)
+{
+    cont_ad_t *cont;
+    int32 uttid, uttlen, starttime, siltime, sps, debug, writeseg, rawmode;
+    int16 buf[4096];
+    char *infile, *copyfile, segfile[1024];
+    FILE *fp;
+    float endsil;
+    ad_rec_t ad;
+    int32 i, k;
+    int32 winsize, leader, trailer;
+    int32 orig_min_noise, orig_max_noise;
+    int32 orig_delta_sil, orig_delta_speech;
+    int32 orig_speech_onset, orig_sil_onset;
+    int32 min_noise, max_noise;
+    int32 delta_sil, delta_speech;
+    int32 sil_onset, speech_onset;
+    float32 orig_adapt_rate;
+    float32 adapt_rate;
+    int32 total_speech_samples;
+    float32 total_speech_sec;
+    FILE *rawfp;
+
+    /* Set argument defaults */
+    cont = NULL;
+    sps = 16000;
+    swap = 0;
+    endsil = 0.5;
+    writeseg = 0;
+    min_noise = max_noise = -1;
+    delta_sil = delta_speech = -1;
+    sil_onset = speech_onset = -1;
+    adapt_rate = -1.0;
+    max_ad_read_size = (int32) 0x7ffffff0;
+    debug = 0;
+    infile = NULL;
+    copyfile = NULL;
+    rawfp = NULL;
+    rawmode = 0;
+
+    /* Parse arguments */
+    for (i = 1; i < argc; i++) {
+        if ((strcmp(argv[i], "-help") == 0)
+            || (strcmp(argv[i], "-h") == 0)
+            || (strcmp(argv[i], "-?") == 0)) {
+            usagemsg(argv[0]);
+        }
+        else if ((strcmp(argv[i], "-debug") == 0)
+                 || (strcmp(argv[i], "-d") == 0)) {
+            debug = 1;
+        }
+        else if (strcmp(argv[i], "-sps") == 0) {
+            i++;
+            if ((i == argc)
+                || (sscanf(argv[i], "%d", &sps) != 1)
+                || (sps <= 0)) {
+                E_ERROR("Invalid -sps argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if ((strcmp(argv[i], "-byteswap") == 0)
+                 || (strcmp(argv[i], "-b") == 0)) {
+            swap = 1;
+        }
+        else if ((strcmp(argv[i], "-silsep") == 0)
+                 || (strcmp(argv[i], "-s") == 0)) {
+            i++;
+            if ((i == argc)
+                || (sscanf(argv[i], "%f", &endsil) != 1)
+                || (endsil <= 0.0)) {
+                E_ERROR("Invalid -silsep argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if ((strcmp(argv[i], "-writeseg") == 0)
+                 || (strcmp(argv[i], "-w") == 0)) {
+            writeseg = 1;
+        }
+        else if (strcmp(argv[i], "-min-noise") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%d", &min_noise) != 1) ||
+                (min_noise < 0)) {
+                E_ERROR("Invalid -min-noise argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-max-noise") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%d", &max_noise) != 1) ||
+                (max_noise < 0)) {
+                E_ERROR("Invalid -max-noise argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-delta-sil") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%d", &delta_sil) != 1) ||
+                (delta_sil < 0)) {
+                E_ERROR("Invalid -delta-sil argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-delta-speech") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%d", &delta_speech) != 1) ||
+                (delta_speech < 0)) {
+                E_ERROR("Invalid -delta-speech argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-sil-onset") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%d", &sil_onset) != 1) ||
+                (sil_onset < 1)) {
+                E_ERROR("Invalid -sil-onset argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-speech-onset") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%d", &speech_onset) != 1) ||
+                (speech_onset < 1)) {
+                E_ERROR("Invalid -speech-onset argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-adapt-rate") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%f", &adapt_rate) != 1) ||
+                (adapt_rate < 0.0) || (adapt_rate > 1.0)) {
+                E_ERROR("Invalid -adapt-rate argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-max-adreadsize") == 0) {
+            i++;
+            if ((i == argc) ||
+                (sscanf(argv[i], "%d", &max_ad_read_size) != 1) ||
+                (max_ad_read_size < 1)) {
+                E_ERROR("Invalid -max-adreadsize argument\n");
+                usagemsg(argv[0]);
+            }
+        }
+        else if (strcmp(argv[i], "-c") == 0) {
+            i++;
+            if (i == argc) {
+                E_ERROR("Invalid -c argument\n");
+                usagemsg(argv[0]);
+            }
+            copyfile = argv[i];
+        }
+        else if ((strcmp(argv[i], "-rawmode") == 0)
+                 || (strcmp(argv[i], "-r") == 0)) {
+            rawmode = 1;
+        }
+        else if (strcmp(argv[i], "-i") == 0) {
+            i++;
+            if (i == argc) {
+                E_ERROR("Invalid -i argument\n");
+                usagemsg(argv[0]);
+            }
+            infile = argv[i];
+        }
+        else {
+            usagemsg(argv[0]);
+        }
+    }
+
+    if (infile == NULL) {
+        E_ERROR("No input file specified\n");
+        usagemsg(argv[0]);
+    }
+
+    if ((infp = fopen(infile, "rb")) == NULL)
+        E_FATAL("fopen(%s,rb) failed\n", infile);
+
+    /*
+     * Associate continuous listening module with opened input file and read function.
+     * No A/D device is involved, but need to fill in ad->sps.
+     * Calibrate input data using first few seconds of file, but then rewind it!!
+     */
+    ad.sps = sps;
+    ad.bps = sizeof(int16);
+    if (!rawmode)
+        cont = cont_ad_init(&ad, file_ad_read);
+    else
+        cont = cont_ad_init_rawmode(&ad, file_ad_read);
+
+    printf("Calibrating ...");
+    fflush(stdout);
+    if (cont_ad_calib(cont) < 0)
+        printf(" failed; file too short?\n");
+    else
+        printf(" done\n");
+    rewind(infp);
+
+    /* Convert desired min. inter-utterance silence duration to #samples */
+    siltime = (int32) (endsil * sps);
+
+    /* Enable writing raw input to output by the cont module if specified */
+    if (copyfile) {
+        if ((rawfp = fopen(copyfile, "wb")) == NULL)
+            E_ERROR("fopen(%s,wb) failed; not dumping raw file\n",
+                    copyfile);
+        else
+            cont_ad_set_rawfp(cont, rawfp);
+    }
+
+    cont_ad_get_params(cont,
+                       &orig_delta_sil, &orig_delta_speech,
+                       &orig_min_noise, &orig_max_noise,
+                       &winsize,
+                       &orig_speech_onset, &orig_sil_onset,
+                       &leader, &trailer, &orig_adapt_rate);
+
+    E_INFO("Default parameters:\n");
+    E_INFOCONT("\tmin-noise = %d, max-noise = %d\n",
+               orig_min_noise, orig_max_noise);
+    E_INFOCONT("\tdelta-sil = %d, delta-speech = %d\n",
+               orig_delta_sil, orig_delta_speech);
+    E_INFOCONT("\tsil-onset = %d, speech-onset = %d\n",
+               orig_sil_onset, orig_speech_onset);
+    E_INFOCONT("\tadapt_rate = %.3f\n", orig_adapt_rate);
+
+    if (min_noise < 0)
+        min_noise = orig_min_noise;
+    if (max_noise < 0)
+        max_noise = orig_max_noise;
+    if (delta_sil < 0)
+        delta_sil = orig_delta_sil;
+    if (delta_speech < 0)
+        delta_speech = orig_delta_speech;
+    if (sil_onset < 0)
+        sil_onset = orig_sil_onset;
+    if (speech_onset < 0)
+        speech_onset = orig_speech_onset;
+    if (adapt_rate < 0.0)
+        adapt_rate = orig_adapt_rate;
+
+    cont_ad_set_params(cont,
+                       delta_sil, delta_speech,
+                       min_noise, max_noise,
+                       winsize,
+                       speech_onset, sil_onset,
+                       leader, trailer, adapt_rate);
+
+    E_INFO("Current parameters:\n");
+    E_INFOCONT("\tmin-noise = %d, max-noise = %d\n", min_noise, max_noise);
+    E_INFOCONT("\tdelta-sil = %d, delta-speech = %d\n", delta_sil,
+               delta_speech);
+    E_INFOCONT("\tsil-onset = %d, speech-onset = %d\n", sil_onset,
+               speech_onset);
+    E_INFOCONT("\tadapt_rate = %.3f\n", adapt_rate);
+
+    E_INFO("Sampling rate: %d", sps);
+    E_INFOCONT("; Byteswap: %s", swap ? "Yes" : "No");
+    E_INFOCONT("; Max ad-read size: %d\n", max_ad_read_size);
+
+    if (debug)
+        cont_ad_set_logfp(cont, stdout);
+
+    total_speech_samples = 0;
+    total_speech_sec = 0.0;
+
+    uttid = 0;
+    uttlen = 0;
+    starttime = 0;
+    fp = NULL;
+
+    /* Process data */
+    for (;;) {
+        /* Get audio data from continuous listening module */
+        k = cont_ad_read(cont, buf, 4096);
+
+        if (k < 0) {            /* End of input audio file; close any open output file and exit */
+            if (fp != NULL) {
+                fclose(fp);
+                fp = NULL;
+
+                printf
+                    ("Utt %08d, st= %8.2fs, et= %8.2fs, seg= %7.2fs (#samp= %10d)\n",
+                     uttid, (double) starttime / (double) sps,
+                     (double) (starttime + uttlen) / (double) sps,
+                     (double) uttlen / (double) sps, uttlen);
+                fflush(stdout);
+
+                total_speech_samples += uttlen;
+                total_speech_sec += (double) uttlen / (double) sps;
+
+                uttid++;
+            }
+
+            break;
+        }
+
+        if (cont->state == CONT_AD_STATE_SIL) { /* Silence data got */
+            if (fp != NULL) {   /* Currently in an utterance */
+                if (cont->seglen > siltime) {   /* Long enough silence detected; end the utterance */
+                    fclose(fp);
+                    fp = NULL;
+
+                    printf
+                        ("Utt %08d, st= %8.2fs, et= %8.2fs, seg= %7.2fs (#samp= %10d)\n",
+                         uttid, (double) starttime / (double) sps,
+                         (double) (starttime + uttlen) / (double) sps,
+                         (double) uttlen / (double) sps, uttlen);
+                    fflush(stdout);
+
+                    total_speech_samples += uttlen;
+                    total_speech_sec += (double) uttlen / (double) sps;
+
+                    uttid++;
+                }
+                else {
+                    /*
+                     * Short silence within utt; write it to output.  (Some extra trailing silence
+                     * is included in the utterance, as a result.  Not to worry about it.)
+                     */
+                    if (k > 0) {
+                        fwrite(buf, sizeof(int16), k, fp);
+                        uttlen += k;
+                    }
+                }
+            }
+        }
+        else {
+            assert(cont->state == CONT_AD_STATE_SPEECH);
+
+            if (fp == NULL) {   /* Not in an utt; open a new output file */
+                if (writeseg)
+                    sprintf(segfile, "%08d.raw", uttid);
+                else
+                    strcpy(segfile, NULL_DEVICE);
+                if ((fp = fopen(segfile, "wb")) == NULL)
+                    E_FATAL("fopen(%s,wb) failed\n", segfile);
+
+                starttime = cont->read_ts - k;
+                uttlen = 0;
+            }
+
+            /* Write data obtained to output file */
+            if (k > 0) {
+                fwrite(buf, sizeof(int16), k, fp);
+                uttlen += k;
+            }
+        }
+    }
+
+    if (rawfp)
+        fclose(rawfp);
+
+    E_INFO("Total raw input speech = %d frames, %d samples, %.2f sec\n",
+           cont->tot_frm, cont->tot_frm * cont->spf,
+           (cont->tot_frm * cont->spf) / (float32) cont->sps);
+    E_INFO("Total speech detected = %d samples, %.2f sec\n",
+           total_speech_samples, total_speech_sec);
+
+    cont_ad_close(cont);
+
+    return 0;
+}

src/tests/libs/sphinx/sphinx_adtools/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx sphinx_adtools ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+
+SimpleTest sphinx_cont_adseg : cont_adseg.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest sphinx_cont_fileseg : cont_fileseg.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest sphinx_pitch : sphinx_pitch.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/sphinx_adtools/cont_adseg.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* ====================================================================
+ * Copyright (c) 1999-2001 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.
+ *
+ * ====================================================================
+ *
+ */
+/*
+ * cont_adseg.c -- Continuously listen and segment input speech into utterances.
+ * 
+ * HISTORY
+ * 
+ * 27-Jun-96    M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ *      Created.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+
+#include <prim_type.h>
+#include <ad.h>
+#include <cont_ad.h>
+#include <err.h>
+
+/*
+ * Segment raw A/D input data into utterances whenever silence region of given
+ * duration is encountered.
+ * Utterances are written to files named 0001.raw, 0002.raw, 0003.raw, etc.
+ */
+int
+main(int32 argc, char **argv)
+{
+    ad_rec_t *ad;
+    cont_ad_t *cont;
+    int32 k, uttno, ts, uttlen, sps, endsilsamples;
+    float endsil;
+    int16 buf[4096];
+    FILE *fp;
+    char file[1024];
+
+    if ((argc != 3) ||
+        (sscanf(argv[1], "%d", &sps) != 1) ||
+        (sscanf(argv[2], "%f", &endsil) != 1) || (endsil <= 0.0)) {
+        E_FATAL("Usage: %s <sampling-rate> <utt-end-sil(sec)>\n", argv[0]);
+    }
+
+    /* Convert desired min. inter-utterance silence duration to #samples */
+    endsilsamples = (int32) (endsil * sps);
+
+    /* Open raw A/D device */
+    if ((ad = ad_open_sps(sps)) == NULL)
+        E_FATAL("ad_open_sps(%d) failed\n", sps);
+
+    /* Associate new continuous listening module with opened raw A/D device */
+    if ((cont = cont_ad_init(ad, ad_read)) == NULL)
+        E_FATAL("cont_ad_init failed\n");
+
+    /* Calibrate continuous listening for background noise/silence level */
+    printf("Calibrating ...");
+    fflush(stdout);
+    ad_start_rec(ad);
+    if (cont_ad_calib(cont) < 0)
+        printf(" failed\n");
+    else
+        printf(" done\n");
+
+    /* Forever listen for utterances */
+    printf("You may speak now\n");
+    fflush(stdout);
+    uttno = 0;
+    for (;;) {
+        /* Wait for beginning of next utterance; for non-silence data */
+        while ((k = cont_ad_read(cont, buf, 4096)) == 0);
+        if (k < 0)
+            E_FATAL("cont_ad_read failed\n");
+
+        /* Non-silence data received; open and write to new logging file */
+        uttno++;
+        sprintf(file, "%04d.raw", uttno);
+        if ((fp = fopen(file, "wb")) == NULL)
+            E_FATAL("fopen(%s,wb) failed\n", file);
+        fwrite(buf, sizeof(int16), k, fp);
+        uttlen = k;
+        printf("Utterance %04d, logging to %s\n", uttno, file);
+
+        /* Note current timestamp */
+        ts = cont->read_ts;
+
+        /* Read utterance data until a gap of at least 1 sec observed */
+        for (;;) {
+            if ((k = cont_ad_read(cont, buf, 4096)) < 0)
+                E_FATAL("cont_ad_read failed\n");
+            if (k == 0) {
+                /*
+                 * No speech data available; check current timestamp.  End of
+                 * utterance if no non-silence data been read for at least 1 sec.
+                 */
+                if ((cont->read_ts - ts) > endsilsamples)
+                    break;
+            }
+            else {
+                /* Note timestamp at the end of most recently read speech data */
+                ts = cont->read_ts;
+                uttlen += k;
+                fwrite(buf, sizeof(int16), k, fp);
+            }
+        }
+        fclose(fp);
+
+        printf("\tUtterance %04d = %d samples (%.1fsec)\n\n",
+               uttno, uttlen, (double) uttlen / (double) sps);
+    }
+
+    ad_stop_rec(ad);
+    cont_ad_close(cont);
+    ad_close(ad);
+    return 0;
+}

src/tests/libs/sphinx/test_matrix/_test_determinant.res

@@ +1 @@
+5.22
+-1.00

src/tests/libs/sphinx/test_matrix/_test_invert.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./test_invert | sed -e 's,-0\.0,0.0,g' > _test_invert.out
+compare_table invert _test_invert.out $tests/unit/test_matrix/_test_invert.res
+rm -f _test_invert.out

src/tests/libs/sphinx/test_matrix/_test_solve.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./test_solve > _test_solve.out
+compare_table solve _test_solve.out $tests/unit/test_matrix/_test_solve.res
+rm -f _test_solve.out

src/tests/libs/sphinx/test_matrix/_test_determinant.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./test_determinant | sed -e 's,-0\.0,0.0,g' > _test_determinant.out
+compare_table determinant _test_determinant.out $tests/unit/test_matrix/_test_determinant.res
+rm -f _test_determinant.out

src/tests/libs/sphinx/test_matrix/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_matrix ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_solve : test_solve.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_determinant : test_determinant.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_invert : test_invert.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_matrix/test_invert.c

@@ +1 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "matrix.h"
+#include "ckd_alloc.h"
+
+const float32 foo[3][3] = {
+    {2, 1, 1},
+    {1, 2, 1},
+    {1, 1, 2}
+};
+const float32 bar[3][3] = {
+    {2, 0.5, 1},
+    {0.5, 2, 1},
+    {1, 1, 2}
+};
+
+int
+main(int argc, char *argv[])
+{
+    float32 **a, **ainv, **ii;
+    int i, j;
+
+    a = (float32 **)ckd_calloc_2d(3, 3, sizeof(float32));
+    ainv = (float32 **)ckd_calloc_2d(3, 3, sizeof(float32));
+    ii = (float32 **)ckd_calloc_2d(3, 3, sizeof(float32));
+
+    memcpy(a[0], foo, sizeof(float32) * 3 * 3);
+    printf("%d\n", invert(ainv, a, 3));
+    /* Should see:
+       0.75 -0.25 -0.25 
+       -0.25 0.75 -0.25 
+       -0.25 -0.25 0.75 
+    */
+    for (i = 0; i < 3; ++i) {
+        for (j = 0; j < 3; ++j) {
+            printf("%.2f ", ainv[i][j]);
+        }
+        printf("\n");
+    }
+    /* Should see:
+       1.00 0.00 0.00
+       0.00 1.00 0.00
+       0.00 0.00 1.00
+    */
+    matrixmultiply(ii, ainv, a, 3);
+    for (i = 0; i < 3; ++i) {
+        for (j = 0; j < 3; ++j) {
+            printf("%.2f ", ii[i][j]);
+        }
+        printf("\n");
+    }
+
+    memcpy(a[0], bar, sizeof(float32) * 3 * 3);
+    printf("%d\n", invert(ainv, a, 3));
+    /* Should see:
+    */
+    for (i = 0; i < 3; ++i) {
+        for (j = 0; j < 3; ++j) {
+            printf("%.2f ", ainv[i][j]);
+        }
+        printf("\n");
+    }
+    /* Should see:
+       1.00 0.00 0.00 
+       0.00 1.00 0.00 
+       0.00 0.00 1.00 
+    */
+    memset(ii[0], 0, sizeof(float32) * 3 * 3);
+    matrixmultiply(ii, ainv, a, 3);
+    for (i = 0; i < 3; ++i) {
+        for (j = 0; j < 3; ++j) {
+            printf("%.2f ", ii[i][j]);
+        }
+        printf("\n");
+    }
+
+    /* Should see:
+       -1
+    */
+    a[0][0] = 1.0;
+    printf("%d\n", invert(ainv, a, 3));
+
+    ckd_free_2d((void **)a);
+    ckd_free_2d((void **)ainv);
+    ckd_free_2d((void **)ii);
+
+    return 0;
+}

src/tests/libs/sphinx/test_matrix/test_solve.c

@@ +1 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "matrix.h"
+#include "ckd_alloc.h"
+
+const float32 foo[3][3] = {
+    {2, 1, 1},
+    {1, 2, 1},
+    {1, 1, 2}
+};
+float32 bar[3] = {1, 3, 1};
+
+int
+main(int argc, char *argv[])
+{
+    float32 **a, *x;
+    int i;
+
+    a = (float32 **)ckd_calloc_2d(3, 3, sizeof(float32));
+    memcpy(a[0], foo, sizeof(float32) * 3 * 3);
+    x = ckd_calloc(3, sizeof(float32));
+
+    /* Should see:
+       -0.25 1.75 -0.25
+    */
+    solve(a, bar, x, 3);
+    for (i = 0; i < 3; ++i)
+        printf("%.2f ", x[i]);
+    printf("\n");
+
+    ckd_free_2d((void **)a);
+    ckd_free(x);
+
+    return 0;
+}

src/tests/libs/sphinx/test_matrix/test_determinant.c

@@ +1 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "matrix.h"
+#include "ckd_alloc.h"
+
+const float32 foo[3][3] = {
+    {2, 0.42, 1},
+    {0.42, 2, -0.3},
+    {1, -0.3, 2}
+};
+const float32 bar[3][3] = {
+    {1, 0, 1},
+    {0, 1, 0},
+    {0, 0, 1}
+};
+
+int
+main(int argc, char *argv[])
+{
+    float32 **a;
+
+    a = (float32 **)ckd_calloc_2d(3, 3, sizeof(float32));
+
+    memcpy(a[0], foo, sizeof(float32) * 3 * 3);
+    /* Should see 5.22 */
+    printf("%.2f\n", determinant(a, 3));
+
+    /* Should see -1.0 */
+    memcpy(a[0], bar, sizeof(float32) * 3 * 3);
+    printf("%.2f\n", determinant(a, 3));
+
+    ckd_free_2d((void **)a);
+
+    return 0;
+}

src/tests/libs/sphinx/test_matrix/_test_invert.res

@@ +1 @@
+0
+0.75 -0.25 -0.25 
+-0.25 0.75 -0.25 
+-0.25 -0.25 0.75 
+1.00 0.00 0.00 
+0.00 1.00 0.00 
+0.00 0.00 1.00 
+0
+0.67 0.00 -0.33 
+0.00 0.67 -0.33 
+-0.33 -0.33 0.83 
+1.00 0.00 0.00 
+0.00 1.00 0.00 
+0.00 0.00 1.00 
+0

src/tests/libs/sphinx/test_matrix/_test_solve.res

@@ +1 @@
+-0.25 1.75 -0.25 

src/tests/libs/sphinx/test_ngram/100.probdef

@@ +1 @@
+LMCLASS scylla
+scylla:scylla       0.4
+karybdis:scylla     0.4
+scooby:scylla       0.1
+redwood:scylla      0.1
+END scylla
+
+LMCLASS zero
+zero:zero   0.3
+oh:zero     0.7
+END zero

src/tests/libs/sphinx/test_ngram/test_lm_score.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+void
+run_tests(ngram_model_t *model)
+{
+    int32 n_used;
+
+    ngram_tg_score(model,
+               ngram_wid(model, "daines"),
+               ngram_wid(model, "huggins"),
+               ngram_wid(model, "huggins"), &n_used);
+    TEST_EQUAL(n_used, 2);
+    ngram_tg_score(model,
+               ngram_wid(model, "david"),
+               ngram_wid(model, "david"),
+               ngram_wid(model, "david"), &n_used);
+    TEST_EQUAL(n_used, 1);
+
+    /* Apply weights. */
+    ngram_model_apply_weights(model, 7.5, 0.5, 1.0);
+    /* -9452 * 7.5 + log(0.5) = -77821 */
+    TEST_EQUAL_LOG(ngram_score(model, "daines", "huggins", "david", NULL),
+           -77821);
+    /* Recover original score. */
+    TEST_EQUAL_LOG(ngram_prob(model, "daines", "huggins", "david", NULL),
+           -9452);
+    TEST_EQUAL_LOG(ngram_prob(model, "huggins", "david", NULL), -831);
+
+    /* Un-apply weights. */
+    ngram_model_apply_weights(model, 1.0, 1.0, 1.0);
+    TEST_EQUAL_LOG(ngram_score(model, "daines", "huggins", "david", NULL),
+               -9452);
+    TEST_EQUAL_LOG(ngram_score(model, "huggins", "david", NULL), -831);
+    /* Recover original score. */
+    TEST_EQUAL_LOG(ngram_prob(model, "daines", "huggins", "david", NULL),
+               -9452);
+
+    /* Pre-weighting, this should give the "raw" score. */
+    TEST_EQUAL_LOG(ngram_score(model, "daines", "huggins", "david", NULL),
+               -9452);
+    TEST_EQUAL_LOG(ngram_score(model, "huggins", "david", NULL), -831);
+    /* Verify that backoff mode calculations work. */
+    ngram_bg_score(model,
+               ngram_wid(model, "huggins"),
+               ngram_wid(model, "david"), &n_used);
+    TEST_EQUAL(n_used, 2);
+    ngram_bg_score(model,
+               ngram_wid(model, "blorglehurfle"),
+               ngram_wid(model, "david"), &n_used);
+    TEST_EQUAL(n_used, 1);
+    ngram_bg_score(model,
+               ngram_wid(model, "david"),
+               ngram_wid(model, "david"), &n_used);
+    TEST_EQUAL(n_used, 1);
+    ngram_tg_score(model,
+               ngram_wid(model, "daines"),
+               ngram_wid(model, "huggins"),
+               ngram_wid(model, "david"), &n_used);
+    TEST_EQUAL(n_used, 3);
+}
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+
+    lmath = logmath_init(1.0001, 0, 0);
+
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    run_tests(model);
+    ngram_model_free(model);
+
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.gz", NGRAM_ARPA, lmath);
+    run_tests(model);
+    ngram_model_free(model);
+
+    logmath_free(lmath);
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/test_lm_read.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+static int
+test_lm_vals(ngram_model_t *model)
+{
+    int32 n_used;
+    TEST_ASSERT(model);
+    TEST_EQUAL(ngram_wid(model, "<UNK>"), 0);
+    TEST_EQUAL(strcmp(ngram_word(model, 0), "<UNK>"), 0);
+    TEST_EQUAL(ngram_wid(model, "absolute"), 13);
+    TEST_EQUAL(strcmp(ngram_word(model, 13), "absolute"), 0);
+    /* Test unigrams. */
+    TEST_EQUAL(ngram_score(model, "<UNK>", NULL), -75346);
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "<UNK>"),
+                  NGRAM_INVALID_WID, &n_used), -75346);
+    TEST_EQUAL(n_used, 1);
+    TEST_EQUAL(ngram_score(model, "sphinxtrain", NULL), -64208);
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "sphinxtrain"),
+                  NGRAM_INVALID_WID, &n_used), -64208);
+    TEST_EQUAL(n_used, 1);
+    /* Test bigrams. */
+    TEST_EQUAL(ngram_score(model, "huggins", "david", NULL), -831);
+    /* Test trigrams. */
+    TEST_EQUAL_LOG(ngram_score(model, "daines", "huggins", "david", NULL), -9450);
+    return 0;
+}
+
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+
+    /* Initialize a logmath object to pass to ngram_read */
+    lmath = logmath_init(1.0001, 0, 0);
+    /* Read a language model */
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.bz2", NGRAM_ARPA, lmath);
+    test_lm_vals(model);
+    TEST_EQUAL(0, ngram_model_free(model));
+
+    /* Read a language model */
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    test_lm_vals(model);
+
+    /* Test refcounting. */
+    model = ngram_model_retain(model);
+    TEST_EQUAL(1, ngram_model_free(model));
+    TEST_EQUAL(ngram_score(model, "daines", "huggins", "david", NULL), -9452);
+    TEST_EQUAL(0, ngram_model_free(model));
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/turtle.lm

@@ +1 @@
+Language model created by QuickLM on Wed Aug  4 14:21:56 EDT 1999
+Carnegie Mellon University (c) 1996
+
+This model based on a corpus of  sentences and  words
+The (fixed) discount mass is 0.5
+
+\data\
+ngram 1=91
+ngram 2=212
+ngram 3=177
+
+\1-grams:
+-0.9129 </s> -0.3010
+-0.9129 <s> -0.2144
+-2.6031 A -0.2999
+-2.6031 AND -0.2989
+-2.3021 ARE -0.2978
+-2.6031 AROUND -0.2444
+-2.3021 BACKWARD -0.2338
+-2.9042 BACKWARDS -0.2444
+-2.6031 BYE -0.2432
+-2.9042 CENTIMETER -0.2444
+-2.9042 CENTIMETERS -0.2444
+-2.9042 CHASE -0.2989
+-2.9042 COLOR -0.2999
+-1.9499 DEGREES -0.2444
+-2.6031 DISPLAY -0.2999
+-2.9042 DO -0.2983
+-2.9042 DOING -0.2444
+-2.9042 EIGHT -0.2444
+-2.9042 EIGHTEEN -0.2444
+-2.4271 EIGHTY -0.2388
+-2.9042 ELEVEN -0.2444
+-2.9042 EXIT -0.2444
+-2.9042 EXPLORE -0.2444
+-2.6031 FIFTEEN -0.2388
+-2.9042 FIFTY -0.2444
+-2.9042 FIND -0.2989
+-2.9042 FINISH -0.2444
+-2.1260 FIVE -0.2338
+-2.3021 FORTY -0.2407
+-2.0011 FORWARD -0.2281
+-2.9042 FOUR -0.2444
+-2.9042 FOURTEEN -0.2444
+-1.7001 GO -0.2923
+-2.9042 GREY -0.2999
+-2.9042 GUARD -0.2989
+-2.4271 HALF -0.2420
+-2.9042 HALL -0.2444
+-2.9042 HALLWAY -0.2444
+-2.9042 HALT -0.2444
+-2.9042 HELLO -0.2444
+-2.9042 HOME -0.2444
+-2.6031 HUNDRED -0.2432
+-2.9042 KEVIN -0.2444
+-2.6031 LAB -0.2444
+-2.2052 LEFT -0.2338
+-2.9042 LISTENING -0.2444
+-2.9042 LOST -0.2444
+-2.3021 METER -0.2444
+-2.0011 METERS -0.2444
+-2.6031 MINUS -0.2983
+-2.9042 NINE -0.2444
+-2.9042 NINETEEN -0.2444
+-2.4271 NINETY -0.2388
+-2.9042 OFFICE -0.2444
+-2.0011 ONE -0.2351
+-2.9042 PERSON -0.2444
+-2.4271 QUARTER -0.2444
+-2.9042 QUARTERS -0.2444
+-2.9042 QUIT -0.2444
+-2.9042 READY -0.2444
+-2.9042 REID -0.2444
+-2.1260 RIGHT -0.2325
+-2.9042 ROBOMAN -0.2444
+-2.9042 ROOM -0.2444
+-2.0591 ROTATE -0.2950
+-2.6031 SAY -0.2994
+-2.9042 SEBASTIAN -0.2444
+-2.6031 SEVEN -0.2395
+-2.9042 SEVENTEEN -0.2444
+-2.9042 SEVENTY -0.2444
+-2.9042 SIX -0.2444
+-2.9042 SIXTEEN -0.2444
+-2.9042 SIXTY -0.2444
+-2.9042 STOP -0.2444
+-2.4271 TEN -0.2338
+-2.3021 THE -0.2432
+-2.9042 THEN -0.2444
+-2.9042 THIRTEEN -0.2444
+-2.6031 THIRTY -0.2388
+-2.3021 THREE -0.2370
+-2.6031 TO -0.2420
+-2.9042 TOM -0.2444
+-2.2052 TURN -0.2939
+-2.9042 TWELVE -0.2444
+-2.9042 TWENTY -0.2444
+-2.4271 TWO -0.2395
+-2.9042 UNDERSTAND -0.2444
+-2.9042 WANDER -0.2999
+-2.9042 WHAT -0.2989
+-2.6031 WINDOW -0.2444
+-2.2052 YOU -0.2967
+
+\2-grams:
+-2.2923 <s> AND -0.1761
+-1.9912 <s> ARE -0.0969
+-2.2923 <s> CENTIMETER 0.0000
+-2.2923 <s> CENTIMETERS 0.0000
+-2.2923 <s> CHASE 0.0000
+-1.9912 <s> DISPLAY 0.0000
+-2.2923 <s> DO 0.0000
+-2.2923 <s> EIGHT 0.0000
+-2.2923 <s> EIGHTEEN 0.0000
+-2.2923 <s> EIGHTY -0.2218
+-2.2923 <s> ELEVEN 0.0000
+-2.2923 <s> EXIT 0.0000
+-2.2923 <s> EXPLORE 0.0000
+-2.2923 <s> FIFTEEN -0.1761
+-2.2923 <s> FIFTY 0.0000
+-2.2923 <s> FIND 0.0000
+-2.2923 <s> FINISH 0.0000
+-2.2923 <s> FIVE -0.2218
+-1.9912 <s> FORTY 0.0000
+-2.2923 <s> FOUR 0.0000
+-2.2923 <s> FOURTEEN 0.0000
+-1.0881 <s> GO 0.0000
+-2.2923 <s> GUARD 0.0000
+-2.2923 <s> HALF -0.1249
+-2.2923 <s> HALL 0.0000
+-2.2923 <s> HALLWAY 0.0000
+-2.2923 <s> HALT 0.0000
+-2.2923 <s> HUNDRED -0.1761
+-2.2923 <s> KEVIN 0.0000
+-2.2923 <s> LAB 0.0000
+-2.2923 <s> METER 0.0000
+-2.2923 <s> METERS 0.0000
+-2.2923 <s> NINE 0.0000
+-2.2923 <s> NINETEEN 0.0000
+-2.2923 <s> NINETY -0.2218
+-2.2923 <s> OFFICE 0.0000
+-1.8151 <s> ONE -0.1761
+-2.2923 <s> PERSON 0.0000
+-2.2923 <s> QUARTER 0.0000
+-2.2923 <s> QUIT 0.0000
+-2.2923 <s> REID 0.0000
+-2.2923 <s> ROBOMAN 0.0000
+-2.2923 <s> ROOM 0.0000
+-1.4472 <s> ROTATE 0.0000
+-1.9912 <s> SAY 0.0000
+-2.2923 <s> SEBASTIAN 0.0000
+-2.2923 <s> SEVEN -0.1761
+-2.2923 <s> SEVENTEEN 0.0000
+-2.2923 <s> SEVENTY 0.0000
+-2.2923 <s> SIX 0.0000
+-2.2923 <s> SIXTEEN 0.0000
+-2.2923 <s> SIXTY 0.0000
+-2.2923 <s> STOP 0.0000
+-2.2923 <s> TEN -0.2218
+-2.2923 <s> THIRTEEN 0.0000
+-2.2923 <s> THIRTY -0.1761
+-1.8151 <s> THREE -0.0969
+-2.2923 <s> TOM 0.0000
+-1.5933 <s> TURN 0.0000
+-2.2923 <s> TWELVE 0.0000
+-2.2923 <s> TWENTY 0.0000
+-2.2923 <s> TWO -0.2218
+-2.2923 <s> WANDER 0.0000
+-2.2923 <s> WHAT 0.0000
+-2.2923 <s> YOU -0.2553
+-0.6021 A COLOR 0.0000
+-0.6021 A GREY 0.0000
+-0.6021 AND EIGHTY -0.1249
+-0.6021 AND THEN 0.0000
+-0.9031 ARE LOST 0.0000
+-0.4260 ARE YOU -0.1461
+-0.3010 AROUND </s> -0.3010
+-0.9031 BACKWARD </s> -0.3010
+-0.9031 BACKWARD FIVE -0.2218
+-0.9031 BACKWARD ONE -0.2430
+-0.9031 BACKWARD TWO -0.1249
+-0.3010 BACKWARDS </s> -0.3010
+-0.6021 BYE </s> -0.3010
+-0.6021 BYE BYE -0.1761
+-0.3010 CENTIMETER </s> -0.3010
+-0.3010 CENTIMETERS </s> -0.3010
+-0.3010 CHASE THE -0.0969
+-0.3010 COLOR WINDOW 0.0000
+-0.3010 DEGREES </s> -0.3010
+-0.3010 DISPLAY A 0.0000
+-0.3010 DO YOU -0.2553
+-0.3010 DOING </s> -0.3010
+-0.3010 EIGHT </s> -0.3010
+-0.3010 EIGHTEEN </s> -0.3010
+-0.7782 EIGHTY </s> -0.3010
+-0.4771 EIGHTY DEGREES 0.0000
+-0.3010 ELEVEN </s> -0.3010
+-0.3010 EXIT </s> -0.3010
+-0.3010 EXPLORE </s> -0.3010
+-0.6021 FIFTEEN </s> -0.3010
+-0.6021 FIFTEEN DEGREES 0.0000
+-0.3010 FIFTY </s> -0.3010
+-0.3010 FIND THE -0.0969
+-0.3010 FINISH </s> -0.3010
+-0.7782 FIVE </s> -0.3010
+-0.7782 FIVE DEGREES 0.0000
+-0.7782 FIVE METERS 0.0000
+-0.9031 FORTY </s> -0.3010
+-0.4260 FORTY FIVE -0.1249
+-1.2041 FORWARD </s> -0.3010
+-1.2041 FORWARD FIVE -0.2218
+-0.9031 FORWARD ONE -0.1761
+-1.2041 FORWARD SEVEN -0.1761
+-1.2041 FORWARD TEN -0.2218
+-1.2041 FORWARD THREE -0.2430
+-1.2041 FORWARD TWO -0.1249
+-0.3010 FOUR </s> -0.3010
+-0.3010 FOURTEEN </s> -0.3010
+-0.9031 GO BACKWARD 0.0000
+-1.5051 GO BACKWARDS 0.0000
+-0.6021 GO FORWARD 0.0000
+-1.5051 GO HOME 0.0000
+-1.2041 GO TO 0.0000
+-0.3010 GREY WINDOW 0.0000
+-0.3010 GUARD THE -0.0969
+-0.4771 HALF </s> -0.3010
+-0.7782 HALF METER 0.0000
+-0.3010 HALL </s> -0.3010
+-0.3010 HALLWAY </s> -0.3010
+-0.3010 HALT </s> -0.3010
+-0.3010 HELLO </s> -0.3010
+-0.3010 HOME </s> -0.3010
+-0.6021 HUNDRED </s> -0.3010
+-0.6021 HUNDRED AND -0.1761
+-0.3010 KEVIN </s> -0.3010
+-0.3010 LAB </s> -0.3010
+-1.0000 LEFT </s> -0.3010
+-1.0000 LEFT FORTY -0.0969
+-1.0000 LEFT MINUS -0.1761
+-1.0000 LEFT NINETY -0.1249
+-1.0000 LEFT ONE -0.2730
+-0.3010 LISTENING </s> -0.3010
+-0.3010 LOST </s> -0.3010
+-0.3010 METER </s> -0.3010
+-0.3010 METERS </s> -0.3010
+-0.6021 MINUS NINETY -0.1249
+-0.6021 MINUS THIRTY -0.1761
+-0.3010 NINE </s> -0.3010
+-0.3010 NINETEEN </s> -0.3010
+-0.7782 NINETY </s> -0.3010
+-0.4771 NINETY DEGREES 0.0000
+-0.3010 OFFICE </s> -0.3010
+-1.2041 ONE </s> -0.3010
+-1.2041 ONE EIGHTY -0.1249
+-0.9031 ONE HALF 0.0000
+-1.2041 ONE HUNDRED -0.1761
+-0.9031 ONE METER 0.0000
+-1.2041 ONE QUARTER 0.0000
+-0.3010 PERSON </s> -0.3010
+-0.3010 QUARTER </s> -0.3010
+-0.3010 QUARTERS </s> -0.3010
+-0.3010 QUIT </s> -0.3010
+-0.3010 READY </s> -0.3010
+-0.3010 REID </s> -0.3010
+-1.0792 RIGHT </s> -0.3010
+-1.0792 RIGHT FIFTEEN -0.1761
+-1.0792 RIGHT FORTY -0.0969
+-1.0792 RIGHT MINUS -0.1761
+-1.0792 RIGHT ONE -0.2730
+-1.0792 RIGHT TEN -0.2218
+-0.3010 ROBOMAN </s> -0.3010
+-0.3010 ROOM </s> -0.3010
+-0.6690 ROTATE LEFT -0.1461
+-0.5441 ROTATE RIGHT -0.1249
+-0.6021 SAY BYE -0.1761
+-0.6021 SAY HELLO 0.0000
+-0.3010 SEBASTIAN </s> -0.3010
+-0.6021 SEVEN </s> -0.3010
+-0.6021 SEVEN METERS 0.0000
+-0.3010 SEVENTEEN </s> -0.3010
+-0.3010 SEVENTY </s> -0.3010
+-0.3010 SIX </s> -0.3010
+-0.3010 SIXTEEN </s> -0.3010
+-0.3010 SIXTY </s> -0.3010
+-0.3010 STOP </s> -0.3010
+-0.7782 TEN </s> -0.3010
+-0.7782 TEN DEGREES 0.0000
+-0.7782 TEN METERS 0.0000
+-0.4260 THE </s> -0.3010
+-0.9031 THE LAB 0.0000
+-0.3010 THEN </s> -0.3010
+-0.3010 THIRTEEN </s> -0.3010
+-0.6021 THIRTY </s> -0.3010
+-0.6021 THIRTY DEGREES 0.0000
+-0.9031 THREE </s> -0.3010
+-0.9031 THREE METERS 0.0000
+-0.9031 THREE QUARTER 0.0000
+-0.9031 THREE QUARTERS 0.0000
+-0.6021 TO </s> -0.3010
+-0.6021 TO THE -0.2430
+-0.3010 TOM </s> -0.3010
+-1.0000 TURN AROUND 0.0000
+-0.6990 TURN LEFT -0.2041
+-0.6990 TURN RIGHT -0.2218
+-0.3010 TWELVE </s> -0.3010
+-0.3010 TWENTY </s> -0.3010
+-0.7782 TWO </s> -0.3010
+-0.4771 TWO METERS 0.0000
+-0.3010 UNDERSTAND </s> -0.3010
+-0.3010 WANDER AROUND 0.0000
+-0.3010 WHAT ARE -0.0969
+-0.3010 WINDOW </s> -0.3010
+-1.0000 YOU ARE -0.2430
+-1.0000 YOU DOING 0.0000
+-1.0000 YOU LISTENING 0.0000
+-1.0000 YOU READY 0.0000
+-1.0000 YOU UNDERSTAND 0.0000
+
+\3-grams:
+-0.3010 <s> AND THEN
+-0.3010 <s> ARE YOU
+-0.3010 <s> CENTIMETER </s>
+-0.3010 <s> CENTIMETERS </s>
+-0.3010 <s> CHASE THE
+-0.3010 <s> DISPLAY A
+-0.3010 <s> DO YOU
+-0.3010 <s> EIGHT </s>
+-0.3010 <s> EIGHTEEN </s>
+-0.3010 <s> EIGHTY </s>
+-0.3010 <s> ELEVEN </s>
+-0.3010 <s> EXIT </s>
+-0.3010 <s> EXPLORE </s>
+-0.3010 <s> FIFTEEN </s>
+-0.3010 <s> FIFTY </s>
+-0.3010 <s> FIND THE
+-0.3010 <s> FINISH </s>
+-0.3010 <s> FIVE </s>
+-0.6021 <s> FORTY </s>
+-0.6021 <s> FORTY FIVE
+-0.3010 <s> FOUR </s>
+-0.3010 <s> FOURTEEN </s>
+-0.9031 <s> GO BACKWARD
+-1.5051 <s> GO BACKWARDS
+-0.6021 <s> GO FORWARD
+-1.5051 <s> GO HOME
+-1.2041 <s> GO TO
+-0.3010 <s> GUARD THE
+-0.3010 <s> HALF </s>
+-0.3010 <s> HALL </s>
+-0.3010 <s> HALLWAY </s>
+-0.3010 <s> HALT </s>
+-0.3010 <s> HUNDRED </s>
+-0.3010 <s> KEVIN </s>
+-0.3010 <s> LAB </s>
+-0.3010 <s> METER </s>
+-0.3010 <s> METERS </s>
+-0.3010 <s> NINE </s>
+-0.3010 <s> NINETEEN </s>
+-0.3010 <s> NINETY </s>
+-0.3010 <s> OFFICE </s>
+-0.7782 <s> ONE </s>
+-0.7782 <s> ONE HALF
+-0.7782 <s> ONE QUARTER
+-0.3010 <s> PERSON </s>
+-0.3010 <s> QUARTER </s>
+-0.3010 <s> QUIT </s>
+-0.3010 <s> REID </s>
+-0.3010 <s> ROBOMAN </s>
+-0.3010 <s> ROOM </s>
+-0.6690 <s> ROTATE LEFT
+-0.5441 <s> ROTATE RIGHT
+-0.6021 <s> SAY BYE
+-0.6021 <s> SAY HELLO
+-0.3010 <s> SEBASTIAN </s>
+-0.3010 <s> SEVEN </s>
+-0.3010 <s> SEVENTEEN </s>
+-0.3010 <s> SEVENTY </s>
+-0.3010 <s> SIX </s>
+-0.3010 <s> SIXTEEN </s>
+-0.3010 <s> SIXTY </s>
+-0.3010 <s> STOP </s>
+-0.3010 <s> TEN </s>
+-0.3010 <s> THIRTEEN </s>
+-0.3010 <s> THIRTY </s>
+-0.7782 <s> THREE </s>
+-0.7782 <s> THREE QUARTER
+-0.7782 <s> THREE QUARTERS
+-0.3010 <s> TOM </s>
+-1.0000 <s> TURN AROUND
+-0.6990 <s> TURN LEFT
+-0.6990 <s> TURN RIGHT
+-0.3010 <s> TWELVE </s>
+-0.3010 <s> TWENTY </s>
+-0.3010 <s> TWO </s>
+-0.3010 <s> WANDER AROUND
+-0.3010 <s> WHAT ARE
+-0.3010 <s> YOU ARE
+-0.3010 A COLOR WINDOW
+-0.3010 A GREY WINDOW
+-0.3010 AND EIGHTY DEGREES
+-0.3010 AND THEN </s>
+-0.3010 ARE LOST </s>
+-0.7782 ARE YOU DOING
+-0.7782 ARE YOU LISTENING
+-0.7782 ARE YOU READY
+-0.3010 BACKWARD FIVE METERS
+-0.3010 BACKWARD ONE METER
+-0.3010 BACKWARD TWO METERS
+-0.3010 BYE BYE </s>
+-0.3010 CHASE THE </s>
+-0.3010 COLOR WINDOW </s>
+-0.6021 DISPLAY A COLOR
+-0.6021 DISPLAY A GREY
+-0.3010 DO YOU UNDERSTAND
+-0.3010 EIGHTY DEGREES </s>
+-0.3010 FIFTEEN DEGREES </s>
+-0.3010 FIND THE </s>
+-0.3010 FIVE DEGREES </s>
+-0.3010 FIVE METERS </s>
+-0.7782 FORTY FIVE </s>
+-0.4771 FORTY FIVE DEGREES
+-0.3010 FORWARD FIVE METERS
+-0.6021 FORWARD ONE HALF
+-0.6021 FORWARD ONE METER
+-0.3010 FORWARD SEVEN METERS
+-0.3010 FORWARD TEN METERS
+-0.3010 FORWARD THREE METERS
+-0.3010 FORWARD TWO METERS
+-0.9031 GO BACKWARD </s>
+-0.9031 GO BACKWARD FIVE
+-0.9031 GO BACKWARD ONE
+-0.9031 GO BACKWARD TWO
+-0.3010 GO BACKWARDS </s>
+-1.2041 GO FORWARD </s>
+-1.2041 GO FORWARD FIVE
+-0.9031 GO FORWARD ONE
+-1.2041 GO FORWARD SEVEN
+-1.2041 GO FORWARD TEN
+-1.2041 GO FORWARD THREE
+-1.2041 GO FORWARD TWO
+-0.3010 GO HOME </s>
+-0.6021 GO TO </s>
+-0.6021 GO TO THE
+-0.3010 GREY WINDOW </s>
+-0.3010 GUARD THE </s>
+-0.3010 HALF METER </s>
+-0.3010 HUNDRED AND EIGHTY
+-0.3010 LEFT FORTY FIVE
+-0.3010 LEFT MINUS NINETY
+-0.3010 LEFT NINETY DEGREES
+-0.3010 LEFT ONE EIGHTY
+-0.3010 MINUS NINETY DEGREES
+-0.3010 MINUS THIRTY DEGREES
+-0.3010 NINETY DEGREES </s>
+-0.3010 ONE EIGHTY DEGREES
+-0.6021 ONE HALF </s>
+-0.6021 ONE HALF METER
+-0.3010 ONE HUNDRED AND
+-0.3010 ONE METER </s>
+-0.3010 ONE QUARTER </s>
+-0.3010 RIGHT FIFTEEN DEGREES
+-0.3010 RIGHT FORTY FIVE
+-0.3010 RIGHT MINUS THIRTY
+-0.3010 RIGHT ONE HUNDRED
+-0.3010 RIGHT TEN DEGREES
+-0.7782 ROTATE LEFT FORTY
+-0.7782 ROTATE LEFT MINUS
+-0.7782 ROTATE LEFT ONE
+-0.9031 ROTATE RIGHT FIFTEEN
+-0.9031 ROTATE RIGHT MINUS
+-0.9031 ROTATE RIGHT ONE
+-0.9031 ROTATE RIGHT TEN
+-0.3010 SAY BYE BYE
+-0.3010 SAY HELLO </s>
+-0.3010 SEVEN METERS </s>
+-0.3010 TEN DEGREES </s>
+-0.3010 TEN METERS </s>
+-0.3010 THE LAB </s>
+-0.3010 THIRTY DEGREES </s>
+-0.3010 THREE METERS </s>
+-0.3010 THREE QUARTER </s>
+-0.3010 THREE QUARTERS </s>
+-0.3010 TO THE LAB
+-0.3010 TURN AROUND </s>
+-0.6021 TURN LEFT </s>
+-0.6021 TURN LEFT NINETY
+-0.6021 TURN RIGHT </s>
+-0.6021 TURN RIGHT FORTY
+-0.3010 TWO METERS </s>
+-0.3010 WANDER AROUND </s>
+-0.3010 WHAT ARE YOU
+-0.3010 YOU ARE LOST
+-0.3010 YOU DOING </s>
+-0.3010 YOU LISTENING </s>
+-0.3010 YOU READY </s>
+-0.3010 YOU UNDERSTAND </s>
+
+\end\

src/tests/libs/sphinx/test_ngram/test_lm_casefold.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+
+    /* Initialize a logmath object to pass to ngram_read */
+    lmath = logmath_init(1.0001, 0, 0);
+
+    /* Read a language model */
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    TEST_ASSERT(model);
+
+    ngram_model_casefold(model, NGRAM_UPPER);
+
+    TEST_EQUAL(0, strcmp("</s>", ngram_word(model, 5)));
+    TEST_EQUAL(0, strcmp("BE", ngram_word(model, 42)));
+    TEST_EQUAL(0, strcmp("FLOORED", ngram_word(model, 130)));
+    TEST_EQUAL(0, strcmp("ZERO", ngram_word(model, 398)));
+    TEST_EQUAL(0, strcmp("~", ngram_word(model, 399)));
+
+    ngram_model_casefold(model, NGRAM_LOWER);
+
+    TEST_EQUAL(0, strcmp("</s>", ngram_word(model, 5)));
+    TEST_EQUAL(0, strcmp("be", ngram_word(model, 42)));
+    TEST_EQUAL(0, strcmp("floored", ngram_word(model, 130)));
+    TEST_EQUAL(0, strcmp("zero", ngram_word(model, 398)));
+    TEST_EQUAL(0, strcmp("~", ngram_word(model, 399)));
+
+    ngram_model_free(model);
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/test_lm_add.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+void
+run_tests(logmath_t *lmath, ngram_model_t *model)
+{
+    int32 wid, score;
+
+    wid = ngram_model_add_word(model, "foobie", 1.0);
+    score = ngram_score(model, "foobie", NULL);
+    TEST_EQUAL_LOG(score, logmath_log(lmath, 1.0/400.0)); /* #unigrams */
+
+    wid = ngram_model_add_word(model, "quux", 0.5);
+    score = ngram_score(model, "quux", NULL);
+    TEST_EQUAL_LOG(score, logmath_log(lmath, 0.5/400.0)); /* #unigrams */
+
+    ngram_model_apply_weights(model, 1.0, 1.0, 0.9);
+    score = ngram_score(model, "quux", NULL);
+    TEST_EQUAL_LOG(score, logmath_log(lmath, 0.5/400.0*0.9 + 1.0/400.0*0.1));
+
+    wid = ngram_model_add_word(model, "bazbar", 0.5);
+    score = ngram_score(model, "bazbar", NULL);
+    TEST_EQUAL_LOG(score, logmath_log(lmath, 0.5/400.0*0.9 + 1.0/400.0*0.1));
+}
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+
+    lmath = logmath_init(1.0001, 0, 0);
+
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    run_tests(lmath, model);
+    ngram_model_free(model);
+
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.gz", NGRAM_ARPA, lmath);
+    run_tests(lmath, model);
+    ngram_model_free(model);
+
+    logmath_free(lmath);
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/test_lm_write.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+#include <err.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+static int
+test_lm_vals(ngram_model_t *model)
+{
+    int32 n_used;
+
+    TEST_ASSERT(model);
+    TEST_EQUAL(ngram_wid(model, "<UNK>"), 0);
+    TEST_EQUAL(strcmp(ngram_word(model, 0), "<UNK>"), 0);
+    TEST_EQUAL(ngram_wid(model, "absolute"), 13);
+    TEST_EQUAL(strcmp(ngram_word(model, 13), "absolute"), 0);
+    /* Test unigrams. */
+    TEST_EQUAL_LOG(ngram_score(model, "<UNK>", NULL), -75346);
+    TEST_EQUAL_LOG(ngram_bg_score(model, ngram_wid(model, "<UNK>"),
+                  NGRAM_INVALID_WID, &n_used), -75346);
+    TEST_EQUAL(n_used, 1);
+    TEST_EQUAL_LOG(ngram_score(model, "sphinxtrain", NULL), -64208);
+    TEST_EQUAL_LOG(ngram_bg_score(model, ngram_wid(model, "sphinxtrain"),
+                  NGRAM_INVALID_WID, &n_used), -64208);
+    TEST_EQUAL(n_used, 1);
+    printf("FOO %d\n", ngram_score(model, "huggins", "david", NULL));
+    printf("FOO %d\n", ngram_score(model, "daines", "huggins", "david", NULL));
+    /* Test bigrams. */
+    TEST_EQUAL_LOG(ngram_score(model, "huggins", "david", NULL), -831);
+    /* Test trigrams. */
+    TEST_EQUAL_LOG(ngram_score(model, "daines", "huggins", "david", NULL), -9450);
+    return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+
+    /* Initialize a logmath object to pass to ngram_read */
+    lmath = logmath_init(1.0001, 0, 0);
+
+    /* Convert ARPA to DMP */
+    E_INFO("Converting ARPA to DMP\n");
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.bz2", NGRAM_ARPA, lmath);
+    test_lm_vals(model);
+    TEST_EQUAL(0, ngram_model_write(model, "100.tmp.DMP", NGRAM_DMP));
+    ngram_model_free(model);
+
+    /* Convert DMP to ARPA */
+    E_INFO("Converting DMP to ARPA\n");
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    test_lm_vals(model);
+    TEST_EQUAL(0, ngram_model_write(model, "100.tmp.arpa", NGRAM_ARPA));
+    ngram_model_free(model);
+
+    /* Test converted DMP */
+    E_INFO("Testing converted DMP\n");
+    model = ngram_model_read(NULL, "100.tmp.DMP", NGRAM_DMP, lmath);
+    test_lm_vals(model);
+    ngram_model_free(model);
+
+    /* Test converted ARPA */
+    E_INFO("Testing converted ARPA\n");
+    model = ngram_model_read(NULL, "100.tmp.arpa", NGRAM_ARPA, lmath);
+    test_lm_vals(model);
+    ngram_model_free(model);
+
+    /* Convert DMP back to ARPA*/
+    E_INFO("Converting ARPA back to DMP\n");
+    model = ngram_model_read(NULL, "100.tmp.arpa", NGRAM_ARPA, lmath);
+    test_lm_vals(model);
+    TEST_EQUAL(0, ngram_model_write(model, "100.tmp.DMP", NGRAM_DMP));
+    ngram_model_free(model);
+
+    /* Convert ARPA back to DMP */
+    E_INFO("Converting DMP back to ARPA\n");
+    model = ngram_model_read(NULL, "100.tmp.DMP", NGRAM_DMP, lmath);
+    test_lm_vals(model);
+    TEST_EQUAL(0, ngram_model_write(model, "100.tmp.arpa", NGRAM_ARPA));
+    ngram_model_free(model);
+
+    logmath_free(lmath);
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/test_lm_mmap.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+static const arg_t defn[] = {
+    { "-mmap", ARG_BOOLEAN, "yes", "use mmap" },
+    { "-lw", ARG_FLOAT32, "1.0", "language weight" },
+    { "-wip", ARG_FLOAT32, "1.0", "word insertion penalty" },
+    { "-uw", ARG_FLOAT32, "1.0", "unigram weight" },
+    { NULL, 0, NULL, NULL }
+};
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+    cmd_ln_t *config;
+    int32 n_used;
+
+    /* Initialize a logmath object to pass to ngram_read */
+    lmath = logmath_init(1.0001, 0, 0);
+    /* Initialize a cmd_ln_t with -mmap yes */
+    config = cmd_ln_parse_r(NULL, defn, 0, NULL, FALSE);
+
+    /* Read a language model (this won't mmap) */
+    model = ngram_model_read(config, LMDIR "/100.arpa.gz", NGRAM_ARPA, lmath);
+    TEST_ASSERT(model);
+    TEST_EQUAL(ngram_wid(model, "<UNK>"), 0);
+    TEST_EQUAL(ngram_wid(model, "absolute"), 13);
+    TEST_EQUAL(strcmp(ngram_word(model, 13), "absolute"), 0);
+    /* Test unigrams. */
+    TEST_EQUAL(ngram_score(model, "<UNK>", NULL), -75346);
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "<UNK>"),
+                  NGRAM_INVALID_WID, &n_used), -75346);
+    TEST_EQUAL(n_used, 1);
+    TEST_EQUAL(ngram_score(model, "sphinxtrain", NULL), -64208);
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "sphinxtrain"),
+                  NGRAM_INVALID_WID, &n_used), -64208);
+    TEST_EQUAL(n_used, 1);
+    /* Test bigrams. */
+    TEST_EQUAL(ngram_score(model, "huggins", "david", NULL), -831);
+    /* Test trigrams. */
+    TEST_EQUAL_LOG(ngram_score(model, "daines", "huggins", "david", NULL), -9450);
+
+    ngram_model_free(model);
+
+    /* Read a language model (this will mmap) */
+    model = ngram_model_read(config, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    TEST_ASSERT(model);
+    TEST_EQUAL(ngram_wid(model, "<UNK>"), 0);
+    TEST_EQUAL(strcmp(ngram_word(model, 0), "<UNK>"), 0);
+    TEST_EQUAL(ngram_wid(model, "absolute"), 13);
+    TEST_EQUAL(strcmp(ngram_word(model, 13), "absolute"), 0);
+    /* Test unigrams. */
+    TEST_EQUAL(ngram_score(model, "<UNK>", NULL), -75346);
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "<UNK>"),
+                  NGRAM_INVALID_WID, &n_used), -75346);
+    TEST_EQUAL(n_used, 1);
+    TEST_EQUAL(ngram_score(model, "sphinxtrain", NULL), -64208);
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "sphinxtrain"),
+                  NGRAM_INVALID_WID, &n_used), -64208);
+    TEST_EQUAL(n_used, 1);
+    /* Test bigrams. */
+    TEST_EQUAL(ngram_score(model, "huggins", "david", NULL), -831);
+    /* Test trigrams. */
+    TEST_EQUAL(ngram_score(model, "daines", "huggins", "david", NULL), -9452);
+
+    ngram_model_free(model);
+
+    /* Test language weights on the command line. */
+    cmd_ln_set_float32_r(config, "-lw", 2.0);
+    cmd_ln_set_float32_r(config, "-wip", 0.5);
+    model = ngram_model_read(config, LMDIR "/100.arpa.gz", NGRAM_ARPA, lmath);
+    TEST_ASSERT(model);
+    TEST_EQUAL(ngram_wid(model, "<UNK>"), 0);
+    TEST_EQUAL(ngram_wid(model, "absolute"), 13);
+    TEST_EQUAL(strcmp(ngram_word(model, 13), "absolute"), 0);
+    /* Test unigrams. */
+    TEST_EQUAL(ngram_score(model, "<UNK>", NULL), -75346
+           * 2 + logmath_log(lmath, 0.5));
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "<UNK>"),
+                  NGRAM_INVALID_WID, &n_used), -75346
+           * 2 + logmath_log(lmath, 0.5));
+    TEST_EQUAL(n_used, 1);
+    TEST_EQUAL(ngram_score(model, "sphinxtrain", NULL), -64208
+           * 2 + logmath_log(lmath, 0.5));
+    TEST_EQUAL(ngram_bg_score(model, ngram_wid(model, "sphinxtrain"),
+                  NGRAM_INVALID_WID, &n_used), -64208
+           * 2 + logmath_log(lmath, 0.5));
+    TEST_EQUAL(n_used, 1);
+    /* Test bigrams. */
+    TEST_EQUAL(ngram_score(model, "huggins", "david", NULL),
+           -831 * 2 + logmath_log(lmath, 0.5));
+    /* Test trigrams. */
+    TEST_EQUAL_LOG(ngram_score(model, "daines", "huggins", "david", NULL),
+               -9450 * 2 + logmath_log(lmath, 0.5));
+
+    ngram_model_free(model);
+
+    logmath_free(lmath);
+    cmd_ln_free_r(config);
+
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/test_lm_set.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *lms[3];
+    ngram_model_t *lmset;
+    const char *names[] = { "100", "100_2" };
+    const char *words[] = {
+        "<UNK>",
+        "ROBOMAN",
+        "libio",
+        "sphinxtrain",
+        "bigbird",
+        "quuxfuzz"
+    };
+    const int32 n_words = sizeof(words) / sizeof(words[0]);
+    float32 weights[] = { 0.6, 0.4 };
+
+    lmath = logmath_init(1.0001, 0, 0);
+
+    lms[0] = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    lms[1] = ngram_model_read(NULL, LMDIR "/100_2.arpa.DMP", NGRAM_DMP, lmath);
+
+    lmset = ngram_model_set_init(NULL, lms, (char **)names, NULL, 2);
+    TEST_ASSERT(lmset);
+    TEST_EQUAL(ngram_model_set_select(lmset, "100_2"), lms[1]);
+    TEST_EQUAL(ngram_model_set_select(lmset, "100"), lms[0]);
+    TEST_EQUAL(ngram_score(lmset, "sphinxtrain", NULL),
+           logmath_log10_to_log(lmath, -2.7884));
+    TEST_EQUAL(ngram_score(lmset, "huggins", "david", NULL),
+           logmath_log10_to_log(lmath, -0.0361));
+    TEST_EQUAL_LOG(ngram_score(lmset, "daines", "huggins", "david", NULL),
+               logmath_log10_to_log(lmath, -0.4105));
+
+    TEST_EQUAL(ngram_model_set_select(lmset, "100_2"), lms[1]);
+    TEST_EQUAL(ngram_score(lmset, "sphinxtrain", NULL),
+           logmath_log10_to_log(lmath, -2.8192));
+    TEST_EQUAL(ngram_score(lmset, "huggins", "david", NULL),
+           logmath_log10_to_log(lmath, -0.1597));
+    TEST_EQUAL_LOG(ngram_score(lmset, "daines", "huggins", "david", NULL),
+               logmath_log10_to_log(lmath, -0.0512));
+
+    /* Test interpolation with default weights. */
+    TEST_ASSERT(ngram_model_set_interp(lmset, NULL, NULL));
+    TEST_EQUAL_LOG(ngram_score(lmset, "sphinxtrain", NULL),
+               logmath_log(lmath,
+                   0.5 * pow(10, -2.7884)
+                   + 0.5 * pow(10, -2.8192)));
+
+    /* Test interpolation with set weights. */
+    TEST_ASSERT(ngram_model_set_interp(lmset, names, weights));
+    TEST_EQUAL_LOG(ngram_score(lmset, "sphinxtrain", NULL),
+               logmath_log(lmath,
+                   0.6 * pow(10, -2.7884)
+                   + 0.4 * pow(10, -2.8192)));
+
+    /* Test switching back to selected mode. */
+    TEST_EQUAL(ngram_model_set_select(lmset, "100_2"), lms[1]);
+    TEST_EQUAL(ngram_score(lmset, "sphinxtrain", NULL),
+           logmath_log10_to_log(lmath, -2.8192));
+    TEST_EQUAL(ngram_score(lmset, "huggins", "david", NULL),
+           logmath_log10_to_log(lmath, -0.1597));
+    TEST_EQUAL_LOG(ngram_score(lmset, "daines", "huggins", "david", NULL),
+               logmath_log10_to_log(lmath, -0.0512));
+
+    /* Test interpolation with previously set weights. */
+    TEST_ASSERT(ngram_model_set_interp(lmset, NULL, NULL));
+    TEST_EQUAL_LOG(ngram_score(lmset, "sphinxtrain", NULL),
+               logmath_log(lmath,
+                   0.6 * pow(10, -2.7884)
+                   + 0.4 * pow(10, -2.8192)));
+
+    /* Test interpolation with closed-vocabulary models and OOVs. */
+    lms[2] = ngram_model_read(NULL, LMDIR "/turtle.lm", NGRAM_ARPA, lmath);
+    TEST_ASSERT(ngram_model_set_add(lmset, lms[2], "turtle", 1.0, FALSE));
+    TEST_EQUAL_LOG(ngram_score(lmset, "sphinxtrain", NULL),
+               logmath_log(lmath,
+                   0.6 * (2.0 / 3.0) * pow(10, -2.7884)
+                   + 0.4 * (2.0 / 3.0) * pow(10, -2.8192)));
+    ngram_model_free(lmset);
+
+    /* Test adding and removing language models with preserved
+     * word ID mappings. */
+    lms[0] = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    lms[1] = ngram_model_read(NULL, LMDIR "/100_2.arpa.DMP", NGRAM_DMP, lmath);
+    lms[2] = ngram_model_read(NULL, LMDIR "/turtle.lm", NGRAM_ARPA, lmath);
+    lmset = ngram_model_set_init(NULL, lms, (char **)names, NULL, 1);
+    {
+        int32 wid;
+        wid = ngram_wid(lmset, "sphinxtrain");
+        TEST_ASSERT(ngram_model_set_add(lmset, lms[1], "100_2", 1.0, TRUE));
+        /* Verify that it is the same. */
+        TEST_EQUAL(wid, ngram_wid(lmset, "sphinxtrain"));
+        /* Now add another model and verify that its words
+         * don't actually get added. */
+        TEST_ASSERT(ngram_model_set_add(lmset, lms[2], "turtle", 1.0, TRUE));
+        TEST_EQUAL(wid, ngram_wid(lmset, "sphinxtrain"));
+        TEST_EQUAL(ngram_unknown_wid(lmset), ngram_wid(lmset, "FORWARD"));
+        /* Remove language model, make sure this doesn't break horribly. */
+        TEST_EQUAL(lms[1], ngram_model_set_remove(lmset, "100_2", TRUE));
+        ngram_model_free(lms[1]);
+        TEST_EQUAL(wid, ngram_wid(lmset, "sphinxtrain"));
+        /* Now enable remapping of word IDs and verify that it works. */
+        TEST_EQUAL(lms[2], ngram_model_set_remove(lmset, "turtle", TRUE));
+        TEST_ASSERT(ngram_model_set_add(lmset, lms[2], "turtle", 1.0, FALSE));
+        printf("FORWARD = %d\n", ngram_wid(lmset, "FORWARD"));
+    }
+
+    ngram_model_free(lmset);
+
+    /* Now test lmctl files. */
+    lmset = ngram_model_set_read(NULL, LMDIR "/100.lmctl", lmath);
+    TEST_ASSERT(lmset);
+    /* Test iterators. */
+    {
+        ngram_model_set_iter_t *itor;
+        ngram_model_t *lm;
+        char const *lmname;
+
+        itor = ngram_model_set_iter(lmset);
+        TEST_ASSERT(itor);
+        lm = ngram_model_set_iter_model(itor, &lmname);
+        printf("1: %s\n", lmname);
+        itor = ngram_model_set_iter_next(itor);
+        lm = ngram_model_set_iter_model(itor, &lmname);
+        printf("2: %s\n", lmname);
+        itor = ngram_model_set_iter_next(itor);
+        lm = ngram_model_set_iter_model(itor, &lmname);
+        printf("3: %s\n", lmname);
+        itor = ngram_model_set_iter_next(itor);
+        TEST_EQUAL(itor, NULL);
+    }
+
+    TEST_EQUAL(ngram_score(lmset, "sphinxtrain", NULL),
+           logmath_log10_to_log(lmath, -2.7884));
+
+    TEST_ASSERT(ngram_model_set_interp(lmset, NULL, NULL));
+    TEST_EQUAL_LOG(ngram_score(lmset, "sphinxtrain", NULL),
+               logmath_log(lmath,
+                   (1.0 / 3.0) * pow(10, -2.7884)
+                   + (1.0 / 3.0) * pow(10, -2.8192)));
+
+    ngram_model_set_select(lmset, "100_2");
+    TEST_EQUAL(ngram_score(lmset, "sphinxtrain", NULL),
+           logmath_log10_to_log(lmath, -2.8192));
+    TEST_EQUAL(ngram_score(lmset, "huggins", "david", NULL),
+           logmath_log10_to_log(lmath, -0.1597));
+    TEST_EQUAL_LOG(ngram_score(lmset, "daines", "huggins", "david", NULL),
+               logmath_log10_to_log(lmath, -0.0512));
+
+    ngram_model_set_select(lmset, "100");
+    TEST_EQUAL(ngram_score(lmset, "sphinxtrain", NULL),
+           logmath_log10_to_log(lmath, -2.7884));
+    TEST_EQUAL(ngram_score(lmset, "huggins", "david", NULL),
+           logmath_log10_to_log(lmath, -0.0361));
+    TEST_EQUAL_LOG(ngram_score(lmset, "daines", "huggins", "david", NULL),
+               logmath_log10_to_log(lmath, -0.4105));
+
+    /* Test class probabilities. */
+    ngram_model_set_select(lmset, "100");
+    TEST_EQUAL_LOG(ngram_score(lmset, "scylla:scylla", NULL),
+               logmath_log10_to_log(lmath, -2.7884) + logmath_log(lmath, 0.4));
+    TEST_EQUAL_LOG(ngram_score(lmset, "scooby:scylla", NULL),
+               logmath_log10_to_log(lmath, -2.7884) + logmath_log(lmath, 0.1));
+    TEST_EQUAL_LOG(ngram_score(lmset, "apparently", "karybdis:scylla", NULL),
+               logmath_log10_to_log(lmath, -0.5172));
+
+    /* Test word ID mapping. */
+    ngram_model_set_select(lmset, "turtle");
+    TEST_EQUAL(ngram_wid(lmset, "ROBOMAN"),
+           ngram_wid(lmset, ngram_word(lmset, ngram_wid(lmset, "ROBOMAN"))));
+    TEST_EQUAL(ngram_wid(lmset, "bigbird"),
+           ngram_wid(lmset, ngram_word(lmset, ngram_wid(lmset, "bigbird"))));
+    TEST_EQUAL(ngram_wid(lmset, "quuxfuzz"), ngram_unknown_wid(lmset));
+    TEST_EQUAL(ngram_score(lmset, "quuxfuzz", NULL), ngram_zero(lmset));
+    ngram_model_set_map_words(lmset, words, n_words);
+    TEST_EQUAL(ngram_wid(lmset, "ROBOMAN"),
+           ngram_wid(lmset, ngram_word(lmset, ngram_wid(lmset, "ROBOMAN"))));
+    TEST_EQUAL(ngram_wid(lmset, "bigbird"),
+           ngram_wid(lmset, ngram_word(lmset, ngram_wid(lmset, "bigbird"))));
+    TEST_EQUAL(ngram_wid(lmset, "quuxfuzz"), 5);
+    TEST_EQUAL(ngram_score(lmset, "quuxfuzz", NULL), ngram_zero(lmset));
+
+    ngram_model_free(lmset);
+    logmath_free(lmath);
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_ngram ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_lm_class : test_lm_class.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_lm_iter : test_lm_iter.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_lm_mmap : test_lm_mmap.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_lm_read : test_lm_read.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_lm_recode : test_lm_recode.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_lm_score : test_lm_score.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_lm_set : test_lm_set.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_lm_write : test_lm_write.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_ngram/test_lm_recode.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+
+    /* Initialize a logmath object to pass to ngram_read */
+    lmath = logmath_init(1.0001, 0, 0);
+
+    /* Read a language model */
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    TEST_ASSERT(model);
+
+    ngram_model_recode(model, "iso8859-1", "utf-8");
+    TEST_EQUAL(strcmp(ngram_word(model, 0), "<UNK>"), 0);
+    ngram_model_free(model);
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/test_macros.h

@@ +1 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_ngram/100.lmctl

@@ +1 @@
+{ 100.probdef }
+100.arpa.DMP 100 { scylla zero }
+100_2.arpa.gz 100_2
+turtle.lm turtle

src/tests/libs/sphinx/test_ngram/test_lm_iter.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+    ngram_iter_t *itor;
+    int i;
+
+    /* Initialize a logmath object to pass to ngram_read */
+    lmath = logmath_init(1.0001, 0, 0);
+    /* Read a language model */
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    TEST_ASSERT(model);
+
+    for (i = 0, itor = ngram_model_mgrams(model, 0);
+         itor; ++i, itor = ngram_iter_next(itor)) {
+        int32 score, bowt;
+        int32 const *wids = ngram_iter_get(itor, &score, &bowt);
+
+        /*
+        printf("%.4f %s %.4f\n",
+               logmath_log_to_log10(lmath, score),
+               ngram_word(model, wids[0]),
+               logmath_log_to_log10(lmath, bowt));
+        */
+
+        if (i == 0) TEST_EQUAL(wids[0], ngram_wid(model, "<UNK>"));
+        if (i == 1) TEST_EQUAL(wids[0], ngram_wid(model, "'s"));
+    }
+
+    for (i = 0, itor = ngram_model_mgrams(model, 1);
+         itor; ++i, itor = ngram_iter_next(itor)) {
+        int32 score, bowt;
+        int32 const *wids = ngram_iter_get(itor, &score, &bowt);
+
+        /*
+        printf("%.4f %s %s %.4f\n",
+               logmath_log_to_log10(lmath, score),
+               ngram_word(model, wids[0]),
+               ngram_word(model, wids[1]),
+               logmath_log_to_log10(lmath, bowt));
+        */
+
+        /* FIXME: These tests are not sufficient - actually we
+         * need to make sure all word IDs line up
+         * correctly. */
+        if (i == 0) TEST_EQUAL(wids[0], ngram_wid(model, "'s"));
+        if (i == 0) TEST_EQUAL(wids[1], ngram_wid(model, "an"));
+        if (i == 1) TEST_EQUAL(wids[0], ngram_wid(model, "'s"));
+        if (i == 1) TEST_EQUAL(wids[1], ngram_wid(model, "going"));
+    }
+
+    for (i = 0, itor = ngram_model_mgrams(model, 2);
+         itor; ++i, itor = ngram_iter_next(itor)) {
+        int32 score, bowt;
+        int32 const *wids = ngram_iter_get(itor, &score, &bowt);
+
+        /*
+        printf("%.4f %s %s %s\n",
+               logmath_log_to_log10(lmath, score),
+               ngram_word(model, wids[0]),
+               ngram_word(model, wids[1]),
+               ngram_word(model, wids[2]));
+        */
+
+        /* FIXME: These tests are not sufficient - actually we
+         * need to make sure all word IDs line up
+         * correctly. */
+        if (i == 0) TEST_EQUAL(wids[0], ngram_wid(model, "'s"));
+        if (i == 0) TEST_EQUAL(wids[1], ngram_wid(model, "an"));
+        if (i == 0) TEST_EQUAL(wids[2], ngram_wid(model, "r"));
+        if (i == 1) TEST_EQUAL(wids[0], ngram_wid(model, "'s"));
+        if (i == 1) TEST_EQUAL(wids[1], ngram_wid(model, "going"));
+        if (i == 1) TEST_EQUAL(wids[2], ngram_wid(model, "so"));
+    }
+
+    {
+        ngram_iter_t *itor2, *itor3;
+        int32 score, bowt;
+        int32 const *wids;
+
+        /* Test the boundary condition - successors of last 1-gram. */
+        itor = ngram_ng_iter(model, ngram_model_get_counts(model)[0] - 1,
+                     NULL, 0);
+        wids = ngram_iter_get(itor, &score, &bowt);
+        printf("%.4f %s %.4f\n",
+               logmath_log_to_log10(lmath, score),
+               ngram_word(model, wids[0]),
+               logmath_log_to_log10(lmath, bowt));
+        TEST_EQUAL(wids[0], ngram_wid(model, "~"));
+
+        for (itor2 = ngram_iter_successors(itor);
+             itor2; itor2 = ngram_iter_next(itor2)) {
+            wids = ngram_iter_get(itor2, &score, &bowt);
+            printf("%.4f %s %s %.4f\n",
+                   logmath_log_to_log10(lmath, score),
+                   ngram_word(model, wids[0]),
+                   ngram_word(model, wids[1]),
+                   logmath_log_to_log10(lmath, bowt));
+            TEST_EQUAL(wids[0], ngram_wid(model, "~"));
+            TEST_EQUAL(wids[1], ngram_wid(model, "eleven"));
+        }
+        itor2 = ngram_iter_successors(itor);
+        for (itor3 = ngram_iter_successors(itor2);
+             itor3; itor3 = ngram_iter_next(itor3)) {
+            wids = ngram_iter_get(itor3, &score, &bowt);
+            printf("%.4f %s %s %s\n",
+                   logmath_log_to_log10(lmath, score),
+                   ngram_word(model, wids[0]),
+                   ngram_word(model, wids[1]),
+                   ngram_word(model, wids[2]));
+            TEST_EQUAL(wids[0], ngram_wid(model, "~"));
+            TEST_EQUAL(wids[1], ngram_wid(model, "eleven"));
+            TEST_EQUAL(wids[2], ngram_wid(model, "per"));
+        }
+        ngram_iter_free(itor2);
+        ngram_iter_free(itor);
+    }
+    
+    TEST_EQUAL(0, ngram_model_free(model));
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_ngram/test_lm_class.c

@@ +1 @@
+#include <ngram_model.h>
+#include <logmath.h>
+#include <strfuncs.h>
+
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+void
+run_tests(logmath_t *lmath, ngram_model_t *model)
+{
+    int32 rv, i;
+
+    TEST_ASSERT(model);
+
+    TEST_EQUAL(ngram_wid(model, "scylla"), 285);
+    TEST_EQUAL(strcmp(ngram_word(model, 285), "scylla"), 0);
+
+    rv = ngram_model_read_classdef(model, LMDIR "/100.probdef");
+    TEST_EQUAL(rv, 0);
+
+    /* Verify that class word IDs remain the same. */
+    TEST_EQUAL(ngram_wid(model, "scylla"), 285);
+    TEST_EQUAL(strcmp(ngram_word(model, 285), "scylla"), 0);
+
+    /* Verify in-class word IDs. */
+    TEST_EQUAL(ngram_wid(model, "scylla:scylla"), 0x80000000 | 400);
+
+    /* Verify in-class and out-class unigram scores. */
+    TEST_EQUAL_LOG(ngram_score(model, "scylla:scylla", NULL),
+               logmath_log10_to_log(lmath, -2.7884) + logmath_log(lmath, 0.4));
+    TEST_EQUAL_LOG(ngram_score(model, "scooby:scylla", NULL),
+               logmath_log10_to_log(lmath, -2.7884) + logmath_log(lmath, 0.1));
+    TEST_EQUAL_LOG(ngram_score(model, "scylla", NULL),
+               logmath_log10_to_log(lmath, -2.7884));
+    TEST_EQUAL_LOG(ngram_score(model, "oh:zero", NULL),
+               logmath_log10_to_log(lmath, -1.9038) + logmath_log(lmath, 0.7));
+    TEST_EQUAL_LOG(ngram_score(model, "zero", NULL),
+               logmath_log10_to_log(lmath, -1.9038));
+
+    /* Verify class bigram scores. */
+    TEST_EQUAL_LOG(ngram_score(model, "scylla", "on", NULL),
+               logmath_log10_to_log(lmath, -1.2642));
+    TEST_EQUAL_LOG(ngram_score(model, "scylla:scylla", "on", NULL),
+               logmath_log10_to_log(lmath, -1.2642) + logmath_log(lmath, 0.4));
+    TEST_EQUAL_LOG(ngram_score(model, "apparently", "scylla", NULL),
+               logmath_log10_to_log(lmath, -0.5172));
+    TEST_EQUAL_LOG(ngram_score(model, "apparently", "karybdis:scylla", NULL),
+               logmath_log10_to_log(lmath, -0.5172));
+    TEST_EQUAL_LOG(ngram_score(model, "apparently", "scooby:scylla", NULL),
+               logmath_log10_to_log(lmath, -0.5172));
+
+    /* Verify class trigram scores. */
+    TEST_EQUAL_LOG(ngram_score(model, "zero", "be", "will", NULL),
+               logmath_log10_to_log(lmath, -0.5725));
+    TEST_EQUAL_LOG(ngram_score(model, "oh:zero", "be", "will", NULL),
+               logmath_log10_to_log(lmath, -0.5725) + logmath_log(lmath, 0.7));
+    TEST_EQUAL_LOG(ngram_score(model, "should", "variance", "zero", NULL),
+               logmath_log10_to_log(lmath, -0.9404));
+    TEST_EQUAL_LOG(ngram_score(model, "should", "variance", "zero:zero", NULL),
+               logmath_log10_to_log(lmath, -0.9404));
+
+    /* Add words to classes. */
+    rv = ngram_model_add_class_word(model, "scylla", "scrappy:scylla", 1.0);
+    TEST_ASSERT(rv >= 0);
+    TEST_EQUAL(ngram_wid(model, "scrappy:scylla"), 0x80000196);
+    TEST_EQUAL_LOG(ngram_score(model, "scrappy:scylla", NULL),
+               logmath_log10_to_log(lmath, -2.7884) + logmath_log(lmath, 0.2));
+    printf("scrappy:scylla %08x %d %f\n", 
+           ngram_wid(model, "scrappy:scylla"),
+           ngram_score(model, "scrappy:scylla", NULL),
+           logmath_exp(lmath, ngram_score(model, "scrappy:scylla", NULL)));
+    /* Add a lot of words to a class. */
+    for (i = 0; i < 129; ++i) {
+        char word[32];
+        sprintf(word, "%d:scylla", i);
+        rv = ngram_model_add_class_word(model, "scylla", word, 1.0);
+        printf("%s %08x %d %f\n", word,
+               ngram_wid(model, word),
+               ngram_score(model, word, NULL),
+               logmath_exp(lmath, ngram_score(model, word, NULL)));
+        TEST_ASSERT(rv >= 0);
+        TEST_EQUAL(ngram_wid(model, word), 0x80000197 + i);
+    }
+
+    /* Add a new class. */
+    {
+        const char *words[] = { "blatz:foobie", "hurf:foobie" };
+        float32 weights[] = { 0.6, 0.4 };
+        int32 foobie_prob;
+        rv = ngram_model_add_class(model, "[foobie]", 1.0,
+                       words, weights, 2);
+        TEST_ASSERT(rv >= 0);
+        foobie_prob = ngram_score(model, "[foobie]", NULL);
+        TEST_EQUAL_LOG(ngram_score(model, "blatz:foobie", NULL),
+                   foobie_prob + logmath_log(lmath, 0.6));
+        TEST_EQUAL_LOG(ngram_score(model, "hurf:foobie", NULL),
+                   foobie_prob + logmath_log(lmath, 0.4));
+    }
+}
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    ngram_model_t *model;
+
+    lmath = logmath_init(1.0001, 0, 0);
+
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.DMP", NGRAM_DMP, lmath);
+    run_tests(lmath, model);
+    ngram_model_free(model);
+
+    model = ngram_model_read(NULL, LMDIR "/100.arpa.gz", NGRAM_ARPA, lmath);
+    run_tests(lmath, model);
+    ngram_model_free(model);
+
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_string/_string_join.test

@@ +1 @@
+#!/bin/sh
+exec ./strtest string_join

src/tests/libs/sphinx/test_string/_fread_line.test

@@ +1 @@
+#!/bin/sh
+exec ./strtest fread_line

src/tests/libs/sphinx/test_string/_fread_line.txt

@@ +1 @@
+Hello world!
+123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456
+All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  

src/tests/libs/sphinx/test_string/_str2words.test

@@ +1 @@
+#!/bin/sh
+exec ./strtest str2words

src/tests/libs/sphinx/test_string/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_string ;
+
+SetSubDirSupportedPlatforms $(HAIKU_BONE_COMPATIBLE_PLATFORMS) ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+AddResources strtest : strtest.rdef ;
+AddResources test_atof : test_atof.rdef ;
+
+SimpleTest strtest : strtest.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+
+SimpleTest test_atof : test_atof.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+

src/tests/libs/sphinx/test_string/_nextword.test

@@ +1 @@
+#!/bin/sh
+exec ./strtest nextword

src/tests/libs/sphinx/test_string/strtest.rdef

@@ +1 @@
+resource app_signature "application/x-vnd.Haiku-strtest";
+
+resource app_version
+{
+    major = 0,
+    middle = 6,
+    minor = 0,
+    variety = B_APPV_FINAL,
+    internal = 0,
+    short_info = "strtest", 
+    long_info  = "strtest from CMU sphinxbase-0.6"
+};
+
+resource app_flags B_MULTIPLE_LAUNCH | B_ARGV_ONLY | B_BACKGROUND_APP ;

src/tests/libs/sphinx/test_string/test_atof.rdef

@@ +1 @@
+resource app_signature "application/x-vnd.Haiku-test_atof";
+
+resource app_version
+{
+    major = 0,
+    middle = 6,
+    minor = 0,
+    variety = B_APPV_BETA,
+    internal = 0,
+    short_info = "test_atof", 
+    long_info  = "test_atof from CMU sphinxbase-0.6"
+};
+
+resource app_flags B_MULTIPLE_LAUNCH | B_ARGV_ONLY | B_BACKGROUND_APP ;

src/tests/libs/sphinx/test_string/strtest.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "strfuncs.h"
+#include "pio.h"
+#include "ckd_alloc.h"
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "."
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+    if (argc < 2)
+        return 1;
+
+    if (!strcmp(argv[1], "string_join")) {
+        char *foo = string_join("bar", "baz", "quux", NULL);
+        if (strcmp(foo, "barbazquux") != 0) {
+            printf("%s != barbazquux\n", foo);
+            return 1;
+        }
+        foo = string_join("hello", NULL);
+        if (strcmp(foo, "hello") != 0) {
+            printf("%s != hello\n", foo);
+            return 1;
+        }
+        return 0;
+    }
+    else if (!strcmp(argv[1], "fread_line")) {
+        FILE *fp = fopen(TESTDATADIR "/_fread_line.txt", "r");
+        char *line;
+        size_t len;
+
+        if (fp == NULL) {
+            perror("Failed to open " TESTDATADIR "/_fread_line.txt");
+            return 1;
+        }
+        line = fread_line(fp, &len);
+        printf("len = %d orig = %ld\n", (int32)len,
+               strlen("Hello world!\n"));
+        if (strcmp(line, "Hello world!\n") != 0) {
+            printf("'%s' != 'Hello world!\\n'\n", line);
+            return 1;
+        }
+        ckd_free(line);
+        line = fread_line(fp, &len);
+        /* A line of exactly 127 characters. */
+        printf("len = %d orig = %ld\n", (int32)len,
+               strlen("123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456\n"));
+        if (strcmp(line, "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456\n") != 0) {
+            printf("'%s' != '123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456\\n'\n", line);
+            return 1;
+        }
+        ckd_free(line);
+        /* A very long line. */
+        line = fread_line(fp, &len);
+        printf("len = %d orig = %ld\n", (int32)len,
+               strlen("All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  \n"));
+        if (strcmp(line, "All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  \n") != 0) {
+            printf("'%s' != 'All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  All work and no play makes Jack a very dull boy.  \\n'\n", line);
+            return 1;
+        }
+        ckd_free(line);
+        line = fread_line(fp, &len);
+        if (line != NULL) {
+            printf("%p != NULL\n", line);
+            return 1;
+        }
+    }
+    else if (!strcmp(argv[1], "string_trim")) {
+        char *foo = ckd_salloc("\t foo bar baz  \n");
+        string_trim(foo, STRING_BOTH);
+        if (strcmp(foo, "foo bar baz") != 0) {
+            printf("'%s' != 'foo bar baz'\n", foo);
+            return 1;
+        }
+        string_trim(foo, STRING_BOTH);
+        if (strcmp(foo, "foo bar baz") != 0) {
+            printf("'%s' != 'foo bar baz'\n", foo);
+            return 1;
+        }
+        strcpy(foo, "foo\nbar\n\n");
+        string_trim(foo, STRING_END);
+        if (strcmp(foo, "foo\nbar") != 0) {
+            printf("'%s' != 'foo\\nbar'\n", foo);
+            return 1;
+        }
+        strcpy(foo, " \t \t foobar\n");
+        string_trim(foo, STRING_START);
+        if (strcmp(foo, "foobar\n") != 0) {
+            printf("'%s' != 'foobar\\n'\n", foo);
+            return 1;
+        }
+    }
+    else if (!strcmp(argv[1], "str2words")) {
+        char *line = strdup("    foo bar baz argh");
+        char **words;
+        int n;
+
+        n = str2words(line, NULL, 0);
+        if (n != 4) {
+            printf("%d != 4\n", n);
+            return 1;
+        }
+        words = ckd_calloc(n, sizeof(*words));
+        n = str2words(line, words, n);
+        if (n != 4) {
+            printf("%d != 4\n", n);
+            return 1;
+        }
+        if (strcmp(words[0], "foo") != 0
+            || strcmp(words[1], "bar") != 0
+            || strcmp(words[2], "baz") != 0
+            || strcmp(words[3], "argh") != 0) {
+            printf("%s, %s, %s, %s != foo, bar, baz, argh\n",
+                   words[0], words[1], words[2], words[3]);
+            return 1;
+        }
+        return 0;
+    }
+    else if (!strcmp(argv[1], "nextword")) {
+        char *line = strdup(" \tfoo bar\nbaz argh");
+        char *word;
+        const char *delim = " \t\n";
+        char delimfound;
+        int n;
+
+        n = nextword(line, delim, &word, &delimfound);
+        if (strcmp(word, "foo") != 0) {
+            printf("%s != foo\n", word);
+            return 1;
+        }
+        if (delimfound != ' ') {
+            printf("didn't find ' '\n");
+            return 1;
+        }
+        word[n] = delimfound;
+        line = word + n;
+        n = nextword(line, delim, &word, &delimfound);
+        if (strcmp(word, "bar") != 0) {
+            printf("%s != bar\n", word);
+            return 1;
+        }
+        if (delimfound != '\n') {
+            printf("didn't find '\\n'\n");
+            return 1;
+        }
+        word[n] = delimfound;
+        line = word + n;
+        n = nextword(line, delim, &word, &delimfound);
+        if (strcmp(word, "baz") != 0) {
+            printf("%s != baz\n", word);
+            return 1;
+        }
+        if (delimfound != ' ') {
+            printf("didn't find ' '\n");
+            return 1;
+        }
+        word[n] = delimfound;
+        line = word + n;
+        n = nextword(line, delim, &word, &delimfound);
+        if (strcmp(word, "argh") != 0) {
+            printf("%s != argh\n", word);
+            return 1;
+        }
+        if (delimfound != '\0') {
+            printf("didn't find NUL\n");
+            return 1;
+        }
+        word[n] = delimfound;
+        line = word + n;
+        n = nextword(line, delim, &word, &delimfound);
+        if (n != -1) {
+            printf("didn't get -1 at end of string\n");
+        }
+
+        line = strdup("FOO!");
+        n = nextword(line, delim, &word, &delimfound);
+        if (strcmp(word, "FOO!") != 0) {
+            printf("%s != FOO!\n", word);
+            return 1;
+        }
+        if (delimfound != '\0') {
+            printf("didn't find NUL\n");
+            return 1;
+        }
+
+        return 0;
+    }
+    return 0;
+}

src/tests/libs/sphinx/test_string/test_atof.c

@@ +1 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <locale.h>
+#include <stdlib.h>
+
+#include "strfuncs.h"
+
+int
+main(int argc, char *argv[])
+{
+    double foo;
+
+    /* Ensure that it's really locale-independent. */
+    if (setlocale(LC_ALL, "fr_CA.UTF-8") == NULL)
+        fprintf(stderr, "Note: setlocale(LC_ALL, fr_CA.UTF-8) failed\n");
+    
+    foo = atof("1.5324523524523423");
+    printf("atof(): 1.5324523524523423 %f\n", foo);
+
+    foo = atof_c("1.5324523524523423");
+    printf("1.5324523524523423 %f\n", foo);
+    if (fabs(foo - 1.532) > 0.01)
+        return 1;
+
+    foo = atof_c("5e-3");
+    printf("5e-3 %f\n", foo);
+    if (fabs(foo - 0.005) > 0.01)
+        return 1;
+
+    foo = atof_c("1.2e+2");
+    printf("1.2e+2 %f\n", foo);
+    if (fabs(foo - 120.0) > 0.01)
+        return 1;
+
+    foo = atof_c("1e-80");
+    printf("1e-80 %g\n", foo);
+
+    return 0;
+}

src/tests/libs/sphinx/test_string/_string_trim.test

@@ +1 @@
+#!/bin/sh
+exec ./strtest string_trim

src/tests/libs/sphinx/test_thread/test_event.c

@@ +1 @@
+#include <stdio.h>
+#include <sbthread.h>
+#include <err.h>
+
+int
+worker_main(sbthread_t *th)
+{
+    sbevent_t *cond;
+
+    cond = sbthread_arg(th);
+
+    /* Get the first signal. */
+    sbevent_wait(cond, -1, -1);
+    E_INFO("Got signal\n");
+
+    /* Now wait a while and exit. */
+    sbevent_wait(cond, 1, 500*1000*1000);
+    return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+    sbthread_t *worker;
+    sbevent_t *cond;
+
+    cond = sbevent_init();
+    worker = sbthread_start(NULL, worker_main, cond);
+
+    E_INFO("Signalling condition\n");
+    sbevent_signal(cond);
+
+    E_INFO("Waiting (about 1.5 sec) for thread termination\n");
+    sbthread_free(worker);
+    sbevent_free(cond);
+    return 0;
+}

src/tests/libs/sphinx/test_thread/test_tls_log.c

@@ +1 @@
+#include <string.h>
+#include <stdio.h>
+#include <sbthread.h>
+#include <strfuncs.h>
+#include <fe.h>
+#include <ckd_alloc.h>
+#include <err.h>
+
+#include "test_macros.h"
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+
+static const arg_t fe_args[] = {
+    waveform_to_cepstral_command_line_macro(),
+    { NULL, 0, NULL, NULL }
+};
+
+
+static int
+process(sbthread_t *th)
+{
+    FILE *raw, *logfh;
+    int16 *buf;
+    mfcc_t **cepbuf;
+    size_t nsamps;
+    fe_t *fe;
+    long fsize;
+    int32 nfr;
+    char outfile[16];
+
+    sprintf(outfile, "%03ld.log", (long)sbthread_arg(th));
+    if ((logfh = fopen(outfile, "w")) == NULL)
+        return -1;
+    err_set_logfp(logfh);
+    if ((fe = fe_init_auto_r(sbthread_config(th))) == NULL)
+        return -1;
+    if ((raw = fopen(TESTDATADIR "/chan3.raw", "rb")) == NULL)
+        return -1;
+    fseek(raw, 0, SEEK_END);
+    fsize = ftell(raw);
+    fseek(raw, 0, SEEK_SET);
+    buf = ckd_malloc(fsize);
+    fread(buf, 1, fsize, raw);
+    nsamps = fsize / 2;
+
+    fe_process_utt(fe, buf, nsamps, &cepbuf, &nfr);
+    E_INFO("nfr = %d\n", nfr);
+    fe_free_2d(cepbuf);
+    ckd_free(buf);
+    fclose(raw);
+    fe_free(fe);
+    fclose(logfh);
+
+    return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+    sbthread_t *threads[10];
+    cmd_ln_t *config;
+    int i;
+
+    E_INFO("Processing chan3.raw in 10 threads\n");
+    if ((config = cmd_ln_parse_r(NULL, fe_args, 0, NULL, FALSE)) == NULL)
+        return -1;
+    for (i = 0; i < 10; ++i) {
+        config = cmd_ln_retain(config);
+        threads[i] = sbthread_start(config, process, (void *)(long)i);
+    }
+    for (i = 0; i < 10; ++i) {
+        int rv;
+        rv = sbthread_wait(threads[i]);
+        E_INFO("Thread %d exited with status %d\n", i, rv);
+        sbthread_free(threads[i]);
+    }
+    /* Now check to make sure they all created logfiles with the
+     * correct contents. */
+    for (i = 0; i < 10; ++i) {
+        char logfile[16], line[256];
+        FILE *logfh;
+
+        sprintf(logfile, "%03d.log", i);
+        TEST_ASSERT(logfh = fopen(logfile, "r"));
+        while (fgets(line, sizeof(line), logfh)) {
+            string_trim(line, STRING_BOTH);
+            printf("%s: |%s|\n", logfile, line);
+            TEST_EQUAL(0, strcmp(line, "INFO: test_tls_log.c(44): nfr = 1436"));
+        }
+        fclose(logfh);
+    }
+    cmd_ln_free_r(config);
+    return 0;
+}

src/tests/libs/sphinx/test_thread/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_thread ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_event : test_event.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_msgq : test_msgq.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a  ;
+SimpleTest test_thread : test_thread.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a  ;
+SimpleTest test_tls_log : test_tls_log.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a  ;

src/tests/libs/sphinx/test_thread/test_msgq.c

@@ +1 @@
+#include <stdio.h>
+#include <sbthread.h>
+#include <err.h>
+
+int
+worker_main(sbthread_t *th)
+{
+    sbmsgq_t *msgq;
+    void *data;
+    size_t len;
+
+    msgq = sbthread_msgq(th);
+    while ((data = sbmsgq_wait(msgq, &len, -1, -1)) != NULL) {
+        int msg = *(int *)data;
+        E_INFO("Got message: %d\n", msg);
+        if (msg == 32)
+            break;
+    }
+
+    return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+    sbthread_t *worker;
+    int i;
+    
+    worker = sbthread_start(NULL, worker_main, NULL);
+    for (i = 0; i <= 32; ++i) {
+        int ii[128];
+        E_INFO("Sending message: %d\n", i);
+        ii[0] = i;
+        if (sbthread_send(worker, sizeof(ii), &ii) < 0) {
+            E_ERROR("sbthread_send failed\n");
+            return 1;
+        }
+    }
+    sbthread_free(worker);
+
+    return 0;
+}

src/tests/libs/sphinx/test_thread/test_thread.c

@@ +1 @@
+#include <stdio.h>
+#include <sbthread.h>
+#include <fe.h>
+#include <ckd_alloc.h>
+#include <err.h>
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+static const arg_t fe_args[] = {
+    waveform_to_cepstral_command_line_macro(),
+    { NULL, 0, NULL, NULL }
+};
+
+static int
+process(sbthread_t *th)
+{
+    FILE *raw;
+    int16 *buf;
+    mfcc_t **cepbuf;
+    size_t nsamps;
+    fe_t *fe;
+    long fsize;
+    int32 nfr;
+
+    if ((fe = fe_init_auto_r(sbthread_config(th))) == NULL)
+        return -1;
+
+    if ((raw = fopen(TESTDATADIR "/chan3.raw", "rb")) == NULL)
+        return -1;
+    fseek(raw, 0, SEEK_END);
+    fsize = ftell(raw);
+    fseek(raw, 0, SEEK_SET);
+    buf = ckd_malloc(fsize);
+    fread(buf, 1, fsize, raw);
+    nsamps = fsize / 2;
+
+    fe_process_utt(fe, buf, nsamps, &cepbuf, &nfr);
+    E_INFO("nfr = %d\n", nfr);
+    fe_free_2d(cepbuf);
+    ckd_free(buf);
+    fclose(raw);
+    fe_free(fe);
+
+    return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+    sbthread_t *threads[10];
+    cmd_ln_t *config;
+    int i;
+
+    E_INFO("Processing chan3.raw in 10 threads\n");
+    if ((config = cmd_ln_parse_r(NULL, fe_args, 0, NULL, FALSE)) == NULL)
+        return -1;
+    for (i = 0; i < 10; ++i) {
+        config = cmd_ln_retain(config);
+        threads[i] = sbthread_start(config, process, NULL);
+    }
+    for (i = 0; i < 10; ++i) {
+        int rv;
+        rv = sbthread_wait(threads[i]);
+        E_INFO("Thread %d exited with status %d\n", i, rv);
+        sbthread_free(threads[i]);
+    }
+    cmd_ln_free_r(config);
+    return 0;
+}

src/tests/libs/sphinx/test_thread/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx ;
+
+#SubInclude HAIKU_TOP src tests libs sphinx sphinx_adtools ;
+SubInclude HAIKU_TOP src tests libs sphinx sphinx_cepview ;
+SubInclude HAIKU_TOP src tests libs sphinx sphinx_fe ;
+SubInclude HAIKU_TOP src tests libs sphinx sphinx_lmtools ;
+#SubInclude HAIKU_TOP src tests libs sphinx test_ad ;
+SubInclude HAIKU_TOP src tests libs sphinx test_alloc ;
+SubInclude HAIKU_TOP src tests libs sphinx test_bitvec ;
+SubInclude HAIKU_TOP src tests libs sphinx test_case ;
+SubInclude HAIKU_TOP src tests libs sphinx test_cmdln ;
+SubInclude HAIKU_TOP src tests libs sphinx test_fe ;
+SubInclude HAIKU_TOP src tests libs sphinx test_feat ;
+SubInclude HAIKU_TOP src tests libs sphinx test_fsg ;
+SubInclude HAIKU_TOP src tests libs sphinx test_hash ;
+SubInclude HAIKU_TOP src tests libs sphinx test_logmath ;
+SubInclude HAIKU_TOP src tests libs sphinx test_matrix ;
+SubInclude HAIKU_TOP src tests libs sphinx test_ngram ;
+SubInclude HAIKU_TOP src tests libs sphinx test_string ;
+SubInclude HAIKU_TOP src tests libs sphinx test_thread ;
+SubInclude HAIKU_TOP src tests libs sphinx test_util ;

src/tests/libs/sphinx/test_case/_ucase2.test

@@ +1 @@
+#!/bin/sh
+./chgCase ucase 1 1
+ No newline at end of file

src/tests/libs/sphinx/test_case/_ucase3.test

@@ +1 @@
+#!/bin/sh
+./chgCase ucase
+ No newline at end of file

src/tests/libs/sphinx/test_case/_lcase1.test

@@ +1 @@
+#!/bin/sh
+./chgCase lcase 5 3

src/tests/libs/sphinx/test_case/_lcase2.test

@@ +1 @@
+#!/bin/sh
+./chgCase lcase 1 1

src/tests/libs/sphinx/test_case/_strcmp1.test

@@ +1 @@
+#!/bin/sh
+./chgCase strcmp_nocase 2 3
+ No newline at end of file

src/tests/libs/sphinx/test_case/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_case ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest chgcase : chgCase.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_case/_lcase3.test

@@ +1 @@
+#!/bin/sh
+./chgCase lcase
+ No newline at end of file

src/tests/libs/sphinx/test_case/_strcmp2.test

@@ +1 @@
+#!/bin/sh
+./chgCase strcmp_nocase 1 1
+ No newline at end of file

src/tests/libs/sphinx/test_case/_strcmp3.test

@@ +1 @@
+#!/bin/sh
+./chgCase strcmp_nocase
+ No newline at end of file

src/tests/libs/sphinx/test_case/_ucase1.test

@@ +1 @@
+#!/bin/sh
+./chgCase ucase 2 4
+ No newline at end of file

src/tests/libs/sphinx/test_case/chgCase.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <case.h>
+#include <err.h>
+
+#define MAX_STR_LEN 64
+#define NUM_STRS 6
+
+#define STR0 "this string should NEVER show up"
+#define STR1 ""
+#define STR2 "az3o%\tW@^#\\\n\r[]{}|\() '\""
+#define STR3 "az3o%\tw@^#\\\n\r[]{}|\() '\""
+#define STR4 "AZ3O%\tW@^#\\\n\r[]{}|\() '\""
+#define STR5 "AZ3O%\tw@^#\\\n\r[]{}|\() '\""
+
+
+int
+main(int argc, char **argv)
+{
+    int cmp;
+    char *n1 = NULL;
+    char *n2 = NULL;
+
+    char s1[MAX_STR_LEN];
+    char s2[MAX_STR_LEN];
+
+    char strs[NUM_STRS][MAX_STR_LEN] = { STR0,
+        STR1,
+        STR2,
+        STR3,
+        STR4,
+        STR5
+    };
+
+    if (argc < 2 ||
+        3 == argc ||
+        argc > 4 ||
+        (strcmp(argv[1], "lcase") &&
+         strcmp(argv[1], "ucase") && strcmp(argv[1], "strcmp_nocase")
+        )) {
+        /*printf("INVALID PARAMETERS to chgCase\n"); */
+        exit(1);
+    }
+
+
+    if (2 == argc) {
+        if (0 == strcmp(argv[1], "ucase")) {
+            ucase(n1);
+        }
+        else if (0 == strcmp(argv[1], "lcase")) {
+            lcase(n1);
+        }
+        else {
+            strcmp_nocase(n1, n2);
+        }
+        /*
+           if we're still alive we obviously didn't segfault
+         */
+        exit(0);
+    }
+
+    if (4 == argc) {
+
+        if (0 >= atoi(argv[2]) ||
+            atoi(argv[2]) >= NUM_STRS ||
+            0 >= atoi(argv[3]) || atoi(argv[3]) >= NUM_STRS) {
+            E_INFO("INVALID PARAMS TO chkCase\n");
+            exit(1);
+        }
+
+        strcpy(s1, strs[atoi(argv[2])]);
+        strcpy(s2, strs[atoi(argv[3])]);
+
+        if (0 == strcmp(argv[1], "ucase")) {
+            ucase(s1);
+            cmp = strcmp(s1, s2);
+        }
+        else if (0 == strcmp(argv[1], "lcase")) {
+            lcase(s1);
+            cmp = strcmp(s1, s2);
+        }
+        else {
+            cmp = strcmp_nocase(s1, s2);
+        }
+
+        /*    E_INFO("Value of cmp %d\n", cmp); */
+        if (0 != cmp) {
+            E_FATAL("test failed\nstr1:|%s|\nstr2:|%s|\n", s1, s2);
+        }
+
+        return (cmp != 0);
+    }
+
+    /*somehow we got here and we shouldn't have */
+
+    exit(1);
+}

src/tests/libs/sphinx/test_bitvec/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_bitvec ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_bitvec : test_bitvec.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_bitvec/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define EPSILON 0.01
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_bitvec/test_bitvec.c

@@ +1 @@
+#include <stdio.h>
+#include <time.h>
+
+#include "bitvec.h"
+#include "test_macros.h"
+
+int
+main(int argc, char *argv[])
+{
+    bitvec_t *bv;
+    int i, j;
+    clock_t c;
+
+    TEST_ASSERT(bv = bitvec_alloc(199));
+    bitvec_set(bv,198);
+    bitvec_set(bv,0);
+    bitvec_set(bv,42);
+    bitvec_set(bv,43);
+    bitvec_set(bv,44);
+    TEST_ASSERT(bitvec_is_set(bv,198));
+    TEST_ASSERT(bitvec_is_set(bv,0));
+    TEST_ASSERT(bitvec_is_set(bv,42));
+    TEST_ASSERT(bitvec_is_set(bv,43));
+    TEST_ASSERT(bitvec_is_set(bv,44));
+    TEST_EQUAL(5, bitvec_count_set(bv, 199));
+    bitvec_clear(bv, 43);
+    TEST_EQUAL(0, bitvec_is_set(bv,43));
+
+    c = clock();
+    for (j = 0; j < 1000000; ++j)
+        bitvec_count_set(bv, 199);
+    c = clock() - c;
+    printf("1000000 * 199 bitvec_count_set in %.2f sec\n",
+           (double)c / CLOCKS_PER_SEC);
+    bitvec_free(bv);
+
+    bv = bitvec_alloc(1314);
+    c = clock();
+    for (j = 0; j < 50000; ++j)
+        for (i = 0; i < 1314; ++i)
+            bitvec_set(bv, i);
+    c = clock() - c;
+    printf("50000 * 1314 bitvec_set in %.2f sec\n",
+           (double)c / CLOCKS_PER_SEC);
+    bitvec_free(bv);
+
+    return 0;
+}

src/tests/libs/sphinx/test_util/test_filename.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/**
+ * @file test_filename.c Test file name operations
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+#include "filename.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+int
+main(int argc, char *argv[])
+{
+    char const testname[] = "/foo/bar/baz/quux.argh";
+    char const testname2[] = "foo/bar/baz";
+    char const testname3[] = "/foo";
+    char testout[32];
+
+    path2basename(testname, testout);
+    TEST_EQUAL(0, strcmp("quux.argh", testout));
+
+    path2dirname(testname, testout);
+    TEST_EQUAL(0, strcmp("/foo/bar/baz", testout));
+
+    path2dirname(testname2, testout);
+    TEST_EQUAL(0, strcmp("foo/bar", testout));
+
+    path2dirname(testname3, testout);
+    TEST_EQUAL(0, strcmp("", testout));
+
+    return 0;
+}

src/tests/libs/sphinx/test_util/test_huff_code.c

@@ +1 @@
+/**
+ * @file test_huff_code.c Test Huffman coding
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+#include "huff_code.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int32 const ivalues[10] = {
+    1, 2, 3, 5, 7, 11, 13, 17, 19, 23
+};
+int32 const frequencies[10] = {
+    42, 4, 5, 6, 225, 15001, 3, 2, 87, 1003
+};
+char * const svalues[10] = {
+    "foo", "bar", "baz", "quux", "argh",
+    "hurf", "burf", "blatz", "unf", "woof"
+};
+char * const svalues2[10] = {
+    "1","2","3","4","5","6","7","8","9","10"
+};
+char const cdata[7] = { 0x08, 0x30, 0x40, 0x4c, 0x00, 0x04, 0x50 };
+
+void
+test_intcode(huff_code_t *hc)
+{
+    FILE *fh;
+    char const *dptr;
+    int i, offset;
+    size_t dlen;
+    int32 val;
+
+    fh = fopen("hufftest.out", "wb");
+    huff_code_attach(hc, fh, "wb");
+    for (i = 0; i < 10; ++i) {
+        huff_code_encode_int(hc, ivalues[i], NULL);
+    }
+    huff_code_detach(hc);
+    fclose(fh);
+    fh = fopen("hufftest.out", "rb");
+    huff_code_attach(hc, fh, "rb");
+    for (i = 0; i < 10; ++i) {
+        int32 val;
+        huff_code_decode_int(hc, &val, NULL, NULL, 0);
+        printf("%d ", val);
+        TEST_EQUAL(val, ivalues[i]);
+    }
+    printf("\n");
+    huff_code_detach(hc);
+    fclose(fh);
+
+    dptr = cdata;
+    dlen = 7;
+    offset = 0;
+    for (i = 0; i < 10; ++i) {
+        huff_code_decode_int(hc, &val, &dptr, &dlen, &offset);
+        printf("%d ", val);
+        TEST_EQUAL(val, ivalues[i]);
+    }
+    TEST_EQUAL(dlen, 1);
+    TEST_EQUAL(offset, 4);
+    printf("\n");
+
+    dptr = cdata;
+    dlen = 7;
+    offset = 0;
+    i = 0;
+    while (huff_code_decode_int(hc, &val, &dptr, &dlen, &offset) != -1) {
+        printf("%d ", val);
+        TEST_EQUAL(val, ivalues[i++]);
+    }
+    TEST_EQUAL(dlen, 1);
+    TEST_EQUAL(offset, 4);
+    printf("\n");
+}
+
+void
+test_strcode(huff_code_t *hc, char * const *svalues)
+{
+    FILE *fh;
+    char const *dptr;
+    int i, offset;
+    size_t dlen;
+
+    fh = fopen("hufftest.out", "wb");
+    huff_code_attach(hc, fh, "wb");
+    for (i = 9; i >= 0; --i) {
+        huff_code_encode_str(hc, svalues[i], NULL);
+    }
+    huff_code_detach(hc);
+    fclose(fh);
+    fh = fopen("hufftest.out", "rb");
+    huff_code_attach(hc, fh, "rb");
+    for (i = 9; i >= 0; --i) {
+        char const *val = huff_code_decode_str(hc, NULL, NULL, 0);
+        printf("%s ", val);
+        TEST_EQUAL(0, strcmp(val, svalues[i]));
+    }
+    printf("\n");
+    huff_code_detach(hc);
+    fclose(fh);
+
+    dptr = cdata;
+    dlen = 7;
+    offset = 0;
+    for (i = 0; i < 10; ++i) {
+        char const *val = huff_code_decode_str(hc, &dptr, &dlen, &offset);
+        printf("%s ", val);
+        TEST_EQUAL(0, strcmp(val, svalues[i]));
+    }
+    TEST_EQUAL(dlen, 1);
+    TEST_EQUAL(offset, 4);
+    printf("\n");
+}
+
+int
+main(int argc, char *argv[])
+{
+    huff_code_t *hc;
+    FILE *fh;
+
+    hc = huff_code_build_int(ivalues, frequencies, 10);
+    huff_code_dump(hc, stdout);
+    test_intcode(hc);
+    fh = fopen("huffcode.out", "wb");
+    huff_code_write(hc, fh);
+    fclose(fh);
+    huff_code_free(hc);
+
+    fh = fopen("huffcode.out", "rb");
+    hc = huff_code_read(fh);
+    fclose(fh);
+    test_intcode(hc);
+    huff_code_free(hc);
+
+    hc = huff_code_build_str(svalues, frequencies, 10);
+    huff_code_dump(hc, stdout);
+    test_strcode(hc, svalues);
+    fh = fopen("huffcode.out", "wb");
+    huff_code_write(hc, fh);
+    fclose(fh);
+    huff_code_free(hc);
+
+    fh = fopen("huffcode.out", "rb");
+    hc = huff_code_read(fh);
+    fclose(fh);
+    test_strcode(hc, svalues);
+    huff_code_free(hc);
+
+    hc = huff_code_build_str(svalues2, frequencies, 10);
+    huff_code_dump(hc, stdout);
+    test_strcode(hc, svalues2);
+    huff_code_free(hc);
+
+    return 0;
+}
+

src/tests/libs/sphinx/test_util/test_build_directory.c

@@ +1 @@
+/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/**
+ * @file test_build_directory.c Test recursive directory creation
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+#include "pio.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main(int argc, char *argv[])
+{
+    TEST_EQUAL(0, build_directory("foo/bar/baz"));
+    TEST_ASSERT(stat_mtime("foo/bar/baz") != -1);
+    TEST_EQUAL(0, build_directory("./quux/"));
+    TEST_ASSERT(stat_mtime("quux") != -1);
+    TEST_EQUAL(0, build_directory("./foo/bar/baz"));
+    TEST_ASSERT(stat_mtime("foo/bar/baz") != -1);
+    TEST_EQUAL(0, build_directory("/tmp/sphinxbase_foo_bar_baz"));
+    TEST_ASSERT(stat_mtime("/tmp/sphinxbase_foo_bar_baz") != -1);
+
+    return 0;
+}

src/tests/libs/sphinx/test_util/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_util ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_bit_encode : test_bit_encode.c :  libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_build_directory : test_build_directory.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_filename : test_filename.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_fopen : test_fopen.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_huff_code : test_huff_code.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_util/test_fopen.c

@@ +1 @@
+/**
+ * @file test_fopen.c Test file opening
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+#include "pio.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef LMDIR
+#define LMDIR "../regression"
+#endif
+
+int
+main(int argc, char *argv[])
+{
+    FILE *fh;
+    char line[256], *c;
+    int ispipe;
+
+    fh = fopen_comp(LMDIR "/100.arpa.gz", "r", &ispipe);
+    TEST_ASSERT(fh != NULL);
+    c = fgets(line, sizeof(line), fh);
+    TEST_EQUAL('#', line[0]);
+    fclose_comp(fh, ispipe);
+
+    fh = fopen_compchk(LMDIR "/100.arpa.gz", &ispipe);
+    TEST_ASSERT(fh != NULL);
+    c = fgets(line, sizeof(line), fh);
+    TEST_EQUAL('#', line[0]);
+    fclose_comp(fh, ispipe);
+
+    fh = fopen_compchk(LMDIR "/100.arpa.bz2", &ispipe);
+    TEST_ASSERT(fh != NULL);
+    c = fgets(line, sizeof(line), fh);
+    TEST_EQUAL('#', line[0]);
+    fclose_comp(fh, ispipe);
+
+    fh = fopen_compchk(LMDIR "/100.arpa", &ispipe);
+    TEST_ASSERT(fh != NULL);
+    c = fgets(line, sizeof(line), fh);
+    TEST_EQUAL('#', line[0]);
+    fclose_comp(fh, ispipe);
+
+    return 0;
+}

src/tests/libs/sphinx/test_util/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_util/test_bit_encode.c

@@ +1 @@
+/**
+ * @file test_bit_encode.c Test bitstream encoding
+ * @author David Huggins-Daines <dhuggins@cs.cmu.edu>
+ */
+
+#include "pio.h"
+#include "test_macros.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int
+main(int argc, char *argv[])
+{
+    FILE *fh;
+    bit_encode_t *be;
+    int i;
+    static unsigned char const bits[] = "\xde\xad\xbe\xef";
+    uint32 cw = 0xdeadbeef;
+    unsigned char inbits[16];
+
+    fh = fopen("bittest.out", "wb");
+    be = bit_encode_attach(fh);
+    bit_encode_write(be, bits, 8);
+    bit_encode_write(be, bits + 1, 16);
+    bit_encode_write(be, bits + 3, 8);
+    bit_encode_write_cw(be, cw >> 24, 8);
+    bit_encode_write_cw(be, cw >> 16, 8);
+    bit_encode_write_cw(be, cw >> 8, 8);
+    bit_encode_write_cw(be, cw, 8);
+    bit_encode_write_cw(be, cw >> 26, 6);
+    bit_encode_write_cw(be, cw >> 14, 12);
+    bit_encode_write_cw(be, cw >> 8, 6);
+    bit_encode_write_cw(be, cw, 8);
+    for (i = 0; i < 32; ++i) {
+        bit_encode_write_cw(be, cw >> (31-i), 1);
+    }
+    bit_encode_flush(be);
+    bit_encode_free(be);
+    fclose(fh);
+    fh = fopen("bittest.out", "rb");
+    i = fread(inbits, 1, 16, fh);
+    TEST_ASSERT(0 == memcmp(inbits, bits, 4));
+    TEST_ASSERT(0 == memcmp(inbits + 4, bits, 4));
+    TEST_ASSERT(0 == memcmp(inbits + 8, bits, 4));
+    TEST_ASSERT(0 == memcmp(inbits + 12, bits, 4));
+    fclose(fh);
+
+    return 0;
+}

src/tests/libs/sphinx/test_fsg/polite.gram

@@ +1 @@
+#JSGF V1.0;
+
+/**
+ * JSGF Grammar for Hello World example
+ */
+
+grammar polite;
+
+public <startPolite> = [please | kindly | could you | oh mighty computer];
+public <endPolite> = [please | thanks | thank you];

src/tests/libs/sphinx/test_fsg/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_fsg ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_fsg_jsgf : test_fsg_jsgf.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_fsg_read : test_fsg_read.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_fsg_write_fsm : test_fsg_write_fsm.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_fsg/goforward.fsg

@@ +1 @@
+FSG_BEGIN turtle
+NUM_STATES 7
+START_STATE 0
+FINAL_STATE 6
+
+# Transitions
+TRANSITION 0 1 1.0 GO
+TRANSITION 1 2 0.5 FORWARD
+TRANSITION 1 3 0.5 BACKWARD
+TRANSITION 2 4 1.0
+TRANSITION 3 4 1.0
+TRANSITION 4 5 0.1 ONE
+TRANSITION 4 5 0.1 TWO
+TRANSITION 4 5 0.1 THREE
+TRANSITION 4 5 0.1 FOUR
+TRANSITION 4 5 0.1 FIVE
+TRANSITION 4 5 0.1 SIX
+TRANSITION 4 5 0.1 SEVEN
+TRANSITION 4 5 0.1 EIGHT
+TRANSITION 4 5 0.1 NINE
+TRANSITION 4 5 0.1 TEN
+TRANSITION 5 6 0.1 METER
+TRANSITION 5 6 0.9 METERS
+FSG_END

src/tests/libs/sphinx/test_fsg/test_fsg_jsgf.c

@@ +1 @@
+#include <jsgf.h>
+#include <fsg_model.h>
+
+#include "test_macros.h"
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    fsg_model_t *fsg;
+    jsgf_t *jsgf;
+    jsgf_rule_t *rule;
+
+    /* Initialize a logmath object to pass to fsg_model_read */
+    lmath = logmath_init(1.0001, 0, 0);
+    jsgf = jsgf_parse_file(LMDIR "/polite.gram", NULL);
+    TEST_ASSERT(jsgf);
+    rule = jsgf_get_rule(jsgf, "<polite.startPolite>");
+    TEST_ASSERT(rule);
+    fsg = jsgf_build_fsg(jsgf, rule, lmath, 7.5);
+    TEST_ASSERT(fsg);
+
+    TEST_ASSERT(fsg_model_add_silence(fsg, "<sil>", -1, 0.3));
+    TEST_ASSERT(fsg_model_add_silence(fsg, "++NOISE++", -1, 0.3));
+    TEST_ASSERT(fsg_model_add_alt(fsg, "please", "please(2)"));
+
+    jsgf_grammar_free(jsgf);
+    fsg_model_write(fsg, stdout);
+    fsg_model_free(fsg);
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_fsg/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_fsg/test_fsg_read.c

@@ +1 @@
+#include <fsg_model.h>
+
+#include "test_macros.h"
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    fsg_model_t *fsg;
+
+    /* Initialize a logmath object to pass to fsg_model_read */
+    lmath = logmath_init(1.0001, 0, 0);
+    /* Read a FSG. */
+    fsg = fsg_model_readfile(LMDIR "/goforward.fsg", lmath, 7.5);
+    TEST_ASSERT(fsg);
+
+    TEST_ASSERT(fsg_model_add_silence(fsg, "<sil>", -1, 0.3));
+    TEST_ASSERT(fsg_model_add_silence(fsg, "++NOISE++", -1, 0.3));
+    TEST_ASSERT(fsg_model_add_alt(fsg, "FORWARD", "FORWARD(2)"));
+
+    fsg_model_write(fsg, stdout);
+
+    /* Test reference counting. */
+    TEST_ASSERT(fsg = fsg_model_retain(fsg));
+    TEST_EQUAL(1, fsg_model_free(fsg));
+    fsg_model_write(fsg, stdout);
+
+    TEST_EQUAL(0, fsg_model_free(fsg));
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_fsg/test_fsg_write_fsm.c

@@ +1 @@
+#include <jsgf.h>
+#include <fsg_model.h>
+
+#include "test_macros.h"
+
+#ifndef LMDIR
+#define LMDIR "."
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+    logmath_t *lmath;
+    fsg_model_t *fsg;
+    jsgf_t *jsgf;
+    jsgf_rule_t *rule;
+
+    /* Initialize a logmath object to pass to fsg_model_read */
+    lmath = logmath_init(1.0001, 0, 0);
+    jsgf = jsgf_parse_file(LMDIR "/polite.gram", NULL);
+    TEST_ASSERT(jsgf);
+    rule = jsgf_get_rule(jsgf, "<polite.startPolite>");
+    TEST_ASSERT(rule);
+    fsg = jsgf_build_fsg(jsgf, rule, lmath, 7.5);
+    TEST_ASSERT(fsg);
+
+    TEST_ASSERT(fsg_model_add_silence(fsg, "<sil>", -1, 0.3));
+    TEST_ASSERT(fsg_model_add_silence(fsg, "++NOISE++", -1, 0.3));
+    TEST_ASSERT(fsg_model_add_alt(fsg, "please", "please(2)"));
+
+    jsgf_grammar_free(jsgf);
+    fsg_model_write_fsm(fsg, stdout);
+    fsg_model_write_symtab(fsg, stdout);
+    fsg_model_free(fsg);
+    logmath_free(lmath);
+
+    return 0;
+}

src/tests/libs/sphinx/test_feat/test_feat.c

@@ +1 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "feat.h"
+#include "ckd_alloc.h"
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+
+const mfcc_t data[6][13] = {
+    { FLOAT2MFCC(15.114), FLOAT2MFCC(-1.424), FLOAT2MFCC(-0.953),
+      FLOAT2MFCC(0.186), FLOAT2MFCC(-0.656), FLOAT2MFCC(-0.226),
+      FLOAT2MFCC(-0.105), FLOAT2MFCC(-0.412), FLOAT2MFCC(-0.024),
+      FLOAT2MFCC(-0.091), FLOAT2MFCC(-0.124), FLOAT2MFCC(-0.158), FLOAT2MFCC(-0.197)},
+    { FLOAT2MFCC(14.729), FLOAT2MFCC(-1.313), FLOAT2MFCC(-0.892),
+      FLOAT2MFCC(0.140), FLOAT2MFCC(-0.676), FLOAT2MFCC(-0.089),
+      FLOAT2MFCC(-0.313), FLOAT2MFCC(-0.422), FLOAT2MFCC(-0.058),
+      FLOAT2MFCC(-0.101), FLOAT2MFCC(-0.100), FLOAT2MFCC(-0.128), FLOAT2MFCC(-0.123)},
+    { FLOAT2MFCC(14.502), FLOAT2MFCC(-1.351), FLOAT2MFCC(-1.028),
+      FLOAT2MFCC(-0.189), FLOAT2MFCC(-0.718), FLOAT2MFCC(-0.139),
+      FLOAT2MFCC(-0.121), FLOAT2MFCC(-0.365), FLOAT2MFCC(-0.139),
+      FLOAT2MFCC(-0.154), FLOAT2MFCC(0.041), FLOAT2MFCC(0.009), FLOAT2MFCC(-0.073)},
+    { FLOAT2MFCC(14.557), FLOAT2MFCC(-1.676), FLOAT2MFCC(-0.864),
+      FLOAT2MFCC(0.118), FLOAT2MFCC(-0.445), FLOAT2MFCC(-0.168),
+      FLOAT2MFCC(-0.069), FLOAT2MFCC(-0.503), FLOAT2MFCC(-0.013),
+      FLOAT2MFCC(0.007), FLOAT2MFCC(-0.056), FLOAT2MFCC(-0.075), FLOAT2MFCC(-0.237)},
+    { FLOAT2MFCC(14.665), FLOAT2MFCC(-1.498), FLOAT2MFCC(-0.582),
+      FLOAT2MFCC(0.209), FLOAT2MFCC(-0.487), FLOAT2MFCC(-0.247),
+      FLOAT2MFCC(-0.142), FLOAT2MFCC(-0.439), FLOAT2MFCC(0.059),
+      FLOAT2MFCC(-0.058), FLOAT2MFCC(-0.265), FLOAT2MFCC(-0.109), FLOAT2MFCC(-0.196)},
+    { FLOAT2MFCC(15.025), FLOAT2MFCC(-1.199), FLOAT2MFCC(-0.607),
+      FLOAT2MFCC(0.235), FLOAT2MFCC(-0.499), FLOAT2MFCC(-0.080),
+      FLOAT2MFCC(-0.062), FLOAT2MFCC(-0.554), FLOAT2MFCC(-0.209),
+      FLOAT2MFCC(-0.124), FLOAT2MFCC(-0.445), FLOAT2MFCC(-0.352), FLOAT2MFCC(-0.400)},
+};
+
+int
+main(int argc, char *argv[])
+{
+    feat_t *fcb;
+    mfcc_t **in_feats, ***out_feats;
+    int32 i, j, ncep;
+
+    /* Test "raw" features without concatenation */
+    fcb = feat_init("13", CMN_NONE, 0, AGC_NONE, 1, 13);
+
+    in_feats = (mfcc_t **)ckd_alloc_2d_ptr(6, 13, data, sizeof(mfcc_t));
+    out_feats = (mfcc_t ***)ckd_calloc_3d(6, 1, 13, sizeof(mfcc_t));
+    ncep = 6;
+    feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
+
+    for (i = 0; i < 6; ++i) {
+        for (j = 0; j < 13; ++j) {
+            printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
+        }
+        printf("\n");
+    }
+    feat_free(fcb);
+    ckd_free(in_feats);
+    ckd_free_3d(out_feats);
+
+    /* Test "raw" features with concatenation */
+    fcb = feat_init("13:1", CMN_NONE, 0, AGC_NONE, 1, 13);
+
+    in_feats = (mfcc_t **)ckd_alloc_2d_ptr(6, 13, data, sizeof(mfcc_t));
+    out_feats = (mfcc_t ***)ckd_calloc_3d(8, 1, 39, sizeof(mfcc_t));
+    ncep = 6;
+    feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
+
+    for (i = 0; i < 6; ++i) {
+        for (j = 0; j < 39; ++j) {
+            printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
+        }
+        printf("\n");
+    }
+    feat_free(fcb);
+
+    /* Test 1s_c_d_dd features */
+    fcb = feat_init("1s_c_d_dd", CMN_NONE, 0, AGC_NONE, 1, 13);
+    ncep = 6;
+    feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
+
+    for (i = 0; i < 6; ++i) {
+        for (j = 0; j < 39; ++j) {
+            printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
+        }
+        printf("\n");
+    }
+
+    /* Verify that the deltas are correct. */
+    for (i = 2; i < 4; ++i) {
+        for (j = 0; j < 13; ++j) {
+            if (fabs(MFCC2FLOAT(out_feats[i][0][13+j] - 
+                        (out_feats[i+2][0][j]
+                         - out_feats[i-2][0][j]))) > 0.01) {
+                printf("Delta mismatch in [%d][%d]\n", i, j);
+                return 1;
+            }
+        }
+    }
+    feat_free(fcb);
+    ckd_free(in_feats);
+    ckd_free_3d(out_feats);
+
+    return 0;
+}

src/tests/libs/sphinx/test_feat/test_subvq.c

@@ +1 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "feat.h"
+#include "test_macros.h"
+#include "ckd_alloc.h"
+
+const mfcc_t data[6][13] = {
+    { FLOAT2MFCC(15.114), FLOAT2MFCC(-1.424), FLOAT2MFCC(-0.953),
+      FLOAT2MFCC(0.186), FLOAT2MFCC(-0.656), FLOAT2MFCC(-0.226),
+      FLOAT2MFCC(-0.105), FLOAT2MFCC(-0.412), FLOAT2MFCC(-0.024),
+      FLOAT2MFCC(-0.091), FLOAT2MFCC(-0.124), FLOAT2MFCC(-0.158), FLOAT2MFCC(-0.197)},
+    { FLOAT2MFCC(14.729), FLOAT2MFCC(-1.313), FLOAT2MFCC(-0.892),
+      FLOAT2MFCC(0.140), FLOAT2MFCC(-0.676), FLOAT2MFCC(-0.089),
+      FLOAT2MFCC(-0.313), FLOAT2MFCC(-0.422), FLOAT2MFCC(-0.058),
+      FLOAT2MFCC(-0.101), FLOAT2MFCC(-0.100), FLOAT2MFCC(-0.128), FLOAT2MFCC(-0.123)},
+    { FLOAT2MFCC(14.502), FLOAT2MFCC(-1.351), FLOAT2MFCC(-1.028),
+      FLOAT2MFCC(-0.189), FLOAT2MFCC(-0.718), FLOAT2MFCC(-0.139),
+      FLOAT2MFCC(-0.121), FLOAT2MFCC(-0.365), FLOAT2MFCC(-0.139),
+      FLOAT2MFCC(-0.154), FLOAT2MFCC(0.041), FLOAT2MFCC(0.009), FLOAT2MFCC(-0.073)},
+    { FLOAT2MFCC(14.557), FLOAT2MFCC(-1.676), FLOAT2MFCC(-0.864),
+      FLOAT2MFCC(0.118), FLOAT2MFCC(-0.445), FLOAT2MFCC(-0.168),
+      FLOAT2MFCC(-0.069), FLOAT2MFCC(-0.503), FLOAT2MFCC(-0.013),
+      FLOAT2MFCC(0.007), FLOAT2MFCC(-0.056), FLOAT2MFCC(-0.075), FLOAT2MFCC(-0.237)},
+    { FLOAT2MFCC(14.665), FLOAT2MFCC(-1.498), FLOAT2MFCC(-0.582),
+      FLOAT2MFCC(0.209), FLOAT2MFCC(-0.487), FLOAT2MFCC(-0.247),
+      FLOAT2MFCC(-0.142), FLOAT2MFCC(-0.439), FLOAT2MFCC(0.059),
+      FLOAT2MFCC(-0.058), FLOAT2MFCC(-0.265), FLOAT2MFCC(-0.109), FLOAT2MFCC(-0.196)},
+    { FLOAT2MFCC(15.025), FLOAT2MFCC(-1.199), FLOAT2MFCC(-0.607),
+      FLOAT2MFCC(0.235), FLOAT2MFCC(-0.499), FLOAT2MFCC(-0.080),
+      FLOAT2MFCC(-0.062), FLOAT2MFCC(-0.554), FLOAT2MFCC(-0.209),
+      FLOAT2MFCC(-0.124), FLOAT2MFCC(-0.445), FLOAT2MFCC(-0.352), FLOAT2MFCC(-0.400)},
+};
+
+int
+main(int argc, char *argv[])
+{
+    static char const svspec[] = "1-12/14-25/0,13,26/27-38";
+    int32 **subvecs, i, j, k, ncep;
+    mfcc_t **in_feats, ***out_feats;
+    feat_t *fcb;
+
+    /* Test parsing of a subvector spec. */
+    subvecs = parse_subvecs(svspec);
+    TEST_ASSERT(subvecs);
+    for (i = 0; i < 12; ++i) {
+        TEST_EQUAL(subvecs[0][i], i+1);
+    }
+    for (i = 0; i < 12; ++i) {
+        TEST_EQUAL(subvecs[1][i], i+14);
+    }
+    TEST_EQUAL(subvecs[2][0], 0);
+    TEST_EQUAL(subvecs[2][1], 13);
+    TEST_EQUAL(subvecs[2][2], 26);
+    for (i = 0; i < 12; ++i) {
+        TEST_EQUAL(subvecs[3][i], i+27);
+    }
+
+    /* Create a 1s_c_d_dd feature stream and split it into subvectors. */
+    fcb = feat_init("1s_c_d_dd", CMN_NONE, 0, AGC_NONE, 1, 13);
+    TEST_ASSERT(fcb);
+    feat_set_subvecs(fcb, subvecs);
+
+    in_feats = (mfcc_t **)ckd_alloc_2d_ptr(6, 13, data, sizeof(mfcc_t));
+    out_feats = feat_array_alloc(fcb, 6);
+    TEST_ASSERT(out_feats);
+
+    ncep = 6;
+    feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
+
+    for (i = 0; i < 6; ++i) {
+        for (j = 0; j < feat_dimension1(fcb); ++j) {
+            for (k = 0; k < feat_dimension2(fcb, j); ++k) {
+                printf("%.3f ", MFCC2FLOAT(out_feats[i][j][k]));
+            }
+            printf("\n");
+        }
+        printf("\n");
+    }
+
+    feat_array_free(out_feats);
+    ckd_free(in_feats);
+    feat_free(fcb);
+
+    return 0;
+}

src/tests/libs/sphinx/test_feat/_test_feat.res

@@ +1 @@
+15.114 -1.424 -0.953 0.186 -0.656 -0.226 -0.105 -0.412 -0.024 -0.091 -0.124 -0.158 -0.197 
+14.729 -1.313 -0.892 0.140 -0.676 -0.089 -0.313 -0.422 -0.058 -0.101 -0.100 -0.128 -0.123 
+14.502 -1.351 -1.028 -0.189 -0.718 -0.139 -0.121 -0.365 -0.139 -0.154 0.041 0.009 -0.073 
+14.557 -1.676 -0.864 0.118 -0.445 -0.168 -0.069 -0.503 -0.013 0.007 -0.056 -0.075 -0.237 
+14.665 -1.498 -0.582 0.209 -0.487 -0.247 -0.142 -0.439 0.059 -0.058 -0.265 -0.109 -0.196 
+15.025 -1.199 -0.607 0.235 -0.499 -0.080 -0.062 -0.554 -0.209 -0.124 -0.445 -0.352 -0.400 
+15.114 -1.424 -0.953 0.186 -0.656 -0.226 -0.105 -0.412 -0.024 -0.091 -0.124 -0.158 -0.197 15.114 -1.424 -0.953 0.186 -0.656 -0.226 -0.105 -0.412 -0.024 -0.091 -0.124 -0.158 -0.197 14.729 -1.313 -0.892 0.140 -0.676 -0.089 -0.313 -0.422 -0.058 -0.101 -0.100 -0.128 -0.123 
+15.114 -1.424 -0.953 0.186 -0.656 -0.226 -0.105 -0.412 -0.024 -0.091 -0.124 -0.158 -0.197 14.729 -1.313 -0.892 0.140 -0.676 -0.089 -0.313 -0.422 -0.058 -0.101 -0.100 -0.128 -0.123 14.502 -1.351 -1.028 -0.189 -0.718 -0.139 -0.121 -0.365 -0.139 -0.154 0.041 0.009 -0.073 
+14.729 -1.313 -0.892 0.140 -0.676 -0.089 -0.313 -0.422 -0.058 -0.101 -0.100 -0.128 -0.123 14.502 -1.351 -1.028 -0.189 -0.718 -0.139 -0.121 -0.365 -0.139 -0.154 0.041 0.009 -0.073 14.557 -1.676 -0.864 0.118 -0.445 -0.168 -0.069 -0.503 -0.013 0.007 -0.056 -0.075 -0.237 
+14.502 -1.351 -1.028 -0.189 -0.718 -0.139 -0.121 -0.365 -0.139 -0.154 0.041 0.009 -0.073 14.557 -1.676 -0.864 0.118 -0.445 -0.168 -0.069 -0.503 -0.013 0.007 -0.056 -0.075 -0.237 14.665 -1.498 -0.582 0.209 -0.487 -0.247 -0.142 -0.439 0.059 -0.058 -0.265 -0.109 -0.196 
+14.557 -1.676 -0.864 0.118 -0.445 -0.168 -0.069 -0.503 -0.013 0.007 -0.056 -0.075 -0.237 14.665 -1.498 -0.582 0.209 -0.487 -0.247 -0.142 -0.439 0.059 -0.058 -0.265 -0.109 -0.196 15.025 -1.199 -0.607 0.235 -0.499 -0.080 -0.062 -0.554 -0.209 -0.124 -0.445 -0.352 -0.400 
+14.665 -1.498 -0.582 0.209 -0.487 -0.247 -0.142 -0.439 0.059 -0.058 -0.265 -0.109 -0.196 15.025 -1.199 -0.607 0.235 -0.499 -0.080 -0.062 -0.554 -0.209 -0.124 -0.445 -0.352 -0.400 15.025 -1.199 -0.607 0.235 -0.499 -0.080 -0.062 -0.554 -0.209 -0.124 -0.445 -0.352 -0.400 
+15.114 -1.424 -0.953 0.186 -0.656 -0.226 -0.105 -0.412 -0.024 -0.091 -0.124 -0.158 -0.197 -0.612 0.073 -0.075 -0.375 -0.062 0.087 -0.016 0.047 -0.115 -0.063 0.165 0.167 0.124 -0.172 -0.363 0.028 -0.022 0.231 -0.079 0.244 -0.081 0.045 0.108 0.044 0.053 -0.114 
+14.729 -1.313 -0.892 0.140 -0.676 -0.089 -0.313 -0.422 -0.058 -0.101 -0.100 -0.128 -0.123 -0.557 -0.252 0.089 -0.068 0.211 0.058 0.036 -0.091 0.011 0.098 0.068 0.083 -0.040 0.163 -0.147 0.446 0.398 0.231 -0.108 -0.021 -0.074 0.198 0.096 -0.306 -0.118 -0.123 
+14.502 -1.351 -1.028 -0.189 -0.718 -0.139 -0.121 -0.365 -0.139 -0.154 0.041 0.009 -0.073 -0.449 -0.074 0.371 0.023 0.169 -0.021 -0.037 -0.027 0.083 0.033 -0.141 0.049 0.001 0.853 0.366 0.196 0.163 -0.034 -0.049 0.215 -0.041 -0.162 -0.121 -0.413 -0.307 -0.237 
+14.557 -1.676 -0.864 0.118 -0.445 -0.168 -0.069 -0.503 -0.013 0.007 -0.056 -0.075 -0.237 0.296 0.114 0.285 0.095 0.177 0.009 0.251 -0.132 -0.151 -0.023 -0.345 -0.224 -0.277 0.972 0.226 0.050 0.401 0.050 0.080 0.096 -0.162 -0.153 -0.003 -0.345 -0.410 -0.328 
+14.665 -1.498 -0.582 0.209 -0.487 -0.247 -0.142 -0.439 0.059 -0.058 -0.265 -0.109 -0.196 0.523 0.152 0.421 0.424 0.219 0.059 0.059 -0.189 -0.070 0.030 -0.486 -0.361 -0.327 0.172 0.363 -0.028 0.022 -0.231 0.079 -0.244 0.081 -0.045 -0.108 -0.044 -0.053 0.114 
+15.025 -1.199 -0.607 0.235 -0.499 -0.080 -0.062 -0.554 -0.209 -0.124 -0.445 -0.352 -0.400 0.468 0.477 0.257 0.117 -0.054 0.088 0.007 -0.051 -0.196 -0.131 -0.389 -0.277 -0.163 -0.163 0.147 -0.446 -0.398 -0.231 0.108 0.021 0.074 -0.198 -0.096 0.306 0.118 0.123 

src/tests/libs/sphinx/test_feat/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tests libs sphinx test_feat ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseLibraryHeaders sphinx ;
+UseLibraryHeaders sphinx/libsphinxbase ;
+
+SimpleTest test_feat : test_feat.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_feat_fe : test_feat_fe.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_feat_live : test_feat_live.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;
+SimpleTest test_subvq : test_subvq.c : libsphinxfe.a libsphinxfeat.a libsphinxlm.a libsphinxutil.a ;

src/tests/libs/sphinx/test_feat/test_feat_fe.c

@@ +1 @@
+#include <stdio.h>
+#include <errno.h>
+
+#include "fe.h"
+#include "feat.h"
+#include "cmd_ln.h"
+#include "ckd_alloc.h"
+
+#include "test_macros.h"
+
+#ifndef TESTDATADIR
+#define TESTDATADIR "../regression"
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+    static const arg_t fe_args[] = {
+        waveform_to_cepstral_command_line_macro(),
+        { NULL, 0, NULL, NULL }
+    };
+    FILE *raw;
+    cmd_ln_t *config;
+    fe_t *fe;
+    feat_t *fcb;
+    int16 buf[2048];
+    mfcc_t **cepbuf, **cptr;
+    mfcc_t ***featbuf1, ***featbuf2, ***fptr;
+    size_t nsamp;
+    int32 total_frames, ncep, nfr, i;
+
+    if ((raw = fopen(TESTDATADIR "/chan3.raw", "rb")) == NULL) {
+        perror(TESTDATADIR "/chan3.raw");
+        return 1;
+    }
+
+    config = cmd_ln_parse_r(NULL, fe_args, argc, argv, FALSE);
+    fe = fe_init_auto_r(config);
+    fcb = feat_init("1s_c_d_dd", CMN_NONE, FALSE, AGC_NONE,
+            TRUE, fe_get_output_size(fe));
+
+    /* Determine how much data and how many MFCC frames we need. */
+    fseek(raw, 0, SEEK_END);
+    nsamp = ftell(raw) / sizeof(int16);
+    fe_process_frames(fe, NULL, &nsamp, NULL, &total_frames);
+    printf("%d samples, %d + 1 frames\n", nsamp, total_frames);
+    total_frames++; /* For the possible fe_end_utt() frame */
+    cepbuf = ckd_calloc_2d(total_frames + 1, fe_get_output_size(fe), sizeof(**cepbuf));
+    fseek(raw, 0, SEEK_SET);
+
+    /* Pay close attention, kids.  This is how you use fe_process_frames(). */
+    fe_start_utt(fe);
+    cptr = cepbuf;
+    nfr = total_frames;
+    while ((nsamp = fread(buf, sizeof(int16), 2048, raw)) > 0) {
+        int16 const *bptr = buf;
+        while (nsamp) {
+            int32 ncep = nfr;
+            fe_process_frames(fe, &bptr, &nsamp, cptr, &ncep);
+            cptr += ncep;
+            nfr -= ncep;
+        }
+    }
+    fe_end_utt(fe, *cptr, &nfr);
+
+    /* Now test some feature extraction problems. */
+    featbuf1 = feat_array_alloc(fcb, total_frames);
+    featbuf2 = feat_array_alloc(fcb, total_frames);
+
+    /* Whole utterance: canonical, assumed to be correct. */
+    ncep = total_frames;
+    TEST_EQUAL(total_frames,
+           feat_s2mfc2feat_live(fcb, cepbuf,
+                    &ncep, TRUE, TRUE,
+                    featbuf1));
+    TEST_EQUAL(ncep, total_frames);
+
+    /* Process one frame at a time. */
+    cptr = cepbuf;
+    fptr = featbuf2;
+    ncep = 1;
+    nfr = feat_s2mfc2feat_live(fcb, cptr, &ncep, TRUE, FALSE, fptr);
+    TEST_EQUAL(nfr, 0); /* Not possible to make any frames yet. */
+    TEST_EQUAL(ncep, 1); /* But we shold have consumed one. */
+    cptr += ncep;
+    for (i = 1; i < total_frames - 1; ++i) {
+        ncep = 1;
+        nfr = feat_s2mfc2feat_live(fcb, cptr, &ncep, FALSE, FALSE, fptr);
+        cptr += ncep;
+        fptr += nfr;
+    }
+    nfr = feat_s2mfc2feat_live(fcb, cptr, &ncep, FALSE, TRUE, fptr);
+    TEST_EQUAL(nfr, 4); /* This should have dumped the trailing window. */
+    TEST_EQUAL(ncep, 1); /* And only consumed one frame of MFCCs. */
+    cptr += ncep;
+    fptr += nfr;
+    /* Verify that we actually got the correct number of frames. */
+    TEST_EQUAL(cptr - cepbuf, total_frames);
+    TEST_EQUAL(fptr - featbuf2, total_frames);
+
+    /* Now verify that the results are equal. */
+    for (i = 0; i < total_frames; ++i) {
+        int32 j;
+        printf("%-4d ", i);
+        for (j = 0; j < feat_dimension(fcb); ++j) {
+            TEST_EQUAL_FLOAT(featbuf1[i][0][j], featbuf2[i][0][j]);
+        }
+        if (i % 10 == 9)
+            printf("\n");
+    }
+    printf("\n");
+
+    /* Process large chunks of frames at once, so as to exceed the
+     * internal ringbuffer size in feat_s2mfc2feat_live(). */
+    cptr = cepbuf;
+    fptr = featbuf2;
+    ncep = total_frames;
+    nfr = feat_s2mfc2feat_live(fcb, cptr, &ncep, TRUE, FALSE, fptr);
+    TEST_ASSERT(ncep != nfr);
+    cptr += ncep;
+    fptr += nfr;
+    ncep = total_frames - ncep;
+    while (ncep) {
+        int32 tmp_ncep;
+        tmp_ncep = ncep;
+        nfr = feat_s2mfc2feat_live(fcb, cptr, &tmp_ncep, FALSE, FALSE, fptr);
+        cptr += tmp_ncep;
+        fptr += nfr;
+        ncep -= tmp_ncep;
+    }
+    nfr = feat_s2mfc2feat_live(fcb, cptr, &ncep, FALSE, TRUE, fptr);
+    cptr += ncep;
+    fptr += nfr;
+    TEST_EQUAL(cptr - cepbuf, total_frames);
+    TEST_EQUAL(fptr - featbuf2, total_frames);
+
+    /* Now verify that the results are equal. */
+    for (i = 0; i < total_frames; ++i) {
+        int32 j;
+        printf("%-4d ", i);
+        for (j = 0; j < feat_dimension(fcb); ++j)
+            TEST_EQUAL_FLOAT(featbuf1[i][0][j], featbuf2[i][0][j]);
+        if (i % 10 == 9)
+            printf("\n");
+    }
+    printf("\n");
+
+    fclose(raw);
+    fe_free(fe);
+    feat_array_free(featbuf1);
+    feat_array_free(featbuf2);
+    feat_free(fcb);
+    ckd_free_2d(cepbuf);
+
+    return 0;
+}

src/tests/libs/sphinx/test_feat/test_macros.h

@@ +1 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "logmath.h"
+
+#define EPSILON 0.01
+#define TEST_ASSERT(x) if (!(x)) { fprintf(stderr, "FAIL: %s\n", #x); exit(1); }
+#define TEST_EQUAL(a,b) TEST_ASSERT((a) == (b))
+#define TEST_EQUAL_FLOAT(a,b) TEST_ASSERT(fabs((a) - (b)) < EPSILON)
+#define LOG_EPSILON 20
+#define TEST_EQUAL_LOG(a,b) TEST_ASSERT(abs((a) - (b)) < LOG_EPSILON)

src/tests/libs/sphinx/test_feat/_test_feat.test

@@ +1 @@
+#!/bin/sh
+. ../testfuncs.sh
+
+set -e
+./test_feat > _test_feat.out
+compare_table feat _test_feat.out $tests/unit/test_feat/_test_feat.res
+rm -f _test_feat.out

src/tests/libs/sphinx/test_feat/test_feat_live.c

@@ +1 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "feat.h"
+#include "ckd_alloc.h"
+#include "test_macros.h"
+
+const mfcc_t data[6][13] = {
+    { FLOAT2MFCC(15.114), FLOAT2MFCC(-1.424), FLOAT2MFCC(-0.953),
+      FLOAT2MFCC(0.186), FLOAT2MFCC(-0.656), FLOAT2MFCC(-0.226),
+      FLOAT2MFCC(-0.105), FLOAT2MFCC(-0.412), FLOAT2MFCC(-0.024),
+      FLOAT2MFCC(-0.091), FLOAT2MFCC(-0.124), FLOAT2MFCC(-0.158), FLOAT2MFCC(-0.197)},
+    { FLOAT2MFCC(14.729), FLOAT2MFCC(-1.313), FLOAT2MFCC(-0.892),
+      FLOAT2MFCC(0.140), FLOAT2MFCC(-0.676), FLOAT2MFCC(-0.089),
+      FLOAT2MFCC(-0.313), FLOAT2MFCC(-0.422), FLOAT2MFCC(-0.058),
+      FLOAT2MFCC(-0.101), FLOAT2MFCC(-0.100), FLOAT2MFCC(-0.128), FLOAT2MFCC(-0.123)},
+    { FLOAT2MFCC(14.502), FLOAT2MFCC(-1.351), FLOAT2MFCC(-1.028),
+      FLOAT2MFCC(-0.189), FLOAT2MFCC(-0.718), FLOAT2MFCC(-0.139),
+      FLOAT2MFCC(-0.121), FLOAT2MFCC(-0.365), FLOAT2MFCC(-0.139),
+      FLOAT2MFCC(-0.154), FLOAT2MFCC(0.041), FLOAT2MFCC(0.009), FLOAT2MFCC(-0.073)},
+    { FLOAT2MFCC(14.557), FLOAT2MFCC(-1.676), FLOAT2MFCC(-0.864),
+      FLOAT2MFCC(0.118), FLOAT2MFCC(-0.445), FLOAT2MFCC(-0.168),
+      FLOAT2MFCC(-0.069), FLOAT2MFCC(-0.503), FLOAT2MFCC(-0.013),
+      FLOAT2MFCC(0.007), FLOAT2MFCC(-0.056), FLOAT2MFCC(-0.075), FLOAT2MFCC(-0.237)},
+    { FLOAT2MFCC(14.665), FLOAT2MFCC(-1.498), FLOAT2MFCC(-0.582),
+      FLOAT2MFCC(0.209), FLOAT2MFCC(-0.487), FLOAT2MFCC(-0.247),
+      FLOAT2MFCC(-0.142), FLOAT2MFCC(-0.439), FLOAT2MFCC(0.059),
+      FLOAT2MFCC(-0.058), FLOAT2MFCC(-0.265), FLOAT2MFCC(-0.109), FLOAT2MFCC(-0.196)},
+    { FLOAT2MFCC(15.025), FLOAT2MFCC(-1.199), FLOAT2MFCC(-0.607),
+      FLOAT2MFCC(0.235), FLOAT2MFCC(-0.499), FLOAT2MFCC(-0.080),
+      FLOAT2MFCC(-0.062), FLOAT2MFCC(-0.554), FLOAT2MFCC(-0.209),
+      FLOAT2MFCC(-0.124), FLOAT2MFCC(-0.445), FLOAT2MFCC(-0.352), FLOAT2MFCC(-0.400)},
+};
+
+int
+main(int argc, char *argv[])
+{
+    feat_t *fcb;
+    mfcc_t **in_feats, ***out_feats, ***out_feats2, ***optr;
+    int32 i, j, ncep, nfr, nfr1, nfr2;
+
+    in_feats = (mfcc_t **)ckd_alloc_2d_ptr(6, 13, data, sizeof(mfcc_t));
+    out_feats = (mfcc_t ***)ckd_calloc_3d(8, 1, 39, sizeof(mfcc_t));
+    /* Test 1s_c_d_dd features */
+    fcb = feat_init("1s_c_d_dd", CMN_NONE, 0, AGC_NONE, 1, 13);
+    ncep = 6;
+    nfr1 = feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
+    printf("Processed %d input %d output frames\n", ncep, nfr1);
+    for (i = 0; i < nfr1; ++i) {
+        printf("%d: ", i);
+        for (j = 0; j < 39; ++j) {
+            printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
+        }
+        printf("\n");
+    }
+    feat_free(fcb);
+
+    /* Test in "live" mode. */
+    fcb = feat_init("1s_c_d_dd", CMN_NONE, 0, AGC_NONE, 1, 13);
+    optr = out_feats2 = (mfcc_t ***)ckd_calloc_3d(8, 1, 39, sizeof(mfcc_t));
+    nfr2 = 0;
+    ncep = 2;
+    nfr = feat_s2mfc2feat_live(fcb, in_feats, &ncep, TRUE, FALSE, optr);
+    printf("Processed %d input %d output frames\n", ncep, nfr);
+    nfr2 += nfr;
+    for (i = 0; i < nfr; ++i) {
+        printf("%d: ", i);
+        for (j = 0; j < 39; ++j) {
+            printf("%.3f ", MFCC2FLOAT(optr[i][0][j]));
+        }
+        printf("\n");
+    }
+    optr += nfr;
+
+    ncep = 2;
+    nfr = feat_s2mfc2feat_live(fcb, in_feats + 2, &ncep, FALSE, FALSE, optr);
+    nfr2 += nfr;
+    printf("Processed %d input %d output frames\n", ncep, nfr);
+    for (i = 0; i < nfr; ++i) {
+        printf("%d: ", i);
+        for (j = 0; j < 39; ++j) {
+            printf("%.3f ", MFCC2FLOAT(optr[i][0][j]));
+        }
+        printf("\n");
+    }
+    optr += nfr;
+
+    ncep = 2;
+    nfr = feat_s2mfc2feat_live(fcb, in_feats + 4, &ncep, FALSE, TRUE, optr);
+    nfr2 += nfr;
+    printf("Processed %d input %d output frames\n", ncep, nfr);
+    for (i = 0; i < nfr; ++i) {
+        printf("%d: ", i);
+        for (j = 0; j < 39; ++j) {
+            printf("%.3f ", MFCC2FLOAT(optr[i][0][j]));
+        }
+        printf("\n");
+    }
+    optr += nfr;
+    feat_free(fcb);
+
+    TEST_EQUAL(nfr1, nfr2);
+    for (i = 0; i < nfr1; ++i) {
+        for (j = 0; j < 39; ++j) {
+            TEST_EQUAL(out_feats[i][0][j], out_feats2[i][0][j]);
+        }
+    }
+    ckd_free_3d(out_feats2);
+    ckd_free_3d(out_feats);
+    ckd_free(in_feats);
+
+    return 0;
+}