static void
test_set_search()
{
cmd_ln_t *config = default_config();
ps_decoder_t *ps = ps_init(config);
ps_search_iter_t *itor;
jsgf_t *jsgf = jsgf_parse_file(DATADIR "/goforward.gram", NULL);
fsg_model_t *fsg = jsgf_build_fsg(jsgf,
jsgf_get_rule(jsgf, "goforward.move"),
ps->lmath, cmd_ln_int32_r(config, "-lw"));
TEST_ASSERT(!ps_set_fsg(ps, "goforward", fsg));
fsg_model_free(fsg);
TEST_ASSERT(!ps_set_jsgf_file(ps, "goforward_other", DATADIR "/goforward.gram"));
ngram_model_t *lm = ngram_model_read(config, DATADIR "/tidigits/lm/tidigits.lm.dmp",
NGRAM_AUTO, ps->lmath);
TEST_ASSERT(!ps_set_lm(ps, "tidigits", lm));
ngram_model_free(lm);
TEST_ASSERT(!ps_set_search(ps, "tidigits"));
TEST_ASSERT(!ps_set_search(ps, "goforward"));
itor = ps_search_iter(ps);
TEST_EQUAL(0, strcmp("goforward_other", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(0, strcmp("tidigits", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(0, strcmp("goforward", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(0, strcmp("phone_loop", ps_search_iter_val(itor)));
itor = ps_search_iter_next(itor);
TEST_EQUAL(NULL, itor);
TEST_ASSERT(!ps_start_utt(ps));
TEST_ASSERT(!ps_end_utt(ps));
ps_free(ps);
cmd_ln_free_r(config);
}
KAGUYA_TEST_FUNCTION_DEF(variadic_function_test)(kaguya::State& state)
{
state["Vari"].setClass(kaguya::ClassMetatable<VariFoo>()
.addConstructor()
.addConstructorVariadicArg()
.addMember("variadicfun", &VariFoo::variadic_arg_func)
);
state("var = Vari.new()");
state("var:variadicfun('hanaregumi','hana-uta',5)");;
VariFoo* ptr = state["var"];
TEST_CHECK(ptr);
TEST_EQUAL(ptr->args[0].get<std::string>(), "hanaregumi");
TEST_EQUAL(ptr->args[1].get<std::string>(), "hana-uta");
TEST_EQUAL(ptr->args[2].get<int>(), 5);
bool typevalid;
TEST_EQUAL(ptr->args[0].get<std::string>(typevalid), "hanaregumi");
TEST_CHECK(typevalid);
TEST_EQUAL(ptr->args[1].get<std::string>(typevalid), "hana-uta");
TEST_CHECK(typevalid);
TEST_EQUAL(ptr->args[2].get<int>(typevalid), 5);
TEST_CHECK(typevalid);
TEST_EQUAL(ptr->args[2].get<std::string>(typevalid), "5");
TEST_CHECK(typevalid);
ptr->args[2].get<std::string>(typevalid, false);
TEST_CHECK(!typevalid);
state("var = Vari.new('abc')");
ptr = state["var"];
TEST_CHECK(ptr);
TEST_EQUAL(ptr->args[0].get<std::string>(), "abc");
state("var = Vari.new('abc', 'def')");
ptr = state["var"];
TEST_CHECK(ptr);
TEST_EQUAL(ptr->args[0].get<std::string>(), "abc");
TEST_EQUAL(ptr->args[1].get<std::string>(), "def");
}
KAGUYA_TEST_FUNCTION_DEF(arg_class_ref)(kaguya::State& state)
{
state["Foo"].setClass(kaguya::ClassMetatable<Foo>()
.addMember("setBar", &Foo::setBar)
);
Foo foo;
state["reffun"] = kaguya::function(reffun);
state["reffun"](kaguya::standard::ref(foo));
TEST_EQUAL(foo.bar, "BarBar");
}
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];
TEST_EQUAL(0, strcmp("quux.argh", path2basename(testname)));
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;
}
bool GetHashKeyTest(void)
{
SimpleHashTable<> table;
table.mTableSize = 3;
table.GetHashKey();
TEST_EQUAL(table.mHashKey, 2);
table.mTableSize = 10;
table.GetHashKey();
TEST_EQUAL(table.mHashKey, 7);
table.mTableSize = 100;
table.GetHashKey();
TEST_EQUAL(table.mHashKey, 97);
table.mTableSize = 30;
table.GetHashKey();
TEST_EQUAL(table.mHashKey, 29);
return true;
}
bool create_account(int soft, int hard)
{
std::string errs;
std::auto_ptr<Configuration> config(
Configuration::LoadAndVerify
("testfiles/bbstored.conf", &BackupConfigFileVerify, errs));
BackupStoreAccountsControl control(*config);
Logger::LevelGuard guard(Logging::GetConsole(), Log::WARNING);
int result = control.CreateAccount(0x01234567, 0, soft, hard, 0);
TEST_EQUAL(0, result);
return (result == 0);
}
int
main(int argc, char *argv[])
{
int nsamps;
int16 *data;
data = bio_read_wavfile(TESTDATADIR, "chan3", ".wav", 44, FALSE, &nsamps);
TEST_EQUAL(230108, nsamps);
ckd_free(data);
return 0;
}
void test(const mie::BitVector& bv)
{
// printf("----------------------\n");
//bv.put();
// printf("bv.blockSize=%d, bitSize=%d\n", (int)bv.getBlockSize(), (int)bv.size());
T s(bv.getBlock(), bv.getBlockSize());
uint64_t num = 0;
for (size_t i = 0; i < bv.size(); i++) {
if (bv.get(i)) num++;
uint64_t rank = s.rank1(i);
TEST_EQUAL(rank, num);
}
}
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_probv(model, "daines", "huggins", "david", NULL),
-9452);
TEST_EQUAL_LOG(ngram_probv(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_probv(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);
}
void pop_returns_element_pushed(char const * test_name)
{
ACE_Notification_Queue queue;
Event_Handler eh1(1);
Event_Handler eh2(2);
Event_Handler eh3(2);
int result = queue.push_new_notification(
ACE_Notification_Buffer(&eh1,
ACE_Event_Handler::READ_MASK));
TEST_ASSERT(result == 1, "push[1] should return 1");
result = queue.push_new_notification(
ACE_Notification_Buffer(&eh2,
ACE_Event_Handler::WRITE_MASK));
TEST_ASSERT(result == 0, "push[2] should return 0");
result = queue.push_new_notification(
ACE_Notification_Buffer(&eh3,
ACE_Event_Handler::READ_MASK |
ACE_Event_Handler::WRITE_MASK));
TEST_ASSERT(result == 0, "push[3] should return 0");
ACE_Notification_Buffer current;
bool more_messages_queued;
ACE_Notification_Buffer next;
result = queue.pop_next_notification(current, more_messages_queued, next);
TEST_ASSERT(result == 1, "pop[0] should return 1");
TEST_ASSERT(more_messages_queued, "pop[0] should have more messages");
TEST_EQUAL(current.eh_, &eh1, "Wrong handler extracted");
TEST_EQUAL(current.mask_, ACE_Event_Handler::READ_MASK,
"Wrong mask extracted");
result = queue.pop_next_notification(current, more_messages_queued, next);
TEST_ASSERT(result == 1, "pop[1] should return 1");
TEST_ASSERT(more_messages_queued, "pop[1] should have more messages");
TEST_EQUAL(current.eh_, &eh2, "Wrong handler extracted");
TEST_EQUAL(current.mask_, ACE_Event_Handler::WRITE_MASK,
"Wrong mask extracted");
result = queue.pop_next_notification(current, more_messages_queued, next);
TEST_ASSERT(result == 1, "pop[2] should return 1");
TEST_ASSERT(!more_messages_queued, "pop[2] should not have more messages");
TEST_EQUAL(current.eh_, &eh3, "Wrong handler extracted");
TEST_EQUAL(current.mask_, ACE_Event_Handler::READ_MASK |
ACE_Event_Handler::WRITE_MASK,
"Wrong mask extracted");
more_messages_queued = true;
result = queue.pop_next_notification(current, more_messages_queued, next);
TEST_ASSERT(result == 0, "pop[3] should return 0");
TEST_ASSERT(!more_messages_queued, "pop[3] should not have more messages");
}
int main(int argc, char *argv[]) {
TEST_NAME();
auto q1 = Quaternion(1,2,3,0);
auto q2 = Quaternion(1,1,1,1);
auto q3 = q1 + q2;
TEST_EQUAL(q3, Quaternion(2,3,4,1), "quaternion addition");
std::cout << "q1: " << q1 << std::endl;
std::cout << "q2: " << q2 << std::endl;
std::cout << "q1 * q2 = " << q1 * q2 << std::endl;
TEST_EQUAL(q1*q2, 6.0, "scalar multiplication");
std::cout << "q1 x q2 = " << q1 % q2 << std::endl;
TEST_EQUAL(q1%q2, Quaternion(-4,6,2,0), "product multiplication");
TEST_EQUAL(q1.conj(), Quaternion(1,-2,-3,0), "Conjugate");
TEST_EQUAL(q2.magnitude_real(), 2, "Real Magnitude");
TEST_EQUAL(q2.magnitude(), 4, "Magnitude");
auto q4 = Quaternion(5,3,2,2);
std::cout << "q4-unit: " << q4.unit() << std::endl;
std::cout << "q4-inverse: " << q4.inv() << std::endl;
auto q5 = Quaternion(4,5,1,2);
auto q6 = q5 % q1;
q5 %= q1;
TEST_EQUAL(q5, q6, "testing product2");
auto q7 = Quaternion();
q7[0] = 1;
q7[1] = 2;
q7[2] = q7[0] + q7[1];
q7[3] = q7[0] + q7[2];
std::cout << "q7: " << q7 << std::endl;
TEST_EQUAL(q7, Quaternion(1,2,3,4), "testing assignment");
return 0;
}
KAGUYA_TEST_FUNCTION_DEF(vector_from_table)(kaguya::State& state)
{
state("arraytablefn =function() return {32,1,2,4,8,16} end");
std::vector<int> b = state["arraytablefn"]();
TEST_EQUAL(b.size(), 6);
TEST_EQUAL(b[0], 32);
TEST_EQUAL(b[1], 1);
TEST_EQUAL(b[2], 2);
TEST_EQUAL(b[3], 4);
TEST_EQUAL(b[4], 8);
TEST_EQUAL(b[5], 16);
TEST_CHECK(state["arraytablefn"]().typeTest<std::vector<int> >());
}
int test_ai_div_unsigned_by_subtraction__zero_result(void)
{
TEST_HEADER();
ArbInt *A = AI_NewArbInt_FromLong(5);
ArbInt *B = AI_NewArbInt_FromLong(12);
ArbInt *remainder;
ArbInt *expected_div;
ArbInt *expected_mod;
ArbInt *C = ai_div_unsigned_by_subtraction(A, B, &remainder);
expected_div = AI_NewArbInt_FromLong(0);
expected_mod = AI_NewArbInt_FromLong(5);
TEST_EQUAL(C, expected_div, AI_Equal, AI_ToString);
TEST_EQUAL(remainder, expected_mod, AI_Equal, AI_ToString);
AI_FreeArbInt(A);
AI_FreeArbInt(B);
AI_FreeArbInt(C);
AI_FreeArbInt(remainder);
AI_FreeArbInt(expected_div);
AI_FreeArbInt(expected_mod);
TEST_FOOTER();
}
void verify(F1 f1, F2 f2, const std::basic_string<C>& str, const Key& key)
{
f1.set(str, key);
f2.set(str, key);
typename F1::type p = f1.begin();
typename F1::type end = f1.end();
for (;;) {
typename F1::type q1 = f1.find(p);
typename F2::type q2 = f2.find(p);
TEST_EQUAL(q1, q2);
if (q1 == end) break;
p = q1 + 1;
}
}
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;
err_set_callback(err_threaded_cb, NULL);
pthread_key_create(&logfp_index, NULL);
pthread_setspecific(logfp_index, (void*)stderr);
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);
/* total number of frames in audio file is 1436, but there are only 1290 voiced */
TEST_EQUAL(0, strcmp(line, "INFO: test_tls_log.c(61): nfr = 1290"));
}
fclose(logfh);
}
cmd_ln_free_r(config);
return 0;
}
bool CheckKeyTest(void)
{
SimpleHashTable<> h(100);
h.Insert(10003, 1);
h.Insert(123123, 21312);
bool re;
int value;
re = h.CheckKey(10003, value);
TEST_EQUAL(re, true);
TEST_EQUAL(value, 1);
re = h.CheckKey(10000, value);
TEST_EQUAL(re, false);
re = h.CheckKey(123123, value);
TEST_EQUAL(re, true);
TEST_EQUAL(value, 21312);
h.RemoveKey(123123);
re = h.CheckKey(123123, value);
TEST_EQUAL(re, false);
return true;
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
ps_search_t *ngs, *pls;
clock_t c;
int32 score;
int i;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-lm", MODELDIR "/lm/en_US/wsj0vp.5000.DMP",
"-dict", MODELDIR "/lm/en_US/cmu07a.dic",
"-fwdtree", "yes",
"-fwdflat", "no",
"-bestpath", "no",
"-pl_window", "6",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
ngs = ps->search;
pls = ps->phone_loop;
acmod = ps->acmod;
setbuf(stdout, NULL);
c = clock();
for (i = 0; i < 5; ++i) {
FILE *rawfh;
int16 buf[2048];
size_t nread;
int16 const *bptr;
int nfr, n_searchfr;
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
ps_search_start(ngs);
ps_search_start(pls);
n_searchfr = 0;
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
ps_search_step(pls, n_searchfr);
if (n_searchfr >= 6)
ps_search_step(ngs, n_searchfr - 6);
acmod_advance(acmod);
++n_searchfr;
}
}
}
for (nfr = n_searchfr - 6; nfr < n_searchfr; ++nfr) {
ps_search_step(ngs, nfr);
}
ps_search_finish(pls);
ps_search_finish(ngs);
printf("%s\n", ps_search_hyp(ngs, &score));
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
}
printf("%s\n", ps_search_hyp(ngs, &score));
TEST_EQUAL(0, strcmp("go forward ten years", ps_search_hyp(ngs, &score)));
c = clock() - c;
printf("5 * fwdtree search in %.2f sec\n",
(double)c / CLOCKS_PER_SEC);
ps_free(ps);
return 0;
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
fsg_search_t *fsgs;
ps_lattice_t *dag;
ps_seg_t *seg;
int32 score;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", DATADIR "/tidigits/hmm",
"-fsg", DATADIR "/tidigits/lm/tidigits.fsg",
"-dict", DATADIR "/tidigits/lm/tidigits.dic",
"-bestpath", "no",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
fsgs = (fsg_search_t *)ps->search;
acmod = ps->acmod;
setbuf(stdout, NULL);
{
FILE *rawfh;
int16 buf[2048];
size_t nread;
int16 const *bptr;
char const *hyp;
int nfr;
TEST_ASSERT(rawfh = fopen(DATADIR "/numbers.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
fsg_search_start(ps_search_base(fsgs));
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
fsg_search_step(ps_search_base(fsgs),
acmod->output_frame);
acmod_advance(acmod);
}
}
}
fsg_search_finish(ps_search_base(fsgs));
hyp = fsg_search_hyp(ps_search_base(fsgs), &score, NULL);
printf("FSG: %s (%d)\n", hyp, score);
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
}
for (seg = ps_seg_iter(ps); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
int32 post, lscr, ascr, lback;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
post = ps_seg_prob(seg, &ascr, &lscr, &lback);
printf("%s (%d:%d) P(w|o) = %f ascr = %d lscr = %d lback = %d\n", word, sf, ef,
logmath_exp(ps_get_logmath(ps), post), ascr, lscr, lback);
}
/* Now get the DAG and play with it. */
dag = ps_get_lattice(ps);
ps_lattice_write(dag, "test_fsg3.lat");
printf("BESTPATH: %s\n",
ps_lattice_hyp(dag, ps_lattice_bestpath(dag, NULL, 1.0, 15.0)));
ps_lattice_posterior(dag, NULL, 15.0);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
ngram_search_t *ngs;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/en-us/en-us",
"-lm", MODELDIR "/en-us/en-us.lm.dmp",
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
"-fwdtree", "no",
"-fwdflat", "yes",
"-bestpath", "no",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
ngs = (ngram_search_t *)ps->search;
acmod = ps->acmod;
setbuf(stdout, NULL);
{
FILE *rawfh, *senfh;
int16 buf[2048];
size_t nread;
int16 const *bptr;
int nfr;
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
TEST_ASSERT(senfh = fopen("goforward.sen", "wb"));
TEST_EQUAL(0, acmod_set_senfh(acmod, senfh));
ngram_fwdflat_start(ngs);
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
ngram_fwdflat_search(ngs, acmod->output_frame);
acmod_advance(acmod);
}
}
}
ngram_fwdflat_finish(ngs);
printf("%s\n",
ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL, NULL)));
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
TEST_EQUAL(0, strcmp("go forward ten meters",
ngram_search_bp_hyp(ngs,
ngram_search_find_exit(ngs, -1, NULL, NULL))));
TEST_EQUAL(0, acmod_set_senfh(acmod, NULL));
TEST_EQUAL(0, acmod_start_utt(acmod));
TEST_ASSERT(senfh = fopen("goforward.sen", "rb"));
TEST_EQUAL(0, acmod_set_insenfh(acmod, senfh));
ngram_fwdflat_start(ngs);
while ((nfr = acmod_read_scores(acmod)) > 0) {
while (acmod->n_feat_frame > 0) {
ngram_fwdflat_search(ngs, acmod->output_frame);
acmod_advance(acmod);
}
}
ngram_fwdflat_finish(ngs);
printf("%s\n",
ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL, NULL)));
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
TEST_EQUAL(0, strcmp("go forward ten meters",
ngram_search_bp_hyp(ngs,
ngram_search_find_exit(ngs, -1, NULL, NULL))));
fclose(senfh);
}
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
acmod_t *acmod;
logmath_t *lmath;
cmd_ln_t *config;
FILE *rawfh;
int16 *buf;
int16 const *bptr;
mfcc_t **cepbuf, **cptr;
size_t nread, nsamps;
int nfr;
int frame_counter;
int bestsen1[270];
lmath = logmath_init(1.0001, 0, 0);
config = cmd_ln_init(NULL, ps_args(), TRUE,
"-featparams", MODELDIR "/hmm/en_US/hub4wsj_sc_8k/feat.params",
"-mdef", MODELDIR "/hmm/en_US/hub4wsj_sc_8k/mdef",
"-mean", MODELDIR "/hmm/en_US/hub4wsj_sc_8k/means",
"-var", MODELDIR "/hmm/en_US/hub4wsj_sc_8k/variances",
"-tmat", MODELDIR "/hmm/en_US/hub4wsj_sc_8k/transition_matrices",
"-sendump", MODELDIR "/hmm/en_US/hub4wsj_sc_8k/sendump",
"-compallsen", "true",
"-cmn", "prior",
"-tmatfloor", "0.0001",
"-mixwfloor", "0.001",
"-varfloor", "0.0001",
"-mmap", "no",
"-topn", "4",
"-ds", "1",
"-input_endian", "little",
"-samprate", "16000", NULL);
TEST_ASSERT(config);
TEST_ASSERT(acmod = acmod_init(config, lmath, NULL, NULL));
cmn_prior_set(acmod->fcb->cmn_struct, prior);
nsamps = 2048;
frame_counter = 0;
buf = ckd_calloc(nsamps, sizeof(*buf));
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
E_INFO("Incremental(2048):\n");
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), nsamps, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0 || nread > 0) {
int16 const *senscr;
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
senscr = acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
TEST_EQUAL(frame_counter, frame_idx);
if (frame_counter < 190)
bestsen1[frame_counter] = best_score;
++frame_counter;
frame_idx = -1;
}
}
}
TEST_EQUAL(0, acmod_end_utt(acmod));
nread = 0;
{
int16 const *senscr;
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
senscr = acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
bestsen1[frame_counter] = best_score;
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
/* Now try to process the whole thing at once. */
E_INFO("Whole utterance:\n");
cmn_prior_set(acmod->fcb->cmn_struct, prior);
nsamps = ftell(rawfh) / sizeof(*buf);
clearerr(rawfh);
fseek(rawfh, 0, SEEK_SET);
buf = ckd_realloc(buf, nsamps * sizeof(*buf));
TEST_EQUAL(nsamps, fread(buf, sizeof(*buf), nsamps, rawfh));
bptr = buf;
TEST_EQUAL(0, acmod_start_utt(acmod));
acmod_process_raw(acmod, &bptr, &nsamps, TRUE);
TEST_EQUAL(0, acmod_end_utt(acmod));
{
int16 const *senscr;
int16 best_score;
int frame_idx = -1, best_senid;
frame_counter = 0;
while (acmod->n_feat_frame > 0) {
senscr = acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
/* Now process MFCCs and make sure we get the same results. */
cepbuf = ckd_calloc_2d(frame_counter,
fe_get_output_size(acmod->fe),
sizeof(**cepbuf));
fe_start_utt(acmod->fe);
nsamps = ftell(rawfh) / sizeof(*buf);
bptr = buf;
nfr = frame_counter;
fe_process_frames(acmod->fe, &bptr, &nsamps, cepbuf, &nfr);
fe_end_utt(acmod->fe, cepbuf[frame_counter-1], &nfr);
E_INFO("Incremental(MFCC):\n");
cmn_prior_set(acmod->fcb->cmn_struct, prior);
TEST_EQUAL(0, acmod_start_utt(acmod));
cptr = cepbuf;
nfr = frame_counter;
frame_counter = 0;
while ((acmod_process_cep(acmod, &cptr, &nfr, FALSE)) > 0) {
int16 const *senscr;
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
senscr = acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
TEST_EQUAL(frame_counter, frame_idx);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
++frame_counter;
frame_idx = -1;
}
}
TEST_EQUAL(0, acmod_end_utt(acmod));
nfr = 0;
acmod_process_cep(acmod, &cptr, &nfr, FALSE);
{
int16 const *senscr;
int16 best_score;
int frame_idx = -1, best_senid;
while (acmod->n_feat_frame > 0) {
senscr = acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
TEST_EQUAL(frame_counter, frame_idx);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
++frame_counter;
frame_idx = -1;
}
}
/* Note that we have to process the whole thing again because
* !#@$@ s2mfc2feat modifies its argument (not for long) */
fe_start_utt(acmod->fe);
nsamps = ftell(rawfh) / sizeof(*buf);
bptr = buf;
nfr = frame_counter;
fe_process_frames(acmod->fe, &bptr, &nsamps, cepbuf, &nfr);
fe_end_utt(acmod->fe, cepbuf[frame_counter-1], &nfr);
E_INFO("Whole utterance (MFCC):\n");
cmn_prior_set(acmod->fcb->cmn_struct, prior);
TEST_EQUAL(0, acmod_start_utt(acmod));
cptr = cepbuf;
nfr = frame_counter;
acmod_process_cep(acmod, &cptr, &nfr, TRUE);
TEST_EQUAL(0, acmod_end_utt(acmod));
{
int16 const *senscr;
int16 best_score;
int frame_idx = -1, best_senid;
frame_counter = 0;
while (acmod->n_feat_frame > 0) {
senscr = acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
E_INFO("Rewound (MFCC):\n");
TEST_EQUAL(0, acmod_rewind(acmod));
{
int16 const *senscr;
int16 best_score;
int frame_idx = -1, best_senid;
frame_counter = 0;
while (acmod->n_feat_frame > 0) {
senscr = acmod_score(acmod, &frame_idx);
acmod_advance(acmod);
best_score = acmod_best_score(acmod, &best_senid);
E_INFO("Frame %d best senone %d score %d\n",
frame_idx, best_senid, best_score);
if (frame_counter < 190)
TEST_EQUAL_LOG(best_score, bestsen1[frame_counter]);
TEST_EQUAL(frame_counter, frame_idx);
++frame_counter;
frame_idx = -1;
}
}
/* Clean up, go home. */
ckd_free_2d(cepbuf);
fclose(rawfh);
ckd_free(buf);
acmod_free(acmod);
logmath_free(lmath);
cmd_ln_free_r(config);
return 0;
}
int
ps_decoder_test(cmd_ln_t *config, char const *sname, char const *expected)
{
ps_decoder_t *ps;
mfcc_t **cepbuf;
FILE *rawfh;
int16 *buf;
int16 const *bptr;
size_t nread;
size_t nsamps;
int32 nfr, i, score, prob;
char const *hyp;
char const *uttid;
double n_speech, n_cpu, n_wall;
ps_seg_t *seg;
TEST_ASSERT(ps = ps_init(config));
/* Test it first with pocketsphinx_decode_raw() */
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
ps_decode_raw(ps, rawfh, "goforward", -1);
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s (%s): %s (%d, %d)\n", sname, uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp(hyp, expected));
TEST_ASSERT(prob <= 0);
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
printf("%.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("%.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
/* Test it with ps_process_raw() */
clearerr(rawfh);
fseek(rawfh, 0, SEEK_END);
nsamps = ftell(rawfh) / sizeof(*buf);
fseek(rawfh, 0, SEEK_SET);
TEST_EQUAL(0, ps_start_utt(ps, NULL));
nsamps = 2048;
buf = ckd_calloc(nsamps, sizeof(*buf));
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), nsamps, rawfh);
ps_process_raw(ps, buf, nread, FALSE, FALSE);
}
TEST_EQUAL(0, ps_end_utt(ps));
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s (%s): %s (%d, %d)\n", sname, uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp(uttid, "000000000"));
TEST_EQUAL(0, strcmp(hyp, expected));
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
printf("%.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("%.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
/* Now read the whole file and produce an MFCC buffer. */
clearerr(rawfh);
fseek(rawfh, 0, SEEK_END);
nsamps = ftell(rawfh) / sizeof(*buf);
fseek(rawfh, 0, SEEK_SET);
bptr = buf = ckd_realloc(buf, nsamps * sizeof(*buf));
TEST_EQUAL(nsamps, fread(buf, sizeof(*buf), nsamps, rawfh));
fe_process_frames(ps->acmod->fe, &bptr, &nsamps, NULL, &nfr);
cepbuf = ckd_calloc_2d(nfr + 1,
fe_get_output_size(ps->acmod->fe),
sizeof(**cepbuf));
fe_start_utt(ps->acmod->fe);
fe_process_frames(ps->acmod->fe, &bptr, &nsamps, cepbuf, &nfr);
fe_end_utt(ps->acmod->fe, cepbuf[nfr], &i);
/* Decode it with process_cep() */
TEST_EQUAL(0, ps_start_utt(ps, NULL));
for (i = 0; i < nfr; ++i) {
ps_process_cep(ps, cepbuf + i, 1, FALSE, FALSE);
}
TEST_EQUAL(0, ps_end_utt(ps));
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s (%s): %s (%d, %d)\n", sname, uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp(uttid, "000000001"));
TEST_EQUAL(0, strcmp(hyp, expected));
TEST_ASSERT(prob <= 0);
for (seg = ps_seg_iter(ps, &score); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
int32 post, lscr, ascr, lback;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
post = ps_seg_prob(seg, &ascr, &lscr, &lback);
printf("%s (%d:%d) P(w|o) = %f ascr = %d lscr = %d lback = %d\n", word, sf, ef,
logmath_exp(ps_get_logmath(ps), post), ascr, lscr, lback);
TEST_ASSERT(post <= 2); // Due to numerical errors with float it sometimes could go out of 0
}
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
printf("%.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("%.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
ps_get_all_time(ps, &n_speech, &n_cpu, &n_wall);
printf("TOTAL: %.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
printf("TOTAL: %.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
fclose(rawfh);
ps_free(ps);
cmd_ln_free_r(config);
ckd_free_2d(cepbuf);
ckd_free(buf);
return 0;
}
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;
}
void const_pointerfun(const VariFoo* pointer)
{
TEST_EQUAL(pointer, 0);
}
bool test_create_account_with_account_control()
{
SETUP_TEST_S3SIMULATOR();
std::auto_ptr<Configuration> config = load_config_file(DEFAULT_BBACKUPD_CONFIG_FILE,
BackupDaemonConfigVerify);
S3BackupAccountControl control(*config);
control.CreateAccount("test", 1000, 2000);
FileStream fs("testfiles/store/subdir/" S3_INFO_FILE_NAME);
std::auto_ptr<BackupStoreInfo> info = BackupStoreInfo::Load(fs, fs.GetFileName(),
true); // ReadOnly
TEST_EQUAL(0, info->GetAccountID());
TEST_EQUAL(1, info->GetLastObjectIDUsed());
TEST_EQUAL(1, info->GetBlocksUsed());
TEST_EQUAL(0, info->GetBlocksInCurrentFiles());
TEST_EQUAL(0, info->GetBlocksInOldFiles());
TEST_EQUAL(0, info->GetBlocksInDeletedFiles());
TEST_EQUAL(1, info->GetBlocksInDirectories());
TEST_EQUAL(0, info->GetDeletedDirectories().size());
TEST_EQUAL(1000, info->GetBlocksSoftLimit());
TEST_EQUAL(2000, info->GetBlocksHardLimit());
TEST_EQUAL(0, info->GetNumCurrentFiles());
TEST_EQUAL(0, info->GetNumOldFiles());
TEST_EQUAL(0, info->GetNumDeletedFiles());
TEST_EQUAL(1, info->GetNumDirectories());
TEST_EQUAL(true, info->IsAccountEnabled());
TEST_EQUAL(true, info->IsReadOnly());
TEST_EQUAL(0, info->GetClientStoreMarker());
TEST_EQUAL("test", info->GetAccountName());
FileStream root_stream("testfiles/store/subdir/dirs/0x1.dir");
BackupStoreDirectory root_dir(root_stream);
TEST_EQUAL(0, root_dir.GetNumberOfEntries());
TEARDOWN_TEST_S3SIMULATOR();
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
ngram_search_t *ngs;
clock_t c;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-lm", MODELDIR "/lm/en_US/wsj0vp.5000.DMP",
"-dict", MODELDIR "/lm/en_US/cmu07a.dic",
"-fwdtree", "no",
"-fwdflat", "yes",
"-bestpath", "no",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
ngs = (ngram_search_t *)ps->search;
acmod = ps->acmod;
setbuf(stdout, NULL);
c = clock();
{
FILE *rawfh;
int16 buf[2048];
size_t nread;
int16 const *bptr;
int nfr;
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
ngram_fwdflat_start(ngs);
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
ngram_fwdflat_search(ngs,acmod->output_frame);
acmod_advance(acmod);
}
}
}
ngram_fwdflat_finish(ngs);
printf("%s\n",
ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL)));
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
}
TEST_EQUAL(0, strcmp("go forward and users",
ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL))));
c = clock() - c;
printf("2 * fwdflat search in %.2f sec\n",
(double)c / CLOCKS_PER_SEC);
ps_free(ps);
return 0;
}
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 %d nsamp %d 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 %d nsamp %d 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 %d nsamp %d 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 %d nsamp %d 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 %d nsamp %d 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 %d nsamp %d 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 %d nsamp %d 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 %d nsamp %d 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;
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
fsg_search_t *fsgs;
jsgf_t *jsgf;
jsgf_rule_t *rule;
fsg_model_t *fsg;
ps_seg_t *seg;
ps_lattice_t *dag;
FILE *rawfh;
char const *hyp, *uttid;
int32 score, prob;
clock_t c;
int i;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
jsgf = jsgf_parse_file(DATADIR "/goforward.gram", NULL);
TEST_ASSERT(jsgf);
rule = jsgf_get_rule(jsgf, "<goforward.move2>");
TEST_ASSERT(rule);
fsg = jsgf_build_fsg(jsgf, rule, ps->lmath, 7.5);
TEST_ASSERT(fsg);
fsg_model_write(fsg, stdout);
ps_set_fsg(ps, "<goforward.move2>", fsg);
ps_set_search(ps, "<goforward.move2>");
acmod = ps->acmod;
fsgs = (fsg_search_t *) fsg_search_init(fsg, config, acmod, ps->dict, ps->d2p);
setbuf(stdout, NULL);
c = clock();
for (i = 0; i < 5; ++i) {
int16 buf[2048];
size_t nread;
int16 const *bptr;
int nfr;
int is_final;
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
fsg_search_start(ps_search_base(fsgs));
is_final = FALSE;
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
fsg_search_step(ps_search_base(fsgs),
acmod->output_frame);
acmod_advance(acmod);
}
}
hyp = fsg_search_hyp(ps_search_base(fsgs), &score, &is_final);
printf("FSG: %s (%d) frame %d final %s\n", hyp, score, acmod->output_frame, is_final ? "FINAL" : "");
TEST_EQUAL (is_final, (acmod->output_frame > 170));
}
fsg_search_finish(ps_search_base(fsgs));
hyp = fsg_search_hyp(ps_search_base(fsgs), &score, NULL);
printf("FSG: %s (%d)\n", hyp, score);
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
}
TEST_EQUAL(0, strcmp("go forward ten meters",
fsg_search_hyp(ps_search_base(fsgs), &score, NULL)));
ps->search = (ps_search_t *)fsgs;
for (seg = ps_seg_iter(ps, &score); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
printf("%s %d %d\n", word, sf, ef);
}
c = clock() - c;
printf("5 * fsg search in %.2f sec\n", (double)c / CLOCKS_PER_SEC);
dag = ps_get_lattice(ps);
ps_lattice_write(dag, "test_jsgf.lat");
jsgf_grammar_free(jsgf);
fsg_search_free(ps_search_base(fsgs));
ps_free(ps);
cmd_ln_free_r(config);
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-jsgf", DATADIR "/goforward.gram",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
ps_decode_raw(ps, rawfh, "goforward", -1);
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s: %s (%d, %d)\n", uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp("go forward ten meters", hyp));
ps_free(ps);
fclose(rawfh);
cmd_ln_free_r(config);
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-jsgf", DATADIR "/goforward.gram",
"-toprule", "goforward.move2",
"-input_endian", "little",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
ps_decode_raw(ps, rawfh, "goforward", -1);
hyp = ps_get_hyp(ps, &score, &uttid);
prob = ps_get_prob(ps, &uttid);
printf("%s: %s (%d, %d)\n", uttid, hyp, score, prob);
TEST_EQUAL(0, strcmp("go forward ten meters", hyp));
ps_free(ps);
cmd_ln_free_r(config);
fclose(rawfh);
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/hmm/en_US/hub4wsj_sc_8k",
"-dict", MODELDIR "/lm/en/turtle.dic",
"-jsgf", DATADIR "/defective.gram",
NULL));
TEST_ASSERT(NULL == ps_init(config));
cmd_ln_free_r(config);
return 0;
}
int
test_decode(ps_decoder_t *ps)
{
FILE *rawfh;
int16 buf[2048];
size_t nread;
int16 const *bptr;
int nfr;
ps_lattice_t *dag;
acmod_t *acmod;
ngram_search_t *ngs;
int i, j;
ps_latlink_t *link;
ps_latnode_t *node;
latlink_list_t *x;
int32 norm, post;
ngs = (ngram_search_t *)ps->search;
acmod = ps->acmod;
/* Decode stuff and build a DAG. */
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
ngram_fwdtree_start(ngs);
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
ngram_fwdtree_search(ngs, acmod->output_frame);
acmod_advance(acmod);
}
}
}
ngram_fwdtree_finish(ngs);
printf("FWDTREE: %s\n",
ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL, NULL)));
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
dag = ngram_search_lattice(ps->search);
if (dag == NULL) {
E_ERROR("Failed to build DAG!\n");
return -1;
}
/* Write lattice to disk. */
TEST_EQUAL(0, ps_lattice_write(dag, "test_posterior.lat"));
/* Do a bunch of checks on the DAG generation and traversal code: */
/* Verify that forward and backward iteration give the same number of edges. */
i = j = 0;
for (link = ps_lattice_traverse_edges(dag, NULL, NULL);
link; link = ps_lattice_traverse_next(dag, NULL)) {
++i;
}
for (link = ps_lattice_reverse_edges(dag, NULL, NULL);
link; link = ps_lattice_reverse_next(dag, NULL)) {
++j;
}
printf("%d forward edges, %d reverse edges\n", i, j);
TEST_EQUAL(i,j);
/* Verify that the same links are reachable via entries and exits. */
for (node = dag->nodes; node; node = node->next) {
for (x = node->exits; x; x = x->next)
x->link->alpha = -42;
}
for (node = dag->nodes; node; node = node->next) {
for (x = node->entries; x; x = x->next)
TEST_EQUAL(x->link->alpha, -42);
}
/* Verify that forward iteration is properly ordered. */
for (link = ps_lattice_traverse_edges(dag, NULL, NULL);
link; link = ps_lattice_traverse_next(dag, NULL)) {
link->alpha = 0;
for (x = link->from->entries; x; x = x->next) {
TEST_EQUAL(x->link->alpha, 0);
}
}
/* Verify that backward iteration is properly ordered. */
for (node = dag->nodes; node; node = node->next) {
for (x = node->exits; x; x = x->next)
x->link->alpha = -42;
}
for (link = ps_lattice_reverse_edges(dag, NULL, NULL);
link; link = ps_lattice_reverse_next(dag, NULL)) {
link->alpha = 0;
for (x = link->to->exits; x; x = x->next) {
TEST_EQUAL(x->link->alpha, 0);
}
}
/* Find and print best path. */
link = ps_lattice_bestpath(dag, ngs->lmset, 1.0, 1.0/20.0);
printf("BESTPATH: %s\n", ps_lattice_hyp(dag, link));
/* Calculate betas. */
post = ps_lattice_posterior(dag, ngs->lmset, 1.0/20.0);
printf("Best path score: %d\n",
link->path_scr + dag->final_node_ascr);
printf("P(S|O) = %d\n", post);
/* Verify that sum of final alphas and initial alphas+betas is
* sufficiently similar. */
norm = logmath_get_zero(acmod->lmath);
for (x = dag->start->exits; x; x = x->next)
norm = logmath_add(acmod->lmath, norm, x->link->beta + x->link->alpha);
E_INFO("Sum of final alphas+betas = %d\n", dag->norm);
E_INFO("Sum of initial alphas+betas = %d\n", norm);
TEST_EQUAL_LOG(dag->norm, norm);
/* Print posterior probabilities for each link in best path. */
while (link) {
printf("P(%s,%d) = %d = %f\n",
dict_wordstr(ps->search->dict, link->from->wid),
link->ef,
link->alpha + link->beta - dag->norm,
logmath_exp(acmod->lmath, link->alpha + link->beta - dag->norm));
link = link->best_prev;
}
return 0;
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
dict_t *dict;
dict2pid_t *d2p;
acmod_t *acmod;
ps_alignment_t *al;
ps_alignment_iter_t *itor;
ps_search_t *search;
cmd_ln_t *config;
int i;
config = cmd_ln_init(NULL, ps_args(), FALSE,
"-hmm", MODELDIR "/en-us/en-us",
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
"-input_endian", "little",
"-samprate", "16000", NULL);
TEST_ASSERT(ps = ps_init(config));
dict = ps->dict;
d2p = ps->d2p;
acmod = ps->acmod;
al = ps_alignment_init(d2p);
TEST_EQUAL(1, ps_alignment_add_word(al, dict_wordid(dict, "<s>"), 0));
TEST_EQUAL(2, ps_alignment_add_word(al, dict_wordid(dict, "go"), 0));
TEST_EQUAL(3, ps_alignment_add_word(al, dict_wordid(dict, "forward"), 0));
TEST_EQUAL(4, ps_alignment_add_word(al, dict_wordid(dict, "ten"), 0));
TEST_EQUAL(5, ps_alignment_add_word(al, dict_wordid(dict, "meters"), 0));
TEST_EQUAL(6, ps_alignment_add_word(al, dict_wordid(dict, "</s>"), 0));
TEST_EQUAL(0, ps_alignment_populate(al));
TEST_ASSERT(search = state_align_search_init(config, acmod, al));
for (i = 0; i < 5; ++i)
do_search(search, acmod);
itor = ps_alignment_words(al);
TEST_EQUAL(ps_alignment_iter_get(itor)->start, 0);
TEST_EQUAL(ps_alignment_iter_get(itor)->duration, 3);
itor = ps_alignment_iter_next(itor);
TEST_EQUAL(ps_alignment_iter_get(itor)->start, 3);
TEST_EQUAL(ps_alignment_iter_get(itor)->duration, 12);
itor = ps_alignment_iter_next(itor);
TEST_EQUAL(ps_alignment_iter_get(itor)->start, 15);
TEST_EQUAL(ps_alignment_iter_get(itor)->duration, 53);
itor = ps_alignment_iter_next(itor);
TEST_EQUAL(ps_alignment_iter_get(itor)->start, 68);
TEST_EQUAL(ps_alignment_iter_get(itor)->duration, 36);
itor = ps_alignment_iter_next(itor);
TEST_EQUAL(ps_alignment_iter_get(itor)->start, 104);
TEST_EQUAL(ps_alignment_iter_get(itor)->duration, 59);
itor = ps_alignment_iter_next(itor);
TEST_EQUAL(ps_alignment_iter_get(itor)->start, 163);
TEST_EQUAL(ps_alignment_iter_get(itor)->duration, 51);
itor = ps_alignment_iter_next(itor);
TEST_EQUAL(itor, NULL);
ps_search_free(search);
ps_alignment_free(al);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
ps_decoder_t *ps;
cmd_ln_t *config;
acmod_t *acmod;
ngram_search_t *ngs;
ps_lattice_t *dag;
clock_t c;
int i;
TEST_ASSERT(config =
cmd_ln_init(NULL, ps_args(), TRUE,
"-hmm", MODELDIR "/en-us/en-us",
"-lm", MODELDIR "/en-us/en-us.lm.bin",
"-dict", MODELDIR "/en-us/cmudict-en-us.dict",
"-fwdtree", "yes",
"-fwdflat", "no",
"-bestpath", "yes",
"-samprate", "16000", NULL));
TEST_ASSERT(ps = ps_init(config));
ngs = (ngram_search_t *)ps->search;
acmod = ps->acmod;
acmod_set_grow(ps->acmod, TRUE);
setbuf(stdout, NULL);
c = clock();
for (i = 0; i < 5; ++i) {
FILE *rawfh;
int16 buf[2048];
size_t nread;
int16 const *bptr;
int nfr;
ps_astar_t *nbest;
ps_latpath_t *path;
char *besthyp;
const char *astar_besthyp = NULL;
int32 astar_hyp_score;
int i;
/* PocketSphinx API would do this for us but we have to do it manually here. */
ps_lattice_free(ps->search->dag);
ps->search->dag = NULL;
TEST_ASSERT(rawfh = fopen(DATADIR "/goforward.raw", "rb"));
TEST_EQUAL(0, acmod_start_utt(acmod));
ngram_fwdtree_start(ngs);
while (!feof(rawfh)) {
nread = fread(buf, sizeof(*buf), 2048, rawfh);
bptr = buf;
while ((nfr = acmod_process_raw(acmod, &bptr, &nread, FALSE)) > 0) {
while (acmod->n_feat_frame > 0) {
ngram_fwdtree_search(ngs, acmod->output_frame);
acmod_advance(acmod);
}
}
}
ngram_fwdtree_finish(ngs);
printf("FWDTREE: %s\n",
ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL)));
TEST_ASSERT(acmod_end_utt(acmod) >= 0);
fclose(rawfh);
dag = ngram_search_lattice(ps->search);
if (dag == NULL) {
E_ERROR("Failed to build DAG!\n");
return 1;
}
besthyp = ckd_salloc
(ps_lattice_hyp(dag, ps_lattice_bestpath
(dag, ngs->lmset, 9.5/6.5, 1.0)));
printf("BESTPATH: %s\n", besthyp);
TEST_ASSERT(nbest = ps_astar_start(dag, ngs->lmset, 9.5/6.5, 0, -1, -1, -1));
i = 0;
astar_hyp_score = WORST_SCORE;
while ((path = ps_astar_next(nbest))) {
if (i < 10)
printf("NBEST %d: %s (%d)\n", i, ps_astar_hyp(nbest, path), path->score);
if (path->score > astar_hyp_score) {
astar_hyp_score = path->score;
astar_besthyp = ps_astar_hyp(nbest, path);
}
i++;
}
TEST_EQUAL(0, strcmp(besthyp, astar_besthyp));
ps_astar_finish(nbest);
ckd_free(besthyp);
}
printf("%s\n", ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL)));
TEST_EQUAL(0, strcmp("go forward ten meters",
ngram_search_bp_hyp(ngs, ngram_search_find_exit(ngs, -1, NULL))));
c = clock() - c;
printf("5 * fwdtree + bestpath + N-best search in %.2f sec\n",
(double)c / CLOCKS_PER_SEC);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}