int
main(int argc, char *argv[])
{
lexicon_t *lex;
model_def_t *mdef;
if (initialize(&lex, &mdef,
argc, argv) != S3_SUCCESS) {
E_ERROR("errors initializing.\n");
return 1;
}
if (init_gau(lex, mdef) != S3_SUCCESS) {
return 1;
}
return 0;
}
int
sbthread_wait(sbthread_t *th)
{
void *exit;
int rv;
/* It has already been joined. */
if (th->th == (pthread_t)-1)
return -1;
rv = pthread_join(th->th, &exit);
if (rv != 0) {
E_ERROR("Failed to join thread: %d\n", rv);
return -1;
}
th->th = (pthread_t)-1;
return (int)(long)exit;
}
sbthread_t *
sbthread_start(cmd_ln_t *config, sbthread_main func, void *arg)
{
sbthread_t *th;
int rv;
th = ckd_calloc(1, sizeof(*th));
th->config = config;
th->func = func;
th->arg = arg;
th->msgq = sbmsgq_init(1024);
if ((rv = pthread_create(&th->th, NULL, &sbthread_internal_main, th)) != 0) {
E_ERROR("Failed to create thread: %d\n", rv);
sbthread_free(th);
return NULL;
}
return th;
}
void
fsg_model_writefile_symtab(fsg_model_t *fsg, char const *file)
{
FILE *fp;
assert(fsg);
E_INFO("Writing FSM symbol table '%s'\n", file);
if ((fp = fopen(file, "w")) == NULL) {
E_ERROR("Failed to open symbol table '%s' for writing: %s\n", file, strerror(errno));
return;
}
fsg_model_write_symtab(fsg, fp);
fclose(fp);
}
PJ *PROJECTION(loxim) {
struct pj_opaque *Q = pj_calloc (1, sizeof (struct pj_opaque));
if (0==Q)
return freeup_new (P);
P->opaque = Q;
Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
Q->cosphi1 = cos(Q->phi1);
if (Q->cosphi1 < EPS)
E_ERROR(-22);
Q->tanphi1 = tan(M_FORTPI + 0.5 * Q->phi1);
P->inv = s_inverse;
P->fwd = s_forward;
P->es = 0.;
return P;
}
int
sbthread_wait(sbthread_t *th)
{
DWORD rv, exit;
/* It has already been joined. */
if (th->th == NULL)
return -1;
rv = WaitForSingleObject(th->th, INFINITE);
if (rv == WAIT_FAILED) {
E_ERROR("Failed to join thread: WAIT_FAILED\n");
return -1;
}
GetExitCodeThread(th->th, &exit);
CloseHandle(th->th);
th->th = NULL;
return (int)exit;
}
void priority_queue_add(priority_queue_t *queue, void *element)
{
size_t i;
if (queue->size == queue->alloc_size) {
E_ERROR("Trying to add element into full queue\n");
return;
}
for (i = 0; i < queue->alloc_size; i++) {
if (queue->pointers[i] == NULL) {
queue->pointers[i] = element;
break;
}
}
if (queue->max_element == NULL || queue->compare(element, queue->max_element) < 0) {
queue->max_element = element;
}
queue->size++;
}
int
dict_add_g2p_word(dict_t * dict, char const *word)
{
int32 wid = 0;
s3cipid_t *pron;
char **phonestr, *tmp;
int np, i;
char *phones;
phones = dict_g2p(word, dict->ngram_g2p_model);
if (phones == NULL)
return 0;
E_INFO("Adding phone %s for word %s \n", phones, word);
tmp = ckd_salloc(phones);
np = str2words(tmp, NULL, 0);
phonestr = ckd_calloc(np, sizeof(*phonestr));
str2words(tmp, phonestr, np);
pron = ckd_calloc(np, sizeof(*pron));
for (i = 0; i < np; ++i) {
pron[i] = bin_mdef_ciphone_id(dict->mdef, phonestr[i]);
if (pron[i] == -1) {
E_ERROR("Unknown phone %s in phone string %s\n",
phonestr[i], tmp);
ckd_free(phonestr);
ckd_free(tmp);
ckd_free(pron);
ckd_free(phones);
return -1;
}
}
ckd_free(phonestr);
ckd_free(tmp);
ckd_free(phones);
if ((wid = dict_add_word(dict, word, pron, np)) == -1) {
ckd_free(pron);
return -1;
}
ckd_free(pron);
return wid;
}
sbevent_t *
sbevent_init(void)
{
sbevent_t *evt;
int rv;
evt = ckd_calloc(1, sizeof(*evt));
if ((rv = pthread_mutex_init(&evt->mtx, NULL)) != 0) {
E_ERROR("Failed to initialize mutex: %d\n", rv);
ckd_free(evt);
return NULL;
}
if ((rv = pthread_cond_init(&evt->cond, NULL)) != 0) {
E_ERROR_SYSTEM("Failed to initialize mutex: %d\n", rv);
pthread_mutex_destroy(&evt->mtx);
ckd_free(evt);
return NULL;
}
return evt;
}
static int
calc_feat_idx(acmod_t *acmod, int frame_idx)
{
int n_backfr, feat_idx;
n_backfr = acmod->n_feat_alloc - acmod->n_feat_frame;
if (frame_idx < 0 || acmod->output_frame - frame_idx > n_backfr) {
E_ERROR("Frame %d outside queue of %d frames, %d alloc (%d > %d), cannot score\n",
frame_idx, acmod->n_feat_frame, acmod->n_feat_alloc,
acmod->output_frame - frame_idx, n_backfr);
return -1;
}
/* Get the index in feat_buf/framepos of the frame to be scored. */
feat_idx = ((acmod->feat_outidx + frame_idx - acmod->output_frame)
% acmod->n_feat_alloc);
if (feat_idx < 0) feat_idx += acmod->n_feat_alloc;
return feat_idx;
}
blkarray_list_t *
_blkarray_list_init(int32 maxblks, int32 blksize)
{
blkarray_list_t *bl;
if ((maxblks <= 0) || (blksize <= 0)) {
E_ERROR("Cannot allocate %dx%d blkarray\n", maxblks, blksize);
return NULL;
}
bl = (blkarray_list_t *) ckd_calloc(1, sizeof(blkarray_list_t));
bl->ptr = (void ***) ckd_calloc(maxblks, sizeof(void **));
bl->maxblks = maxblks;
bl->blksize = blksize;
bl->n_valid = 0;
bl->cur_row = -1; /* No row is allocated (dummy) */
bl->cur_row_free = blksize; /* The dummy row is full */
return bl;
}
/**
* Map the given ngram string to an array of word IDs of the individual
* words in the ngram.
*
* args:
* ngram - the ngram string to map
* length - the length of the ngram string
* w - the word ID array
* lm - the language model to use
*
* returns:
* the number of words in the ngram string, or 0 if the string contains an
* unknown word
*/
int
ngram2wid(char *ngram, int length, s3lmwid32_t * w, lm_t * lm)
{
char *word[1024];
int nwd;
int i;
if ((nwd = str2words(ngram, word, length)) < 0)
E_FATAL("Increase word[] and w[] arrays size\n");
for (i = 0; i < nwd; i++) {
w[i] = lm_wid(lm, word[i]);
if (NOT_LMWID(lm, w[i])) {
E_ERROR("Unknown word: %s\n", word[i]);
return 0;
}
}
return nwd;
}
void
utt_decode_block(float ***block_feat, /* Incoming block of featurevecs */
int32 no_frm, /* No. of vecs in cepblock */
int32 * curfrm, /* Utterance level index of
frames decoded so far */
kb_t * kb /* kb structure with all model
and decoder info */
)
{
srch_t *s;
s = (srch_t *) kb->srch;
/* These are necessary! */
s->uttid = kb->uttid;
s->uttfile = kb->uttfile;
if (srch_utt_decode_blk(s, block_feat, no_frm, curfrm) == SRCH_FAILURE) {
E_ERROR("srch_utt_decode_blk failed. \n");
}
}
int
acmod_rewind(acmod_t *acmod)
{
/* If the feature buffer is circular, this is not possible. */
if (acmod->output_frame > acmod->n_feat_alloc) {
E_ERROR("Circular feature buffer cannot be rewound (output frame %d, "
"alloc %d)\n", acmod->output_frame, acmod->n_feat_alloc);
return -1;
}
/* Frames consumed + frames available */
acmod->n_feat_frame = acmod->output_frame + acmod->n_feat_frame;
/* Reset output pointers. */
acmod->feat_outidx = 0;
acmod->output_frame = 0;
acmod->senscr_frame = -1;
acmod->mgau->frame_idx = 0;
return 0;
}
int32 cep_write_bin(char const *file, float32 *buf, int32 len)
{
int32 fd;
#ifdef WIN32
fd = open(file, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644);
#else
fd = open(file, O_WRONLY|O_CREAT|O_TRUNC, 0644);
#endif
if (fd < 0) {
E_ERROR("Couldn't open %s for writing\n", file);
return errno;
}
len *= sizeof(float32);
if (write(fd, (char *)&len, sizeof(int32)) != sizeof(int32)) return -1;
if (write(fd, (char *)buf, len) != len) return -1;
if (close(fd) != ESUCCESS) return -1;
return ESUCCESS;
}
jsgf_t *
jsgf_parse_file(const char *filename, jsgf_t * parent)
{
yyscan_t yyscanner;
jsgf_t *jsgf;
int yyrv;
FILE *in = NULL;
yylex_init(&yyscanner);
if (filename == NULL) {
yyset_in(stdin, yyscanner);
}
else {
in = fopen(filename, "r");
if (in == NULL) {
E_ERROR_SYSTEM("Failed to open %s for parsing", filename);
return NULL;
}
yyset_in(in, yyscanner);
}
jsgf = jsgf_grammar_new(parent);
if (!parent)
jsgf_set_search_path(jsgf, filename);
yyrv = yyparse(yyscanner, jsgf);
if (yyrv != 0) {
E_ERROR("Failed to parse JSGF grammar from '%s'\n",
filename ? filename : "(stdin)");
jsgf_grammar_free(jsgf);
yylex_destroy(yyscanner);
return NULL;
}
if (in)
fclose(in);
yylex_destroy(yyscanner);
return jsgf;
}
huff_code_t *
huff_code_build_str(char * const *values, int32 const *frequencies, int nvals)
{
huff_code_t *hc;
huff_node_t *root;
heap_t *q;
int i;
hc = (huff_code_t*)ckd_calloc(1, sizeof(*hc));
hc->refcount = 1;
hc->type = HUFF_CODE_STR;
/* Initialize the heap with nodes for each symbol. */
q = heap_new();
for (i = 0; i < nvals; ++i) {
heap_insert(q,
huff_node_new_str(values[i]),
frequencies[i]);
}
/* Now build the tree, which gives us codeword lengths. */
root = huff_code_build_tree(q);
heap_destroy(q);
if (root == 0 || root->nbits > 32) {
E_ERROR("Huffman trees currently limited to 32 bits\n");
huff_node_free_str(root, TRUE);
huff_code_free(hc);
return 0;
}
/* Build a canonical codebook. */
hc->maxbits = root->nbits;
huff_code_canonicalize(hc, root);
/* Tree no longer needed (note we retain pointers to its strings). */
huff_node_free_str(root, FALSE);
return hc;
}
/**
* Add a word to the word string and ID mapping.
*/
int32
ngram_add_word_internal(ngram_model_t * model,
const char *word, int32 classid)
{
/* Check for hash collisions. */
int32 wid;
if (hash_table_lookup_int32(model->wid, word, &wid) == 0) {
E_WARN("Omit duplicate word '%s'\n", word);
return wid;
}
/* Take the next available word ID */
wid = model->n_words;
if (classid >= 0) {
wid = NGRAM_CLASSWID(wid, classid);
}
/* Reallocate word_str if necessary. */
if (model->n_words >= model->n_1g_alloc) {
model->n_1g_alloc += UG_ALLOC_STEP;
model->word_str = ckd_realloc(model->word_str,
sizeof(*model->word_str) *
model->n_1g_alloc);
}
/* Add the word string in the appropriate manner. */
/* Class words are always dynamically allocated. */
model->word_str[model->n_words] = ckd_salloc(word);
/* Now enter it into the hash table. */
if (hash_table_enter_int32
(model->wid, model->word_str[model->n_words], wid) != wid) {
E_ERROR
("Hash insertion failed for word %s => %p (should not happen)\n",
model->word_str[model->n_words], (void *) (long) (wid));
}
/* Increment number of words. */
++model->n_words;
return wid;
}
static int
corpus_read_next_sent_file(char **trans)
{
FILE *fp;
lineiter_t *li;
/* open the current file */
fp = open_file_for_reading(DATA_TYPE_SENT);
li = lineiter_start_clean(fp);
if (li == NULL) {
E_ERROR("Unable to read data in sent file %s\n",
mk_filename(DATA_TYPE_SENT, cur_ctl_path));
return S3_ERROR;
}
*trans = strdup(li->buf);
lineiter_free(li);
fclose(fp);
return S3_SUCCESS;
}
huff_code_t *
huff_code_build_int(int32 const *values, int32 const *frequencies, int nvals)
{
huff_code_t *hc;
huff_node_t *root;
heap_t *q;
int i;
hc = ckd_calloc(1, sizeof(*hc));
hc->refcount = 1;
hc->type = HUFF_CODE_INT;
/* Initialize the heap with nodes for each symbol. */
q = heap_new();
for (i = 0; i < nvals; ++i) {
heap_insert(q,
huff_node_new_int(values[i]),
frequencies[i]);
}
/* Now build the tree, which gives us codeword lengths. */
root = huff_code_build_tree(q);
heap_destroy(q);
if (root == NULL || root->nbits > 64) {
E_ERROR("Huffman trees currently limited to 32 bits\n");
huff_node_free_int(root);
huff_code_free(hc);
return NULL;
}
/* Build a canonical codebook. */
hc->maxbits = root->nbits;
huff_code_canonicalize(hc, root);
/* Tree no longer needed. */
huff_node_free_int(root);
return hc;
}
int
srch_FSG_dump_vithist(void *srch)
{
FILE *latfp;
char file[8192];
srch_t *s;
fsg_search_t *fsgsrch;
s = (srch_t *) srch;
fsgsrch = (fsg_search_t *) s->grh->graph_struct;
sprintf(file, "%s/%s.hist", cmd_ln_str("-bptbldir"), fsgsrch->uttid);
if ((latfp = fopen(file, "w")) == NULL)
E_ERROR("fopen(%s,w) failed\n", file);
else {
fsg_history_dump(fsgsrch->history, fsgsrch->uttid, latfp,
fsgsrch->dict);
fclose(latfp);
}
return SRCH_SUCCESS;
}
static fwd_dbg_t *
init_fwd_dbg(srch_FLAT_FWD_graph_t * fwg)
{
const char *tmpstr;
fwd_dbg_t *fd;
fd = (fwd_dbg_t *) ckd_calloc(1, sizeof(fwd_dbg_t));
assert(fd);
/* Word to be traced in detail */
if ((tmpstr = cmd_ln_str_r(kbcore_config(fwg->kbcore), "-tracewhmm")) != NULL) {
fd->trace_wid = dict_wordid(fwg->kbcore->dict, tmpstr);
if (NOT_S3WID(fd->trace_wid))
E_ERROR("%s not in dictionary; cannot be traced\n", tmpstr);
}
else
fd->trace_wid = BAD_S3WID;
/* Active words to be dumped for debugging after and before the given frame nos, if any */
fd->word_dump_sf = (int32) 0x7ffffff0;
if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpsf"))
fd->word_dump_sf = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpsf");
fd->word_dump_ef = (int32) 0x7ffffff0;
if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpef"))
fd->word_dump_ef = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpef");
/* Active HMMs to be dumped for debugging after and before the given frame nos, if any */
fd->hmm_dump_sf = (int32) 0x7ffffff0;
if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpsf"))
fd->hmm_dump_sf = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpsf");
fd->hmm_dump_ef = (int32) 0x7ffffff0;
if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpef"))
fd->hmm_dump_ef = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpef");
return fd;
}
hmm_context_t *
hmm_context_init(int32 n_emit_state,
uint8 ** const *tp,
int16 const *senscore,
uint16 * const *sseq)
{
hmm_context_t *ctx;
assert(n_emit_state > 0);
if (n_emit_state > HMM_MAX_NSTATE) {
E_ERROR("Number of emitting states must be <= %d\n", HMM_MAX_NSTATE);
return NULL;
}
ctx = ckd_calloc(1, sizeof(*ctx));
ctx->n_emit_state = n_emit_state;
ctx->tp = tp;
ctx->senscore = senscore;
ctx->sseq = sseq;
ctx->st_sen_scr = ckd_calloc(n_emit_state, sizeof(*ctx->st_sen_scr));
return ctx;
}
int
ngram_model_trie_write_bin(ngram_model_t * base, const char *path)
{
int i;
int32 is_pipe;
ngram_model_trie_t *model = (ngram_model_trie_t *) base;
FILE *fp = fopen_comp(path, "wb", &is_pipe);
if (!fp) {
E_ERROR("Unable to open %s to write binary trie LM\n", path);
return -1;
}
fwrite(trie_hdr, sizeof(*trie_hdr), strlen(trie_hdr), fp);
fwrite(&model->base.n, sizeof(model->base.n), 1, fp);
for (i = 0; i < model->base.n; i++) {
fwrite(&model->base.n_counts[i], sizeof(model->base.n_counts[i]),
1, fp);
}
lm_trie_write_bin(model->trie, base->n_counts[0], fp);
write_word_str(fp, base);
fclose_comp(fp, is_pipe);
return 0;
}
static PJ *setup(PJ *P) {
struct pj_opaque *Q = P->opaque;
if ((Q->height = pj_param(P->ctx, P->params, "dh").f) <= 0.) E_ERROR(-30);
if (fabs(fabs(P->phi0) - M_HALFPI) < EPS10)
Q->mode = P->phi0 < 0. ? S_POLE : N_POLE;
else if (fabs(P->phi0) < EPS10)
Q->mode = EQUIT;
else {
Q->mode = OBLIQ;
Q->sinph0 = sin(P->phi0);
Q->cosph0 = cos(P->phi0);
}
Q->pn1 = Q->height / P->a; /* normalize by radius */
Q->p = 1. + Q->pn1;
Q->rp = 1. / Q->p;
Q->h = 1. / Q->pn1;
Q->pfact = (Q->p + 1.) * Q->h;
P->inv = s_inverse;
P->fwd = s_forward;
P->es = 0.;
return P;
}
static int
add_phones(uint32 n_phone,
lex_entry_t *e,
acmod_set_t *acmod_set)
{
uint32 i;
char *nxt_phone;
e->phone = ckd_calloc(n_phone, sizeof(char *));
e->ci_acmod_id = ckd_calloc(n_phone, sizeof(uint32));
e->phone_cnt = n_phone;
for (i = 0; (nxt_phone = strtok(NULL, " \t")); i++) {
e->phone[i] = nxt_phone;
e->ci_acmod_id[i] =
acmod_set_name2id(acmod_set, nxt_phone);
if (e->ci_acmod_id[i] == NO_ACMOD) {
E_ERROR("Unknown phone %s\n", nxt_phone);
ckd_free(e->phone);
e->phone = NULL;
ckd_free(e->ci_acmod_id);
e->ci_acmod_id = NULL;
e->phone_cnt = 0;
return S3_ERROR;
}
}
assert(i == n_phone);
return S3_SUCCESS;
}
FILE *
s3_open_bin_write(const char *file_name,
const char *version,
const char *comment)
{
FILE *fp;
fp = fopen(file_name, "wb");
if (fp == NULL) {
E_WARN_SYSTEM("Unable to open %s for writing", file_name);
goto error;
}
if ((unsigned)fprintf(fp, "%s\n", version) !=
strlen(version)+1) {
E_ERROR("unable to write version id in %s",
file_name);
goto error;
}
if (bcomment_write(fp, comment) != S3_SUCCESS) {
goto error;
}
if (swap_stamp(fp) != S3_SUCCESS) {
goto error;
}
return fp;
error:
fclose(fp);
return NULL;
}
const char *
id_of(const char *buf)
{
uint32 i;
char *op, *cp;
static char id[128];
op = strrchr(buf, '(');
cp = strrchr(buf, ')');
if (op && cp) {
for (i = 0, ++op; op < cp; op++, i++) {
id[i] = *op;
}
id[i] = '\0';
}
else {
E_ERROR("Unable to locate id field at end of line\n");
return NULL;
}
/* Fixed by awb 23/09/00, this didn't return anything before */
return id;
}
cmd_ln_t *
cmd_ln_init(cmd_ln_t *inout_cmdln, const arg_t *defn, int32 strict, ...)
{
va_list args;
const char *arg, *val;
char **f_argv;
int32 f_argc;
va_start(args, strict);
f_argc = 0;
while ((arg = va_arg(args, const char *))) {
++f_argc;
val = va_arg(args, const char*);
if (val == NULL) {
E_ERROR("Number of arguments must be even!\n");
return NULL;
}
++f_argc;
}
va_end(args);
/* Now allocate f_argv */
f_argv = ckd_calloc(f_argc, sizeof(*f_argv));
va_start(args, strict);
f_argc = 0;
while ((arg = va_arg(args, const char *))) {
f_argv[f_argc] = ckd_salloc(arg);
++f_argc;
val = va_arg(args, const char*);
f_argv[f_argc] = ckd_salloc(val);
++f_argc;
}
va_end(args);
return parse_options(inout_cmdln, defn, f_argc, f_argv, strict);
}
int
corpus_ckpt_set_interval(const char *fn)
{
FILE *fp;
uint32 o, rl;
fp = fopen(fn, "r");
if (fp == NULL) {
E_ERROR_SYSTEM("Can't open ckpt file %s", fn);
return S3_ERROR;
}
if (fscanf(fp, "%u %u", &o, &rl) != 2) {
E_ERROR("Problems reading ckpt file %s\n", fn);
fclose(fp);
return S3_ERROR;
}
fclose(fp);
return corpus_set_interval(o, rl);
}
