mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-14 15:30:07 +00:00
318 lines
8.7 KiB
C
318 lines
8.7 KiB
C
/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
|
|
/* ====================================================================
|
|
* Copyright (c) 1999-2004 Carnegie Mellon University. All rights
|
|
* reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
*
|
|
* THIS 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.
|
|
*
|
|
* ====================================================================
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* fsg_history.c -- FSG Viterbi decode history
|
|
*
|
|
* **********************************************
|
|
* CMU ARPA Speech Project
|
|
*
|
|
* Copyright (c) 1999 Carnegie Mellon University.
|
|
* ALL RIGHTS RESERVED.
|
|
* **********************************************
|
|
*
|
|
* HISTORY
|
|
*
|
|
* 25-Feb-2004 M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
|
|
* Started..
|
|
*/
|
|
|
|
/* System headers. */
|
|
#include <assert.h>
|
|
|
|
/* SphinxBase headers. */
|
|
#include <sphinxbase/prim_type.h>
|
|
#include <sphinxbase/err.h>
|
|
#include <sphinxbase/ckd_alloc.h>
|
|
|
|
/* Local headers. */
|
|
#include "fsg_search_internal.h"
|
|
#include "fsg_history.h"
|
|
|
|
|
|
#define __FSG_DBG__ 0
|
|
|
|
|
|
fsg_history_t *
|
|
fsg_history_init(fsg_model_t * fsg, dict_t *dict)
|
|
{
|
|
fsg_history_t *h;
|
|
|
|
h = (fsg_history_t *) ckd_calloc(1, sizeof(fsg_history_t));
|
|
h->fsg = fsg;
|
|
h->entries = blkarray_list_init();
|
|
|
|
if (fsg && dict) {
|
|
h->n_ciphone = bin_mdef_n_ciphone(dict->mdef);
|
|
h->frame_entries =
|
|
(glist_t **) ckd_calloc_2d(fsg_model_n_state(fsg),
|
|
bin_mdef_n_ciphone(dict->mdef),
|
|
sizeof(**h->frame_entries));
|
|
}
|
|
else {
|
|
h->frame_entries = NULL;
|
|
}
|
|
|
|
return h;
|
|
}
|
|
|
|
void
|
|
fsg_history_free(fsg_history_t *h)
|
|
{
|
|
int32 s, lc, ns, np;
|
|
gnode_t *gn;
|
|
|
|
if (h->fsg) {
|
|
ns = fsg_model_n_state(h->fsg);
|
|
np = h->n_ciphone;
|
|
|
|
for (s = 0; s < ns; s++) {
|
|
for (lc = 0; lc < np; lc++) {
|
|
for (gn = h->frame_entries[s][lc]; gn; gn = gnode_next(gn)) {
|
|
ckd_free(gnode_ptr(gn));
|
|
}
|
|
glist_free(h->frame_entries[s][lc]);
|
|
}
|
|
}
|
|
}
|
|
ckd_free_2d(h->frame_entries);
|
|
blkarray_list_free(h->entries);
|
|
ckd_free(h);
|
|
}
|
|
|
|
|
|
void
|
|
fsg_history_set_fsg(fsg_history_t *h, fsg_model_t *fsg, dict_t *dict)
|
|
{
|
|
if (blkarray_list_n_valid(h->entries) != 0) {
|
|
E_WARN("Switching FSG while history not empty; history cleared\n");
|
|
blkarray_list_reset(h->entries);
|
|
}
|
|
|
|
if (h->frame_entries)
|
|
ckd_free_2d((void **) h->frame_entries);
|
|
h->frame_entries = NULL;
|
|
h->fsg = fsg;
|
|
|
|
if (fsg && dict) {
|
|
h->n_ciphone = bin_mdef_n_ciphone(dict->mdef);
|
|
h->frame_entries =
|
|
(glist_t **) ckd_calloc_2d(fsg_model_n_state(fsg),
|
|
bin_mdef_n_ciphone(dict->mdef),
|
|
sizeof(glist_t));
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
fsg_history_entry_add(fsg_history_t * h,
|
|
fsg_link_t * link,
|
|
int32 frame, int32 score, int32 pred,
|
|
int32 lc, fsg_pnode_ctxt_t rc)
|
|
{
|
|
fsg_hist_entry_t *entry, *new_entry;
|
|
int32 s;
|
|
gnode_t *gn, *prev_gn;
|
|
|
|
/* Skip the optimization for the initial dummy entries; always enter them */
|
|
if (frame < 0) {
|
|
new_entry =
|
|
(fsg_hist_entry_t *) ckd_calloc(1, sizeof(fsg_hist_entry_t));
|
|
new_entry->fsglink = link;
|
|
new_entry->frame = frame;
|
|
new_entry->score = score;
|
|
new_entry->pred = pred;
|
|
new_entry->lc = lc;
|
|
new_entry->rc = rc;
|
|
|
|
blkarray_list_append(h->entries, (void *) new_entry);
|
|
return;
|
|
}
|
|
|
|
s = fsg_link_to_state(link);
|
|
|
|
/* Locate where this entry should be inserted in frame_entries[s][lc] */
|
|
prev_gn = NULL;
|
|
for (gn = h->frame_entries[s][lc]; gn; gn = gnode_next(gn)) {
|
|
entry = (fsg_hist_entry_t *) gnode_ptr(gn);
|
|
|
|
if (score BETTER_THAN entry->score)
|
|
break; /* Found where to insert new entry */
|
|
|
|
/* Existing entry score not worse than new score */
|
|
if (FSG_PNODE_CTXT_SUB(&rc, &(entry->rc)) == 0)
|
|
return; /* rc set reduced to 0; new entry can be ignored */
|
|
|
|
prev_gn = gn;
|
|
}
|
|
|
|
/* Create new entry after prev_gn (if prev_gn is NULL, at head) */
|
|
new_entry =
|
|
(fsg_hist_entry_t *) ckd_calloc(1, sizeof(fsg_hist_entry_t));
|
|
new_entry->fsglink = link;
|
|
new_entry->frame = frame;
|
|
new_entry->score = score;
|
|
new_entry->pred = pred;
|
|
new_entry->lc = lc;
|
|
new_entry->rc = rc; /* Note: rc set must be non-empty at this point */
|
|
|
|
if (!prev_gn) {
|
|
h->frame_entries[s][lc] = glist_add_ptr(h->frame_entries[s][lc],
|
|
(void *) new_entry);
|
|
prev_gn = h->frame_entries[s][lc];
|
|
}
|
|
else
|
|
prev_gn = glist_insert_ptr(prev_gn, (void *) new_entry);
|
|
|
|
/*
|
|
* Update the rc set of all the remaining entries in the list. At this
|
|
* point, gn is the entry, if any, immediately following new entry.
|
|
*/
|
|
while (gn) {
|
|
entry = (fsg_hist_entry_t *) gnode_ptr(gn);
|
|
|
|
if (FSG_PNODE_CTXT_SUB(&(entry->rc), &rc) == 0) {
|
|
/* rc set of entry reduced to 0; can prune this entry */
|
|
ckd_free((void *) entry);
|
|
gn = gnode_free(gn, prev_gn);
|
|
}
|
|
else {
|
|
prev_gn = gn;
|
|
gn = gnode_next(gn);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Transfer the surviving history entries for this frame into the permanent
|
|
* history table.
|
|
*/
|
|
void
|
|
fsg_history_end_frame(fsg_history_t * h)
|
|
{
|
|
int32 s, lc, ns, np;
|
|
gnode_t *gn;
|
|
fsg_hist_entry_t *entry;
|
|
|
|
ns = fsg_model_n_state(h->fsg);
|
|
np = h->n_ciphone;
|
|
|
|
for (s = 0; s < ns; s++) {
|
|
for (lc = 0; lc < np; lc++) {
|
|
for (gn = h->frame_entries[s][lc]; gn; gn = gnode_next(gn)) {
|
|
entry = (fsg_hist_entry_t *) gnode_ptr(gn);
|
|
blkarray_list_append(h->entries, (void *) entry);
|
|
}
|
|
|
|
glist_free(h->frame_entries[s][lc]);
|
|
h->frame_entries[s][lc] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
fsg_hist_entry_t *
|
|
fsg_history_entry_get(fsg_history_t * h, int32 id)
|
|
{
|
|
return ((fsg_hist_entry_t *) blkarray_list_get(h->entries, id));
|
|
}
|
|
|
|
|
|
void
|
|
fsg_history_reset(fsg_history_t * h)
|
|
{
|
|
blkarray_list_reset(h->entries);
|
|
}
|
|
|
|
|
|
int32
|
|
fsg_history_n_entries(fsg_history_t * h)
|
|
{
|
|
return (blkarray_list_n_valid(h->entries));
|
|
}
|
|
|
|
void
|
|
fsg_history_utt_start(fsg_history_t * h)
|
|
{
|
|
int32 s, lc, ns, np;
|
|
|
|
assert(blkarray_list_n_valid(h->entries) == 0);
|
|
assert(h->frame_entries);
|
|
|
|
ns = fsg_model_n_state(h->fsg);
|
|
np = h->n_ciphone;
|
|
|
|
for (s = 0; s < ns; s++) {
|
|
for (lc = 0; lc < np; lc++) {
|
|
assert(h->frame_entries[s][lc] == NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
fsg_history_utt_end(fsg_history_t * h)
|
|
{
|
|
}
|
|
|
|
void
|
|
fsg_history_print(fsg_history_t *h, dict_t *dict)
|
|
{
|
|
int bpidx, bp;
|
|
|
|
for (bpidx = 0; bpidx < blkarray_list_n_valid(h->entries); bpidx++) {
|
|
bp = bpidx;
|
|
printf("History entry: ");
|
|
while (bp > 0) {
|
|
fsg_hist_entry_t *hist_entry = fsg_history_entry_get(h, bp);
|
|
fsg_link_t *fl = fsg_hist_entry_fsglink(hist_entry);
|
|
char const *baseword;
|
|
int32 wid;
|
|
bp = fsg_hist_entry_pred(hist_entry);
|
|
wid = fsg_link_wid(fl);
|
|
|
|
if (fl == NULL)
|
|
continue;
|
|
|
|
baseword = fsg_model_word_str(h->fsg, wid);
|
|
|
|
printf("%s(%d->%d:%d) ", baseword,
|
|
fsg_link_from_state(hist_entry->fsglink),
|
|
fsg_link_to_state(hist_entry->fsglink),
|
|
hist_entry->frame);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|