void
segment_audio()
{
FILE *file;
int16 pcm_buf[BLOCKSIZE];
mfcc_t **cep_buf;
int16 *voiced_buf;
int32 voiced_nsamps, out_frameidx, uttstart = 0;
char file_name[1024];
uint8 cur_vad_state, vad_state, writing;
int uttno, uttlen, sample_rate;
int32 nframes, nframes_tmp;
int16 frame_size, frame_shift, frame_rate;
size_t k;
sample_rate = (int) cmd_ln_float32_r(config, "-samprate");
frame_rate = cmd_ln_int32_r(config, "-frate");
frame_size =
(int32) (cmd_ln_float32_r(config, "-wlen") * sample_rate + 0.5);
frame_shift =
(int32) (sample_rate / cmd_ln_int32_r(config, "-frate") + 0.5);
nframes = (BLOCKSIZE - frame_size) / frame_shift;
cep_buf =
(mfcc_t **) ckd_calloc_2d(nframes, fe_get_output_size(fe),
sizeof(mfcc_t));
uttno = 0;
uttlen = 0;
cur_vad_state = 0;
voiced_nsamps = 0;
writing = 0;
file = NULL;
voiced_buf = NULL;
fe_start_stream(fe);
fe_start_utt(fe);
while ((k = read_audio(pcm_buf, BLOCKSIZE)) > 0) {
int16 const *pcm_buf_tmp;
pcm_buf_tmp = &pcm_buf[0];
while (k) {
nframes_tmp = nframes;
fe_process_frames_ext(fe, &pcm_buf_tmp, &k, cep_buf,
&nframes_tmp, &voiced_buf,
&voiced_nsamps, &out_frameidx);
if (out_frameidx > 0) {
uttstart = out_frameidx;
}
vad_state = fe_get_vad_state(fe);
if (!cur_vad_state && vad_state) {
/* silence->speech transition, time to start new file */
uttno++;
if (!singlefile) {
sprintf(file_name, "%s%04d.raw", infile_path, uttno);
if ((file = fopen(file_name, "wb")) == NULL)
E_FATAL_SYSTEM("Failed to open '%s' for writing",
file_name);
} else {
sprintf(file_name, "%s.raw", infile_path);
if ((file = fopen(file_name, "ab")) == NULL)
E_FATAL_SYSTEM("Failed to open '%s' for writing",
file_name);
}
writing = 1;
}
if (writing && file && voiced_nsamps > 0) {
fwrite(voiced_buf, sizeof(int16), voiced_nsamps, file);
uttlen += voiced_nsamps;
}
if (cur_vad_state && !vad_state) {
/* speech -> silence transition, time to finish file */
fclose(file);
printf("Utterance %04d: file %s start %.1f sec length %d samples ( %.2f sec )\n",
uttno,
file_name,
((double) uttstart) / frame_rate,
uttlen,
((double) uttlen) / sample_rate);
fflush(stdout);
fe_end_utt(fe, cep_buf[0], &nframes_tmp);
writing = 0;
uttlen = 0;
voiced_nsamps = 0;
fe_start_utt(fe);
}
cur_vad_state = vad_state;
}
}
if (writing) {
fclose(file);
printf("Utterance %04d: file %s start %.1f sec length %d samples ( %.2f sec )\n",
uttno,
file_name,
((double) uttstart) / frame_rate,
uttlen,
((double) uttlen) / sample_rate);
fflush(stdout);
}
fe_end_utt(fe, cep_buf[0], &nframes);
ckd_free_2d(cep_buf);
}
static int32 senone_mgau_map_read (senone_t *s, const char *file_name)
{
FILE *fp;
int32 byteswap, chksum_present, n_mgau_present;
uint32 chksum;
int32 i;
char eofchk;
char **argname, **argval;
float32 v;
E_INFO("Reading senone-codebook map file: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr (fp, &argname, &argval, &byteswap) < 0)
E_FATAL("bio_readhdr(%s) failed\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
n_mgau_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp (argname[i], "version") == 0) {
if (strcmp(argval[i], SPDEF_PARAM_VERSION) != 0) {
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], SPDEF_PARAM_VERSION);
}
/* HACK!! Convert version# to float32 and take appropriate action */
if (sscanf (argval[i], "%f", &v) != 1)
E_FATAL("%s: Bad version no. string: %s\n", file_name, argval[i]);
n_mgau_present = (v > 1.1) ? 1 : 0;
} else if (strcmp (argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free (argname, argval);
argname = argval = NULL;
chksum = 0;
/* Read #gauden (if version matches) */
if (n_mgau_present) {
if (bio_fread (&(s->n_mgau), sizeof(int32), 1, fp, byteswap, &chksum) != 1)
E_FATAL("fread(%s) (#gauden) failed\n", file_name);
}
/* Read 1d array data; s->sen2mgau allocated by called function */
if (bio_fread_1d ((void **)(&s->sen2mgau), sizeof(int32), &(s->n_sen), fp,
byteswap, &chksum) < 0) {
E_FATAL("bio_fread_1d(%s) failed\n", file_name);
}
/* Infer n_mgau if not present in this version */
if (! n_mgau_present) {
s->n_mgau = 1;
for (i = 0; i < s->n_sen; i++) {
if (s->sen2mgau[i] >= s->n_mgau)
s->n_mgau = s->sen2mgau[i]+1;
}
}
if (s->n_sen >= MAX_SENID)
E_FATAL("%s: #senones (%d) exceeds limit (%d)\n", file_name, s->n_sen, MAX_SENID);
if (s->n_mgau >= MAX_MGAUID)
E_FATAL("%s: #gauden (%d) exceeds limit (%d)\n", file_name, s->n_mgau, MAX_MGAUID);
/* Check for validity of mappings */
for (i = 0; i < s->n_sen; i++) {
if ((s->sen2mgau[i] >= s->n_mgau) || NOT_MGAUID(s->sen2mgau[i]))
E_FATAL("Bad sen2mgau[%d]= %d, out of range [0, %d)\n",
i, s->sen2mgau[i], s->n_mgau);
}
if (chksum_present)
bio_verify_chksum (fp, byteswap, chksum);
if (fread (&eofchk, 1, 1, fp) == 1)
E_FATAL("More data than expected in %s\n", file_name);
fclose(fp);
E_INFO("Read %d->%d senone-codebook mappings\n", s->n_sen, s->n_mgau);
return 0;
}
static int32
senone_mgau_map_read(senone_t * s, char const *file_name)
{
FILE *fp;
int32 byteswap, chksum_present, n_gauden_present;
uint32 chksum;
int32 i;
char eofchk;
char **argname, **argval;
void *ptr;
float32 v;
E_INFO("Reading senone gauden-codebook map file: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == 0)
E_FATAL_SYSTEM("Failed to open map file '%s' for reading", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr(fp, &argname, &argval, &byteswap) < 0)
E_FATAL("Failed to read header from file '%s'\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
n_gauden_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp(argname[i], "version") == 0) {
if (strcmp(argval[i], SPDEF_PARAM_VERSION) != 0) {
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], SPDEF_PARAM_VERSION);
}
#ifndef POCKETSPHINX_NET
/* HACK!! Convert version# to float32 and take appropriate action */
if (sscanf(argval[i], "%f", &v) != 1)
E_FATAL("%s: Bad version no. string: %s\n", file_name,
argval[i]);
#else
if (!Single::TryParse(gcnew String(argval[i]),v))
E_FATAL("%s: Bad version no. string: %s\n", file_name,
argval[i]);
#endif
n_gauden_present = (v > 1.1) ? 1 : 0;
}
else if (strcmp(argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free(argname, argval);
argname = argval = 0;
chksum = 0;
/* Read #gauden (if version matches) */
if (n_gauden_present) {
E_INFO("Reading number of codebooks from %s\n", file_name);
if (bio_fread
(&(s->n_gauden), sizeof(int32), 1, fp, byteswap, &chksum) != 1)
E_FATAL("fread(%s) (#gauden) failed\n", file_name);
}
/* Read 1d array data */
if (bio_fread_1d(&ptr, sizeof(uint32), &(s->n_sen), fp,
byteswap, &chksum) < 0) {
E_FATAL("bio_fread_1d(%s) failed\n", file_name);
}
s->mgau = (uint32*)ptr;
E_INFO("Mapping %d senones to %d codebooks\n", s->n_sen, s->n_gauden);
/* Infer n_gauden if not present in this version */
if (!n_gauden_present) {
s->n_gauden = 1;
for (i = 0; i <(int) s->n_sen; i++)
if (s->mgau[i] >= s->n_gauden)
s->n_gauden = s->mgau[i] + 1;
}
if (chksum_present)
bio_verify_chksum(fp, byteswap, chksum);
if (fread(&eofchk, 1, 1, fp) == 1)
E_FATAL("More data than expected in %s: %d\n", file_name, eofchk);
fclose(fp);
E_INFO("Read %d->%d senone-codebook mappings\n", s->n_sen,
s->n_gauden);
return 1;
}
static int32
gauden_param_read(vector_t **** out_param, /* Alloc space iff *out_param == NULL */
int32 * out_n_mgau,
int32 * out_n_feat,
int32 * out_n_density,
int32 ** out_veclen, const char *file_name)
{
char tmp;
FILE *fp;
int32 i, j, k, l, n, blk;
int32 n_mgau;
int32 n_feat;
int32 n_density;
int32 *veclen;
int32 byteswap, chksum_present;
vector_t ***out;
float32 *buf;
char **argname, **argval;
uint32 chksum;
E_INFO("Reading mixture gaussian parameter: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr(fp, &argname, &argval, &byteswap) < 0)
E_FATAL("bio_readhdr(%s) failed\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp(argname[i], "version") == 0) {
if (strcmp(argval[i], GAUDEN_PARAM_VERSION) != 0)
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], GAUDEN_PARAM_VERSION);
}
else if (strcmp(argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free(argname, argval);
argname = argval = NULL;
chksum = 0;
/* #Codebooks */
if (bio_fread(&n_mgau, sizeof(int32), 1, fp, byteswap, &chksum) != 1)
E_FATAL("fread(%s) (#codebooks) failed\n", file_name);
*out_n_mgau = n_mgau;
/* #Features/codebook */
if (bio_fread(&n_feat, sizeof(int32), 1, fp, byteswap, &chksum) != 1)
E_FATAL("fread(%s) (#features) failed\n", file_name);
*out_n_feat = n_feat;
/* #Gaussian densities/feature in each codebook */
if (bio_fread(&n_density, sizeof(int32), 1, fp, byteswap, &chksum) !=
1)
E_FATAL("fread(%s) (#density/codebook) failed\n", file_name);
*out_n_density = n_density;
/* #Dimensions in each feature stream */
veclen = ckd_calloc(n_feat, sizeof(uint32));
*out_veclen = veclen;
if (bio_fread(veclen, sizeof(int32), n_feat, fp, byteswap, &chksum) !=
n_feat)
E_FATAL("fread(%s) (feature-lengths) failed\n", file_name);
/* blk = total vector length of all feature streams */
for (i = 0, blk = 0; i < n_feat; i++)
blk += veclen[i];
/* #Floats to follow; for the ENTIRE SET of CODEBOOKS */
if (bio_fread(&n, sizeof(int32), 1, fp, byteswap, &chksum) != 1)
E_FATAL("fread(%s) (total #floats) failed\n", file_name);
if (n != n_mgau * n_density * blk) {
E_FATAL
("%s: #float32s(%d) doesn't match dimensions: %d x %d x %d\n",
file_name, n, n_mgau, n_density, blk);
}
/* Allocate memory for mixture gaussian densities if not already allocated */
if (!(*out_param)) {
out = (vector_t ***) ckd_calloc_3d(n_mgau, n_feat, n_density,
sizeof(vector_t));
buf = (float32 *) ckd_calloc(n, sizeof(float));
for (i = 0, l = 0; i < n_mgau; i++) {
for (j = 0; j < n_feat; j++) {
for (k = 0; k < n_density; k++) {
out[i][j][k] = &buf[l];
l += veclen[j];
}
}
}
}
else {
out = *out_param;
buf = out[0][0][0];
}
/* Read mixture gaussian densities data */
if (bio_fread(buf, sizeof(float32), n, fp, byteswap, &chksum) != n)
E_FATAL("fread(%s) (densitydata) failed\n", file_name);
if (chksum_present)
bio_verify_chksum(fp, byteswap, chksum);
if (fread(&tmp, 1, 1, fp) == 1)
E_FATAL("More data than expected in %s\n", file_name);
fclose(fp);
*out_param = out;
E_INFO("%d codebook, %d feature, size\n", n_mgau, n_feat);
for (i = 0; i < n_feat; i++)
printf(" %dx%d", n_density, veclen[i]);
printf("\n");
fflush(stdout);
return 0;
}
tmat_t *tmat_init (char *file_name, float64 tpfloor)
{
char tmp;
int32 n_src, n_dst;
FILE *fp;
int32 byteswap, chksum_present;
uint32 chksum;
float32 **tp;
int32 i, j, k, tp_per_tmat;
char **argname, **argval;
tmat_t *t;
E_INFO("Reading HMM transition probability matrices: %s\n", file_name);
t = (tmat_t *) ckd_calloc (1, sizeof(tmat_t));
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr (fp, &argname, &argval, &byteswap) < 0)
E_FATAL("bio_readhdr(%s) failed\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp (argname[i], "version") == 0) {
if (strcmp(argval[i], TMAT_PARAM_VERSION) != 0)
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], TMAT_PARAM_VERSION);
} else if (strcmp (argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free (argname, argval);
argname = argval = NULL;
chksum = 0;
/* Read #tmat, #from-states, #to-states, arraysize */
if ((bio_fread (&(t->n_tmat), sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&n_src, sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&n_dst, sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&i, sizeof(int32), 1, fp, byteswap, &chksum) != 1)) {
E_FATAL("bio_fread(%s) (arraysize) failed\n", file_name);
}
if (t->n_tmat >= MAX_S3TMATID)
E_FATAL("%s: #tmat (%d) exceeds limit (%d)\n", file_name, t->n_tmat, MAX_S3TMATID);
if (n_dst != n_src+1)
E_FATAL("%s: #from-states(%d) != #to-states(%d)-1\n", file_name, n_src, n_dst);
t->n_state = n_src;
if (i != t->n_tmat * n_src * n_dst) {
E_FATAL("%s: #float32s(%d) doesn't match dimensions: %d x %d x %d\n",
file_name, i, t->n_tmat, n_src, n_dst);
}
/* Allocate memory for tmat data */
t->tp = (int32 ***) ckd_calloc_3d (t->n_tmat, n_src, n_dst, sizeof(int32));
/* Temporary structure to read in the float data */
tp = (float32 **) ckd_calloc_2d (n_src, n_dst, sizeof(float32));
/* Read transition matrices, normalize and floor them, and convert to logs3 domain */
tp_per_tmat = n_src * n_dst;
for (i = 0; i < t->n_tmat; i++) {
if (bio_fread (tp[0], sizeof(float32), tp_per_tmat, fp,
byteswap, &chksum) != tp_per_tmat) {
E_FATAL("fread(%s) (arraydata) failed\n", file_name);
}
/* Normalize and floor */
for (j = 0; j < n_src; j++) {
if (vector_sum_norm (tp[j], n_dst) == 0.0)
E_ERROR("Normalization failed for tmat %d from state %d\n", i, j);
vector_nz_floor (tp[j], n_dst, tpfloor);
vector_sum_norm (tp[j], n_dst);
/* Convert to logs3. Take care of special case when tp = 0.0! */
for (k = 0; k < n_dst; k++)
t->tp[i][j][k] = (tp[j][k] == 0.0) ? S3_LOGPROB_ZERO : logs3(tp[j][k]);
}
}
ckd_free_2d ((void **) tp);
if (chksum_present)
bio_verify_chksum (fp, byteswap, chksum);
if (fread (&tmp, 1, 1, fp) == 1)
E_ERROR("Non-empty file beyond end of data\n");
fclose(fp);
E_INFO("Read %d transition matrices of size %dx%d\n",
t->n_tmat, t->n_state, t->n_state+1);
if (tmat_chk_uppertri (t) < 0)
E_FATAL("Tmat not upper triangular\n");
return t;
}
int
main(int32 argc, char *argv[])
{
char sent[16384];
cmd_ln_t *config;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
unlimit();
config = cmd_ln_get();
ctloffset = cmd_ln_int32_r(config, "-ctloffset");
sentfile = cmd_ln_str_r(config, "-insent");
if ((sentfp = fopen(sentfile, "r")) == NULL)
E_FATAL_SYSTEM("Failed to open file %s for reading", sentfile);
/* Note various output directories */
if (cmd_ln_str_r(config, "-s2stsegdir") != NULL)
s2stsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-s2stsegdir"));
if (cmd_ln_str_r(config, "-stsegdir") != NULL)
stsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-stsegdir"));
if (cmd_ln_str_r(config, "-phsegdir") != NULL)
phsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-phsegdir"));
if (cmd_ln_str_r(config, "-phlabdir") != NULL)
phlabdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-phlabdir"));
if (cmd_ln_str_r(config, "-wdsegdir") != NULL)
wdsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-wdsegdir"));
/* HACK! Pre-read insent without checking whether ctl could also
be read. In general, this is caused by the fact that we used
multiple files to specify resource in sphinx III. This is easy
to solve but currently I just to remove process_ctl because it
duplicates badly with ctl_process.
The call back function will take care of matching the uttfile
names. We don't need to worry too much about inconsistency.
*/
while (ctloffset > 0) {
if (fgets(sent, sizeof(sent), sentfp) == NULL) {
E_ERROR("EOF(%s)\n", sentfile);
break;
}
--ctloffset;
}
if ((outsentfile = cmd_ln_str_r(config, "-outsent")) != NULL) {
if ((outsentfp = fopen(outsentfile, "w")) == NULL)
E_FATAL_SYSTEM("Failed to open file %s for writing", outsentfile);
}
if ((outctlfile = cmd_ln_str_r(config, "-outctl")) != NULL) {
if ((outctlfp = fopen(outctlfile, "w")) == NULL)
E_FATAL_SYSTEM("Failed top open file %s for writing", outctlfile);
}
if ((cmd_ln_str_r(config, "-s2stsegdir") == NULL) &&
(cmd_ln_str_r(config, "-stsegdir") == NULL) &&
(cmd_ln_str_r(config, "-phlabdir") == NULL) &&
(cmd_ln_str_r(config, "-phsegdir") == NULL) &&
(cmd_ln_str_r(config, "-wdsegdir") == NULL) &&
(cmd_ln_str_r(config, "-outsent") == NULL))
E_FATAL("Missing output file/directory argument(s)\n");
/* Read in input databases */
models_init(config);
if (!feat)
feat = feat_array_alloc(kbcore_fcb(kbc), S3_MAX_FRAMES);
timers[tmr_utt].name = "U";
timers[tmr_gauden].name = "G";
timers[tmr_senone].name = "S";
timers[tmr_align].name = "A";
/* Initialize align module */
align_init(kbc->mdef, kbc->tmat, dict, config, kbc->logmath);
printf("\n");
if (cmd_ln_str_r(config, "-mllr") != NULL) {
if (kbc->mgau)
adapt_set_mllr(adapt_am, kbc->mgau, cmd_ln_str_r(config, "-mllr"), NULL,
kbc->mdef, config);
else if (kbc->ms_mgau)
model_set_mllr(kbc->ms_mgau, cmd_ln_str_r(config, "-mllr"), NULL, kbcore_fcb(kbc),
kbc->mdef, config);
else
E_WARN("Can't use MLLR matrices with .s2semi. yet\n");
}
tot_nfr = 0;
/* process_ctlfile (); */
if (cmd_ln_str_r(config, "-ctl")) {
/* When -ctlfile is speicified, corpus.c will look at -ctl_mllr to get
the corresponding MLLR for the utterance */
ctl_process(cmd_ln_str_r(config, "-ctl"),
NULL,
cmd_ln_str_r(config, "-ctl_mllr"),
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"),
utt_align, config);
}
else {
E_FATAL(" -ctl are not specified.\n");
}
if (tot_nfr > 0) {
printf("\n");
printf("TOTAL FRAMES: %8d\n", tot_nfr);
printf("TOTAL CPU TIME: %11.2f sec, %7.2f xRT\n",
tm_utt.t_tot_cpu, tm_utt.t_tot_cpu / (tot_nfr * 0.01));
printf("TOTAL ELAPSED TIME: %11.2f sec, %7.2f xRT\n",
tm_utt.t_tot_elapsed,
tm_utt.t_tot_elapsed / (tot_nfr * 0.01));
}
if (outsentfp)
fclose(outsentfp);
if (outctlfp)
fclose(outctlfp);
if (sentfp)
fclose(sentfp);
ckd_free(s2stsegdir);
ckd_free(stsegdir);
ckd_free(phsegdir);
ckd_free(wdsegdir);
feat_array_free(feat);
align_free();
models_free();
#if (! WIN32)
system("ps aguxwww | grep s3align");
#endif
cmd_ln_free_r(config);
return 0;
}
/* the following function is used for MMIE training
lqin 2010-03 */
static int
mmi_normalize()
{
uint32 i;
uint32 n_mgau;
uint32 n_stream;
uint32 n_density;
vector_t ***in_mean = NULL;
vector_t ***in_var = NULL;
vector_t ***wt_mean = NULL;
vector_t ***wt_var = NULL;
const uint32 *veclen = NULL;
const char **accum_dir;
const char *in_mean_fn;
const char *out_mean_fn;
const char *in_var_fn;
const char *out_var_fn;
vector_t ***wt_num_mean = NULL;
vector_t ***wt_den_mean = NULL;
vector_t ***wt_num_var = NULL;
vector_t ***wt_den_var = NULL;
float32 ***num_dnom = NULL;
float32 ***den_dnom = NULL;
uint32 n_num_mgau;
uint32 n_den_mgau;
uint32 n_num_stream;
uint32 n_den_stream;
uint32 n_num_density;
uint32 n_den_density;
float32 constE;
uint32 n_temp_mgau;
uint32 n_temp_stream;
uint32 n_temp_density;
const uint32 *temp_veclen = NULL;
accum_dir = cmd_ln_str_list("-accumdir");
/* the following variables are used for mmie training */
out_mean_fn = cmd_ln_str("-meanfn");
out_var_fn = cmd_ln_str("-varfn");
in_mean_fn = cmd_ln_str("-inmeanfn");
in_var_fn = cmd_ln_str("-invarfn");
constE = cmd_ln_float32("-constE");
/* get rid of some unnecessary parameters */
if (cmd_ln_int32("-fullvar")) {
E_FATAL("Current MMIE training can not be done for full variance, set -fulllvar as no\n");
}
if (cmd_ln_int32("-tiedvar")) {
E_FATAL("Current MMIE training can not be done for tied variance, set -tiedvar as no\n");
}
if (cmd_ln_str("-mixwfn")) {
E_FATAL("Current MMIE training does not support mixture weight update, remove -mixwfn \n");
}
if (cmd_ln_str("-inmixwfn")) {
E_FATAL("Current MMIE training does not support mixture weight update, remove -inmixwfn \n");
}
if (cmd_ln_str("-tmatfn")) {
E_FATAL("Current MMIE training does not support transition matrix update, remove -tmatfn \n");
}
if (cmd_ln_str("-regmatfn")) {
E_FATAL("Using norm for computing regression matrix is obsolete, please use mllr_transform \n");
}
/* must be at least one accum dir */
if (accum_dir[0] == NULL) {
E_FATAL("No accumulated reestimation path is specified, use -accumdir \n");
}
/* at least update mean or variance parameters */
if (out_mean_fn == NULL && out_var_fn == NULL) {
E_FATAL("Neither -meanfn nor -varfn is specified, at least do mean or variance update \n");
}
else if (out_mean_fn == NULL) {
E_INFO("No -meanfn specified, will skip if any\n");
}
else if (out_var_fn == NULL) {
E_INFO("No -varfn specified, will skip if any\n");
}
/* read input mean */
if (in_mean_fn != NULL) {
E_INFO("read original density mean parameters from %s\n", in_mean_fn);
if (s3gau_read(in_mean_fn,
&in_mean,
&n_mgau,
&n_stream,
&n_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_mean_fn);
}
ckd_free((void *)veclen);
veclen = NULL;
}
/* read input variance */
if (in_var_fn != NULL) {
E_INFO("read original density variance parameters from %s\n", in_var_fn);
if (s3gau_read(in_var_fn,
&in_var,
&n_mgau,
&n_stream,
&n_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
ckd_free((void *)veclen);
veclen = NULL;
}
/* read accumulated numerator and denominator counts */
for (i = 0; accum_dir[i]; i++) {
E_INFO("Reading and accumulating counts from %s\n", accum_dir[i]);
rdacc_mmie_den(accum_dir[i],
"numlat",
&wt_num_mean,
&wt_num_var,
&num_dnom,
&n_num_mgau,
&n_num_stream,
&n_num_density,
&veclen);
rdacc_mmie_den(accum_dir[i],
"denlat",
&wt_den_mean,
&wt_den_var,
&den_dnom,
&n_den_mgau,
&n_den_stream,
&n_den_density,
&veclen);
if (n_num_mgau != n_den_mgau)
E_FATAL("number of gaussians inconsistent between num and den lattice\n");
else if (n_num_mgau != n_mgau)
E_FATAL("number of gaussians inconsistent between imput model and accumulator (%u != %u)\n", n_mgau, n_num_mgau);
if (n_num_stream != n_den_stream)
E_FATAL("number of gaussian streams inconsistent between num and den lattice\n");
else if (n_num_stream != n_stream)
E_FATAL("number of gaussian streams inconsistent between imput model and accumulator (%u != %u)\n", n_stream, n_num_stream);
if (n_num_density != n_den_density)
E_FATAL("number of gaussian densities inconsistent between num and den lattice\n");
else if (n_num_density != n_density)
E_FATAL("number of gaussian densities inconsistent between imput model and accumulator (%u != %u)\n", n_density, n_num_density);
}
/* initialize update parameters as the input parameters */
if (out_mean_fn) {
if (s3gau_read(in_mean_fn,
&wt_mean,
&n_temp_mgau,
&n_temp_stream,
&n_temp_density,
&temp_veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_mean_fn);
}
ckd_free((void *)temp_veclen);
temp_veclen = NULL;
}
if (out_var_fn) {
if (s3gau_read(in_var_fn,
&wt_var,
&n_temp_mgau,
&n_temp_stream,
&n_temp_density,
&temp_veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
ckd_free((void *)temp_veclen);
temp_veclen = NULL;
}
/* update mean parameters */
if (wt_mean) {
if (out_mean_fn) {
E_INFO("Normalizing mean for n_mgau= %u, n_stream= %u, n_density= %u\n",
n_mgau, n_stream, n_density);
gauden_norm_wt_mmie_mean(in_mean, wt_mean, wt_num_mean, wt_den_mean,
in_var, wt_num_var, wt_den_var, num_dnom, den_dnom,
n_mgau, n_stream, n_density, veclen, constE);
}
else {
E_INFO("Ignoring means since -meanfn not specified\n");
}
}
else {
E_INFO("No means to normalize\n");
}
/* update variance parameters */
if (wt_var) {
if (out_var_fn) {
E_INFO("Normalizing variance for n_mgau= %u, n_stream= %u, n_density= %u\n",
n_mgau, n_stream, n_density);
gauden_norm_wt_mmie_var(in_var, wt_var, wt_num_var, wt_den_var, num_dnom, den_dnom,
in_mean, wt_mean, wt_num_mean, wt_den_mean,
n_mgau, n_stream, n_density, veclen, constE);
}
else {
E_INFO("Ignoring variances since -varfn not specified\n");
}
}
else {
E_INFO("No variances to normalize\n");
}
/* write the updated mean parameters to files */
if (out_mean_fn) {
if (wt_mean) {
if (s3gau_write(out_mean_fn,
(const vector_t ***)wt_mean,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
E_WARN("NO reestimated means seen, but -meanfn specified\n");
}
}
else {
if (wt_mean) {
E_INFO("Reestimated means seen, but -meanfn NOT specified\n");
}
}
/* write the updated variance parameters to files */
if (out_var_fn) {
if (wt_var) {
if (s3gau_write(out_var_fn,
(const vector_t ***)wt_var,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
E_WARN("NO reestimated variances seen, but -varfn specified\n");
}
}
else {
if (wt_var) {
E_INFO("Reestimated variances seen, but -varfn NOT specified\n");
}
}
if (veclen)
ckd_free((void *)veclen);
if (temp_veclen)
ckd_free((void *)temp_veclen);
return S3_SUCCESS;
}
/*
* Initialize phones (ci and triphones) and state->senone mappings from .mdef file.
*/
mdef_t *
mdef_init(const char *mdeffile, int32 breport)
{
FILE *fp;
int32 n_ci, n_tri, n_map, n;
char tag[1024], buf[1024];
s3senid_t **senmap;
/* s3senid_t *tempsenmap; */
s3pid_t p;
int32 s, ci, cd;
mdef_t *m;
if (!mdeffile)
E_FATAL("No mdef-file\n");
if (breport)
E_INFO("Reading model definition: %s\n", mdeffile);
m = (mdef_t *) ckd_calloc(1, sizeof(mdef_t)); /* freed in mdef_free */
if ((fp = fopen(mdeffile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", mdeffile);
if (noncomment_line(buf, sizeof(buf), fp) < 0)
E_FATAL("Empty file: %s\n", mdeffile);
if (strncmp(buf, MODEL_DEF_VERSION, strlen(MODEL_DEF_VERSION)) != 0)
E_FATAL("Version error: Expecing %s, but read %s\n",
MODEL_DEF_VERSION, buf);
/* Read #base phones, #triphones, #senone mappings defined in header */
n_ci = -1;
n_tri = -1;
n_map = -1;
m->n_ci_sen = -1;
m->n_sen = -1;
m->n_tmat = -1;
do {
if (noncomment_line(buf, sizeof(buf), fp) < 0)
E_FATAL("Incomplete header\n");
if ((sscanf(buf, "%d %s", &n, tag) != 2) || (n < 0))
E_FATAL("Error in header: %s\n", buf);
if (strcmp(tag, "n_base") == 0)
n_ci = n;
else if (strcmp(tag, "n_tri") == 0)
n_tri = n;
else if (strcmp(tag, "n_state_map") == 0)
n_map = n;
else if (strcmp(tag, "n_tied_ci_state") == 0)
m->n_ci_sen = n;
else if (strcmp(tag, "n_tied_state") == 0)
m->n_sen = n;
else if (strcmp(tag, "n_tied_tmat") == 0)
m->n_tmat = n;
else
E_FATAL("Unknown header line: %s\n", buf);
} while ((n_ci < 0) || (n_tri < 0) || (n_map < 0) ||
(m->n_ci_sen < 0) || (m->n_sen < 0) || (m->n_tmat < 0));
if ((n_ci == 0) || (m->n_ci_sen == 0) || (m->n_tmat == 0)
|| (m->n_ci_sen > m->n_sen))
E_FATAL("%s: Error in header\n", mdeffile);
/* Check typesize limits */
if (n_ci >= MAX_S3CIPID)
E_FATAL("%s: #CI phones (%d) exceeds limit (%d)\n", mdeffile, n_ci,
MAX_S3CIPID);
if (n_ci + n_tri >= MAX_S3PID)
E_FATAL("%s: #Phones (%d) exceeds limit (%d)\n", mdeffile,
n_ci + n_tri, MAX_S3PID);
if (m->n_sen >= MAX_S3SENID)
E_FATAL("%s: #senones (%d) exceeds limit (%d)\n", mdeffile,
m->n_sen, MAX_S3SENID);
if (m->n_tmat >= MAX_S3TMATID)
E_FATAL("%s: #tmats (%d) exceeds limit (%d)\n", mdeffile,
m->n_tmat, MAX_S3TMATID);
m->n_emit_state = (n_map / (n_ci + n_tri)) - 1;
if ((m->n_emit_state + 1) * (n_ci + n_tri) != n_map)
E_FATAL
("Header error: n_state_map not a multiple of n_ci*n_tri\n");
/* Initialize ciphone info */
m->n_ciphone = n_ci;
m->ciphone_ht = hash_table_new(n_ci, HASH_CASE_YES); /* With case-insensitive string names *//* freed in mdef_free */
m->ciphone = (ciphone_t *) ckd_calloc(n_ci, sizeof(ciphone_t)); /* freed in mdef_free */
/* Initialize phones info (ciphones + triphones) */
m->n_phone = n_ci + n_tri;
m->phone = (phone_t *) ckd_calloc(m->n_phone, sizeof(phone_t)); /* freed in mdef_free */
/* Allocate space for state->senone map for each phone */
senmap = (s3senid_t **) ckd_calloc_2d(m->n_phone, m->n_emit_state, sizeof(s3senid_t)); /* freed in mdef_free */
m->sseq = senmap; /* TEMPORARY; until it is compressed into just the unique ones */
/**CODE DUPLICATION!*****************************************************************************************************/
/* Flat decoder-specific */
/* Allocate space for state->senone map for each phone */
/* ARCHAN 20040820, this sacrifice readability and may cause pointer
problems in future. However, this is a less evil than
duplication of code. This is trick point all the state mapping
to the global mapping and avoid duplicated memory.
*/
/* S3 xwdpid_compress will compress the below list phone list.
*/
/* ARCHAN, this part should not be used when one of the recognizer is used. */
m->st2senmap =
(s3senid_t *) ckd_calloc(m->n_phone * m->n_emit_state,
sizeof(s3senid_t));
for (p = 0; p < m->n_phone; p++)
m->phone[p].state = m->st2senmap + (p * m->n_emit_state);
/******************************************************************************************************/
/* Allocate initial space for <ci,lc,rc,wpos> -> pid mapping */
m->wpos_ci_lclist = (ph_lc_t ***) ckd_calloc_2d(N_WORD_POSN, m->n_ciphone, sizeof(ph_lc_t *)); /* freed in mdef_free */
/*
* Read base phones and triphones. They'll simply be assigned a running sequence
* number as their "phone-id". If the phone-id < n_ci, it's a ciphone.
*/
/* Read base phones */
for (p = 0; p < n_ci; p++) {
if (noncomment_line(buf, sizeof(buf), fp) < 0)
E_FATAL("Premature EOF reading CIphone %d\n", p);
parse_base_line(m, buf, p);
}
m->sil = mdef_ciphone_id(m, S3_SILENCE_CIPHONE);
/* Read triphones, if any */
for (; p < m->n_phone; p++) {
if (noncomment_line(buf, sizeof(buf), fp) < 0)
E_FATAL("Premature EOF reading phone %d\n", p);
parse_tri_line(m, buf, p);
}
if (noncomment_line(buf, sizeof(buf), fp) >= 0)
E_ERROR("Non-empty file beyond expected #phones (%d)\n",
m->n_phone);
/* Build CD senones to CI senones map */
if (m->n_ciphone * m->n_emit_state != m->n_ci_sen)
E_FATAL
("#CI-senones(%d) != #CI-phone(%d) x #emitting-states(%d)\n",
m->n_ci_sen, m->n_ciphone, m->n_emit_state);
m->cd2cisen = (s3senid_t *) ckd_calloc(m->n_sen, sizeof(s3senid_t)); /* freed in mdef_free */
m->sen2cimap = (s3cipid_t *) ckd_calloc(m->n_sen, sizeof(s3cipid_t)); /* freed in mdef_free */
for (s = 0; s < m->n_sen; s++)
m->sen2cimap[s] = BAD_S3CIPID;
for (s = 0; s < m->n_ci_sen; s++) { /* CI senones */
m->cd2cisen[s] = (s3senid_t) s;
m->sen2cimap[s] = s / m->n_emit_state;
}
for (p = n_ci; p < m->n_phone; p++) { /* CD senones */
for (s = 0; s < m->n_emit_state; s++) {
cd = m->sseq[p][s];
ci = m->sseq[(int) m->phone[p].ci][s];
m->cd2cisen[cd] = (s3senid_t) ci;
m->sen2cimap[cd] = m->phone[p].ci;
}
}
sseq_compress(m);
fclose(fp);
return m;
}
int
main(int argc, char *argv[])
{
gauden_t *g;
const char *cb_basename[4];
char comment[1024];
time_t t;
parse_cmd_ln(argc, argv);
g = gauden_alloc();
gauden_set_min_var(*(float32 *)cmd_ln_access("-varfloor"));
cb_basename[0] = (const char *)cmd_ln_access("-cepcb");
cb_basename[1] = (const char *)cmd_ln_access("-dcepcb");
cb_basename[2] = (const char *)cmd_ln_access("-powcb");
cb_basename[3] = (const char *)cmd_ln_access("-2dcepcb");
s2_read_cb(g,
cmd_ln_access("-cbdir"),
cb_basename,
cmd_ln_access("-meanext"),
cmd_ln_access("-varext"),
TRUE, /* floor variances */
cmd_ln_access("-fixpowvar"));
t = time(NULL);
sprintf(comment,
"Generated on %s\nby %s.\nFrom codebooks in %s\n",
ctime(&t),
argv[0],
(const char *)cmd_ln_access("-cbdir"));
E_INFO("writing %s\n", cmd_ln_access("-meanfn"));
if (s3gau_write((const char *)cmd_ln_access("-meanfn"),
(const vector_t ***)gauden_mean(g),
gauden_n_mgau(g),
gauden_n_feat(g),
gauden_n_density(g),
gauden_veclen(g)) != S3_SUCCESS) {
E_FATAL_SYSTEM("could not write means file\n");
}
if (cmd_ln_access("-varfn")) {
E_INFO("Writing %s\n",
cmd_ln_access("-varfn"));
if (s3gau_write((const char *)cmd_ln_access("-varfn"),
(const vector_t ***)gauden_var(g),
gauden_n_mgau(g),
gauden_n_feat(g),
gauden_n_density(g),
gauden_veclen(g)) != S3_SUCCESS) {
E_FATAL_SYSTEM("could not write var file\n");
}
}
return 0;
}
/**
* Read LM dump (<lmname>.DMP) file and make it the current LM.
* Same interface as lm_read except that the filename refers to a .DMP file.
*/
lm_t *
lm_read_dump(const char *file, /**< The file name*/
int lminmemory, /**< Whether using in memory LM */
logmath_t *logmath,
int expect_dmp /**< Show error if header not found */
)
{
lm_t *lm;
lm = (lm_t *) ckd_calloc(1, sizeof(lm_t));
lm_null_struct(lm);
lm->isLM_IN_MEMORY = lminmemory;
lm->n_ng = 1;
lm->logmath = logmath;
if ((lm->fp = fopen(file, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", file);
/** Read header and compare byte order */
if (lm_read_dump_header(lm, file) == LM_FAIL) {
if (expect_dmp)
E_ERROR("Error in reading the header of the DUMP file. \n");
fclose(lm->fp);
ckd_free(lm);
return NULL;
}
/** Read the full path of file name of lm */
if (lm_read_lmfilename(lm, file) == LM_FAIL) {
E_ERROR("Error in reading the file name of lm. \n");
fclose(lm->fp);
ckd_free(lm);
return NULL;
}
/** Read the version number and number of unigram */
if (lm_read_dump_ver_nug(lm, file) == LM_FAIL) {
E_ERROR
("Error in reading the version name and number of unigram. \n");
fclose(lm->fp);
ckd_free(lm);
return NULL;
}
/** Reading the count of ngrams. */
if (lm_read_dump_ng_counts(lm, file) == LM_FAIL) {
E_ERROR("Error in reading the ngram counts. \n");
fclose(lm->fp);
ckd_free(lm);
return NULL;
}
lm->HT = hash_table_new(lm->n_ug, HASH_CASE_YES);
/** Reading the ngrams, the meat of the code. Also decide how
different versions of LM are read in.
*/
if (lm_read_dump_ng(lm, file) == LM_FAIL) {
E_ERROR("Error in reading the ngram. \n");
fclose(lm->fp);
hash_table_free(lm->HT);
ckd_free(lm);
return NULL;
}
return lm;
}
/**
Reading a regression map
*/
static int
s3map_read(const char *fn, /**< The file name */
void **out_map,
int32 * out_n_dom, int32 * out_n_rng, size_t map_elem_size)
{
uint32 rd_chksum = 0;
uint32 sv_chksum;
uint32 ignore;
char *ver;
char *do_chk;
FILE *fp;
int32 swap;
char **argname, **argval;
int i;
if ((fp = fopen(fn, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", fn);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr(fp, &argname, &argval, &swap) < 0)
E_FATAL("bio_readhdr(%s) failed\n", fn);
/* Parse argument-value list */
ver = do_chk = NULL;
for (i = 0; argname[i]; i++) {
if (strcmp(argname[i], "version") == 0) {
if (strcmp(argval[i], MAP_FILE_VERSION) != 0) {
E_FATAL("Version mismatch(%s): %s, expecting %s\n",
fn, argval[i], MAP_FILE_VERSION);
}
ver = argval[i];
}
else if (strcmp(argname[i], "chksum0") == 0) {
do_chk = argval[i];
}
}
if (ver == NULL)
E_FATAL("No version attribute for %s\n", fn);
bio_hdrarg_free(argname, argval);
argname = argval = NULL;
if (bio_fread(out_n_rng, sizeof(uint32), 1, fp, swap, &rd_chksum) != 1) {
fclose(fp);
return S3_ERROR;
}
if (bio_fread_1d(out_map,
map_elem_size, out_n_dom, fp, swap, &rd_chksum) < 0) {
fclose(fp);
return S3_ERROR;
}
if (do_chk) {
if (bio_fread(&sv_chksum, sizeof(uint32), 1, fp, swap, &ignore) !=
1) {
fclose(fp);
return S3_ERROR;
}
if (sv_chksum != rd_chksum) {
E_FATAL("Checksum error; read corrupted data.\n");
}
}
E_INFO("Read %s [%u mappings to %u]\n", fn, *out_n_dom, *out_n_rng);
return S3_SUCCESS;
}
ptmr_t
ctl_process(const char *ctlfile, const char *ctllmfile, const char *ctlmllrfile, int32 nskip,
int32 count, void (*func) (void *kb, utt_res_t * ur, int32 sf,
int32 ef, char *uttid), void *kb)
{
FILE *fp;
FILE *ctllmfp;
FILE *ctlmllrfp;
char uttfile[16384], uttid[4096];
char lmname[4096];
char regmatname[4096], cb2mllrname[4096];
char tmp[4096];
int32 sf, ef;
utt_res_t *ur;
ptmr_t tm;
kb_t *k;
k = (kb_t *) kb;
ctllmfp = NULL;
ctlmllrfp = NULL;
ur = new_utt_res();
if (ctlfile) {
if ((fp = fopen(ctlfile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", ctlfile);
}
else
fp = stdin;
if (ctllmfile) {
E_INFO("LM is used in this session\n");
if ((ctllmfp = fopen(ctllmfile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", ctllmfile);
}
if (ctlmllrfile) {
E_INFO("MLLR is used in this session\n");
if ((ctlmllrfp = fopen(ctlmllrfile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", ctlmllrfile);
}
ptmr_init(&tm);
if (nskip > 0) {
E_INFO("Skipping %d entries at the beginning of %s\n", nskip,
ctlfile);
for (; nskip > 0; --nskip) {
if (ctl_read_entry(fp, uttfile, &sf, &ef, uttid) < 0) {
fclose(fp);
return tm;
}
/*This checks the size of the control file of the lm in batch mode */
if (ctllmfile) {
if (ctl_read_entry(ctllmfp, lmname, &sf, &ef, tmp) < 0) {
fclose(ctllmfp);
E_ERROR
("An LM control file is specified but LM cannot be read when skipping the %d-th sentence\n",
nskip);
return tm;
}
}
/*This checks the size of the control file of the mllr in batch mode */
if (ctlmllrfile) {
if (ctl_read_entry(ctlmllrfp, regmatname, &sf, &ef, tmp) <
0) {
fclose(ctlmllrfp);
E_ERROR
("A MLLR control file is specified but MLLR cannot be read when skipping the %d-th sentence\n",
nskip);
return tm;
}
}
}
}
for (; count > 0; --count) {
int32 tmp1, tmp2;
if (ctl_read_entry(fp, uttfile, &sf, &ef, uttid) < 0)
break;
/*This checks the size of the control file in batch mode */
if (ctllmfile) {
if (ctl_read_entry(ctllmfp, lmname, &tmp1, &tmp2, tmp) < 0) {
fclose(ctllmfp);
E_ERROR
("LM control file is specified but LM cannot be read when counting the %d-th sentence\n",
count);
break;
}
}
if (ctlmllrfile) {
if (ctl_read_entry
(ctlmllrfp, regmatname, &tmp1, &tmp2, cb2mllrname) < 0) {
E_ERROR
("MLLR control file is specified but MLLR cannot be read when counting the %d-th sentence\n",
count);
break;
}
if (tmp2 == -1)
strcpy(cb2mllrname, ".1cls.");
}
/* Process this utterance */
ptmr_start(&tm);
if (func) {
utt_res_set_uttfile(ur, uttfile);
if (ctllmfile)
utt_res_set_lmname(ur, lmname);
if (ctlmllrfile) {
utt_res_set_regmatname(ur, regmatname);
utt_res_set_cb2mllrname(ur, cb2mllrname);
}
(*func) (kb, ur, sf, ef, uttid);
}
ptmr_stop(&tm);
E_INFO
("%s: %6.1f sec CPU, %6.1f sec Clk; TOT: %8.1f sec CPU, %8.1f sec Clk\n\n",
uttid, tm.t_cpu, tm.t_elapsed, tm.t_tot_cpu,
tm.t_tot_elapsed);
ptmr_reset(&tm);
}
if (fp)
fclose(fp);
if (ctllmfp)
fclose(ctllmfp);
if (ctlmllrfp)
fclose(ctlmllrfp);
if (ur)
ckd_free(ur);
return tm;
}
ptmr_t
ctl_process(char *ctlfile, char *ctlmllrfile, int32 nskip, int32 count,
void (*func) (void *kb, char *uttfile, int32 sf, int32 ef,
char *uttid), void *kb)
{
FILE *fp, *mllrfp;
char uttfile[16384], uttid[4096];
char regmatfile[4096], cb2mllrfile[4096];
int32 sf, ef;
ptmr_t tm;
mllrfp = NULL;
E_INFO("Batch mode recognition without dynamic LM\n");
if (ctlfile) {
if ((fp = fopen(ctlfile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", ctlfile);
}
else
fp = stdin;
if (ctlmllrfile) {
if ((mllrfp = fopen(ctlmllrfile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", ctlmllrfile);
}
ptmr_init(&tm);
if (nskip > 0) {
E_INFO("Skipping %d entries at the beginning of %s\n", nskip,
ctlfile);
for (; nskip > 0; --nskip) {
if (ctl_read_entry(fp, uttfile, &sf, &ef, uttid) < 0) {
fclose(fp);
return tm;
}
}
if (ctlmllrfile) {
for (; nskip > 0; --nskip) {
if (ctl_read_entry(fp, regmatfile, &sf, &ef, cb2mllrfile) <
0) {
E_ERROR
("MLLR cannot be read when skipping the %d-th sentence\n",
nskip);
fclose(fp);
return tm;
}
}
}
}
for (; count > 0; --count) {
if (ctl_read_entry(fp, uttfile, &sf, &ef, uttid) < 0)
break;
if (ctlmllrfile) {
int32 tmp1, tmp2;
if (ctl_read_entry
(mllrfp, regmatfile, &tmp1, &tmp2, cb2mllrfile) < 0) {
E_ERROR
("MLLR cannot be read when counting the %d-th sentence\n",
count);
break;
}
if (tmp2 == -1)
strcpy(cb2mllrfile, ".1cls.");
}
/* Process this utterance */
ptmr_start(&tm);
if (func) {
if (ctlmllrfile)
kb_setmllr(regmatfile, cb2mllrfile, kb);
(*func) (kb, uttfile, sf, ef, uttid);
}
ptmr_stop(&tm);
E_INFO
("%s: %6.1f sec CPU, %6.1f sec Clk; TOT: %8.1f sec CPU, %8.1f sec Clk\n\n",
uttid, tm.t_cpu, tm.t_elapsed, tm.t_tot_cpu,
tm.t_tot_elapsed);
ptmr_reset(&tm);
}
if (fp)
fclose(fp);
return tm;
}
corpus_t *
corpus_load_tailid(const char *file,
int32(*validate) (char *str),
int32(*dup_resolve) (char *s1, char *s2))
{
FILE *fp;
char line[16384], uttid[4096], *id;
int32 j, m, n;
corpus_t *corp;
E_INFO("Loading corpus (%s)\n", file);
if ((fp = fopen(file, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", file);
corp = (corpus_t *) ckd_calloc(1, sizeof(corpus_t));
n = 0;
while (fgets(line, sizeof(line), fp) != NULL) {
/* Skip empty lines */
if (sscanf(line, "%s", uttid) == 1)
n++;
}
rewind(fp);
corp->ht = hash_table_new(n, HASH_CASE_YES);
corp->n = 0;
corp->str = (char **) ckd_calloc(n, sizeof(char *));
n = 0;
while (fgets(line, sizeof(line), fp) != NULL) {
/* Skip blank lines */
if (sscanf(line, "%s", uttid) < 1)
continue;
/* Look for a (uttid) at the end */
if (sep_tailid(line, uttid) < 0)
E_FATAL("corpus_load_tailid(%s) failed; bad line: %s\n", file,
line);
/* Validate if a validation function is given */
if (validate && (!(*validate) (line))) {
E_INFO("Corpus validation %s failed; skipping\n", uttid);
continue;
}
id = ckd_salloc(uttid);
if ((m = (long) hash_table_enter(corp->ht, id, (void *)(long)n)) != n) {
/* Duplicate entry */
if (!dup_resolve)
E_FATAL
("corpus_load_tailid(%s) failed; duplicate ID: %s\n",
file, id);
else {
/* Invoke the application provided duplicate resolver function */
if ((j = (*dup_resolve) (corp->str[m], line)) < 0)
E_FATAL
("corpus_load(tailid(%s) failed; duplicate ID: %s\n",
file, id);
ckd_free(id);
if (j > 0) {
/* Overwrite the original with the new entry */
ckd_free(corp->str[m]);
corp->str[m] = ckd_salloc(line);
}
else {
/* Retain the original entry, discard the new one */
}
}
}
else {
/* Fill in new entry */
corp->str[n] = ckd_salloc(line);
n++;
}
}
corp->n = n;
fclose(fp);
E_INFO("%s: %d entries\n", file, n);
return corp;
}
int
main(int argc, char *argv[])
{
char const *cfg;
int i;
int16 buf[2048];
if (argc == 2) {
config = cmd_ln_parse_file_r(NULL, cont_args_def, argv[1], TRUE);
}
else {
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, FALSE);
}
/* Handle argument file as -argfile. */
if (config && (cfg = cmd_ln_str_r(config, "-argfile")) != NULL) {
config = cmd_ln_parse_file_r(config, cont_args_def, cfg, FALSE);
}
if (config == NULL)
return 1;
singlefile = cmd_ln_boolean_r(config, "-singlefile");
if ((infile_path = cmd_ln_str_r(config, "-infile")) != NULL) {
if ((infile = fopen(infile_path, "rb")) == NULL) {
E_FATAL_SYSTEM("Failed to read audio from '%s'", infile_path);
return 1;
}
read_audio = &read_audio_file;
/* skip wav header */
read_audio(buf, 44);
}
else {
if ((ad = ad_open_dev(cmd_ln_str_r(config, "-adcdev"),
(int) cmd_ln_float32_r(config,
"-samprate"))) ==
NULL) {
E_FATAL("Failed to open audio device\n");
return 1;
}
read_audio = &read_audio_adev;
printf("Start recording ...\n");
fflush(stdout);
if (ad_start_rec(ad) < 0)
E_FATAL("Failed to start recording\n");
/* TODO remove this thing */
for (i = 0; i < 5; i++) {
sleep_msec(200);
read_audio(buf, 2048);
}
printf("You may speak now\n");
fflush(stdout);
}
fe = fe_init_auto_r(config);
if (fe == NULL)
return 1;
segment_audio();
if (ad)
ad_close(ad);
if (infile)
fclose(infile);
fe_free(fe);
cmd_ln_free_r(config);
return 0;
}
cmd_ln_t *
cmd_ln_parse_r(cmd_ln_t *inout_cmdln, const arg_t * defn, int32 argc, char *argv[], int strict)
{
int32 i, j, n, argstart;
hash_table_t *defidx = NULL;
cmd_ln_t *cmdln;
/* Construct command-line object */
if (inout_cmdln == NULL) {
cmdln = (cmd_ln_t*)ckd_calloc(1, sizeof(*cmdln));
cmdln->refcount = 1;
}
else
cmdln = inout_cmdln;
/* Build a hash table for argument definitions */
defidx = hash_table_new(50, 0);
if (defn) {
for (n = 0; defn[n].name; n++) {
void *v;
v = hash_table_enter(defidx, defn[n].name, (void *)&defn[n]);
if (strict && (v != &defn[n])) {
E_ERROR("Duplicate argument name in definition: %s\n", defn[n].name);
goto error;
}
}
}
else {
/* No definitions. */
n = 0;
}
/* Allocate memory for argument values */
if (cmdln->ht == NULL)
cmdln->ht = hash_table_new(n, 0 /* argument names are case-sensitive */ );
/* skip argv[0] if it doesn't start with dash */
argstart = 0;
if (argc > 0 && argv[0][0] != '-') {
argstart = 1;
}
/* Parse command line arguments (name-value pairs) */
for (j = argstart; j < argc; j += 2) {
arg_t *argdef;
cmd_ln_val_t *val;
void *v;
if (hash_table_lookup(defidx, argv[j], &v) < 0) {
if (strict) {
E_ERROR("Unknown argument name '%s'\n", argv[j]);
goto error;
}
else if (defn == NULL)
v = NULL;
else
continue;
}
argdef = (arg_t *)v;
/* Enter argument value */
if (j + 1 >= argc) {
cmd_ln_print_help_r(cmdln, stderr, defn);
E_ERROR("Argument value for '%s' missing\n", argv[j]);
goto error;
}
if (argdef == NULL)
val = cmd_ln_val_init(ARG_STRING, argv[j + 1]);
else {
if ((val = cmd_ln_val_init(argdef->type, argv[j + 1])) == NULL) {
cmd_ln_print_help_r(cmdln, stderr, defn);
E_ERROR("Bad argument value for %s: %s\n", argv[j],
argv[j + 1]);
goto error;
}
}
if ((v = hash_table_enter(cmdln->ht, argv[j], (void *)val)) !=
(void *)val)
{
if (strict) {
cmd_ln_val_free(val);
E_ERROR("Duplicate argument name in arguments: %s\n",
argdef->name);
goto error;
}
else {
v = hash_table_replace(cmdln->ht, argv[j], (void *)val);
cmd_ln_val_free((cmd_ln_val_t *)v);
}
}
}
/* Fill in default values, if any, for unspecified arguments */
for (i = 0; i < n; i++) {
cmd_ln_val_t *val;
void *v;
if (hash_table_lookup(cmdln->ht, defn[i].name, &v) < 0) {
if ((val = cmd_ln_val_init(defn[i].type, defn[i].deflt)) == NULL) {
E_ERROR
("Bad default argument value for %s: %s\n",
defn[i].name, defn[i].deflt);
goto error;
}
hash_table_enter(cmdln->ht, defn[i].name, (void *)val);
}
}
/* Check for required arguments; exit if any missing */
j = 0;
for (i = 0; i < n; i++) {
if (defn[i].type & ARG_REQUIRED) {
void *v;
if (hash_table_lookup(cmdln->ht, defn[i].name, &v) != 0)
E_ERROR("Missing required argument %s\n", defn[i].name);
}
}
if (j > 0) {
cmd_ln_print_help_r(cmdln, stderr, defn);
goto error;
}
if (strict && argc == 1) {
E_ERROR("No arguments given, available options are:\n");
cmd_ln_print_help_r(cmdln, stderr, defn);
if (defidx)
hash_table_free(defidx);
if (inout_cmdln == NULL)
cmd_ln_free_r(cmdln);
return NULL;
}
#ifndef _WIN32_WCE
/* Set up logging. We need to do this earlier because we want to dump
* the information to the configured log, not to the stderr. */
if (cmd_ln_exists_r(cmdln, "-logfn") && cmd_ln_str_r(cmdln, "-logfn")) {
if (err_set_logfile(cmd_ln_str_r(cmdln, "-logfn")) < 0)
E_FATAL_SYSTEM("cannot redirect log output");
}
/* Echo command line */
E_INFO("Parsing command line:\n");
for (i = 0; i < argc; i++) {
if (argv[i][0] == '-')
E_INFOCONT("\\\n\t");
E_INFOCONT("%s ", argv[i]);
}
E_INFOCONT("\n\n");
/* Print configuration */
E_INFOCONT("Current configuration:\n");
arg_dump_r(cmdln, err_get_logfp(), defn, 0);
#endif
hash_table_free(defidx);
return cmdln;
error:
if (defidx)
hash_table_free(defidx);
if (inout_cmdln == NULL)
cmd_ln_free_r(cmdln);
E_ERROR("Failed to parse arguments list\n");
return NULL;
}
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;
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_SYSTEM("Failed to open '%s' for reading", 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
main(int argc, char *argv[])
{
cmd_ln_t *config;
ps_decoder_t *ps;
int32 out_score;
const char *input_file_path;
const char *cfg;
const char *utt_id;
const char *hyp;
FILE *input_file;
int16 buf[PCM_BUF_LEN];
int k;
config = cmd_ln_parse_r(NULL, cont_args_def, argc, argv, TRUE);
/* Handle argument file as -argfile. */
if (config && (cfg = cmd_ln_str_r(config, "-argfile")) != NULL) {
config = cmd_ln_parse_file_r(config, cont_args_def, cfg, FALSE);
}
if (config == NULL)
return 1;
if (cmd_ln_str_r(config, "-kws") == NULL && cmd_ln_str_r(config, "-keyphrase") == NULL) {
E_ERROR("Keyword is missing. Use -keyphrase <keyphrase> or -kws <kws_file> to specify the phrase to look for.");
return 1;
}
input_file_path = cmd_ln_str_r(config, "-infile");
if (input_file_path == NULL) {
E_ERROR("Input file is missing. Use -infile <input_file> to specify the file to look in.\n");
return 1;
}
ps_default_search_args(config);
ps = ps_init(config);
if (ps == NULL) {
E_ERROR("Failed to create the decoder\n");
return 1;
}
input_file = fopen(input_file_path, "rb");
if (input_file == NULL) {
E_FATAL_SYSTEM("Failed to open input file '%s'", input_file_path);
}
ps_start_utt(ps, NULL);
if (cmd_ln_boolean_r(config, "-adcin")) {
fread(buf, 1, 44, input_file);
while ((k = fread(buf, sizeof(int16), PCM_BUF_LEN, input_file)) > 0) {
ps_process_raw(ps, buf, k, FALSE, FALSE);
}
} else {
mfcc_t **mfcs;
int nfr;
if (NULL == (mfcs = read_mfc_file(input_file, &nfr, cmd_ln_int32_r(config, "-ceplen")))) {
E_ERROR("Failed to read MFCC from the file '%s'\n", input_file_path);
fclose(input_file);
return -1;
}
ps_process_cep(ps, mfcs, nfr, FALSE, TRUE);
ckd_free_2d(mfcs);
}
ps_end_utt(ps);
hyp = ps_get_hyp(ps, &out_score, &utt_id);
printf("hypothesis: %s\n", hyp);
fflush(stdout);
fclose(input_file);
ps_free(ps);
cmd_ln_free_r(config);
return 0;
}
static int32 gauden_param_read(float32 *****out_param,
int32 *out_n_mgau,
int32 *out_n_feat,
int32 *out_n_density,
int32 **out_veclen,
const char *file_name)
{
char version[1024], tmp;
FILE *fp;
int32 i, j, k, l, blk, n;
int32 n_mgau;
int32 n_feat;
int32 n_density;
int32 *veclen;
int32 needs_reorder;
float32 ****out;
float32 *buf;
E_INFO("Reading mixture gaussian parameter: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", file_name);
if (fscanf(fp, "%s", version) != 1)
E_FATAL("Unable to read version id\n");
if (strcmp(version, GAUDEN_PARAM_VERSION) != 0)
E_FATAL("Version mismatch: %s, expecting %s\n", version, GAUDEN_PARAM_VERSION);
if (bcomment_read(fp) != S3_SUCCESS)
E_FATAL("bcomment_read() failed\n");
if ((needs_reorder = swap_check(fp)) < 0)
E_FATAL("swap_check() failed\n");
/* #Codebooks */
if (fread_retry(&n_mgau, sizeof(uint32), 1, fp) != 1)
E_FATAL("Error reading #codebooks\n");
if (needs_reorder) {
SWAP_INT32(&n_mgau);
}
*out_n_mgau = n_mgau;
/* #Features/codebook */
if (fread_retry(&n_feat, sizeof(uint32), 1, fp) != 1)
E_FATAL("Error reading #features/codebook\n");
if (needs_reorder) {
SWAP_INT32(&n_feat);
}
*out_n_feat = n_feat;
/* #Gaussian densities/feature in each codebook */
if (fread_retry(&n_density, sizeof(uint32), 1, fp) != 1)
E_FATAL("Error reading #densities/codebook-feature\n");
if (needs_reorder) {
SWAP_INT32(&n_density);
}
*out_n_density = n_density;
/* #Dimensions in each feature stream */
veclen = ckd_calloc(n_feat, sizeof(uint32));
*out_veclen = veclen;
if (fread_retry(veclen, sizeof(uint32), n_feat, fp) != n_feat)
E_FATAL("Error reading feature vector lengths\n");
if (needs_reorder) {
for (i = 0; i < n_feat; i++)
SWAP_INT32(&veclen[i]);
}
/* blk = total vector length of all feature streams */
for (i = 0, blk = 0; i < n_feat; i++)
blk += veclen[i];
/* #Floats to follow; for the ENTIRE SET of CODEBOOKS */
if (fread_retry(&n, sizeof(uint32), 1, fp) != 1)
E_FATAL("Error reading #floats\n");
if (needs_reorder) {
SWAP_INT32(&n);
}
assert(n == n_mgau * n_density * blk);
/* Allocate memory for mixture gaussian densities */
out = (float32 ****) ckd_calloc_3d (n_mgau, n_feat, n_density,
sizeof(float32 *));
buf = (float32 *) ckd_calloc (n, sizeof(float));
for (i = 0, l = 0; i < n_mgau; i++) {
for (j = 0; j < n_feat; j++) {
for (k = 0; k < n_density; k++) {
out[i][j][k] = &buf[l];
l += veclen[j];
}
}
}
/* Read mixture gaussian densities data */
if (fread_retry (buf, sizeof(float32), n, fp) != n)
E_FATAL("Error reading gaussian data\n");
if (needs_reorder)
for (i = 0; i < n; i++)
SWAP_FLOAT32(&buf[i]);
E_INFO("%d codebook, %d feature, size",
n_mgau, n_feat);
for (i = 0; i < n_feat; i++)
printf (" %dx%d", n_density, veclen[i]);
printf ("\n");
if (fread (&tmp, 1, 1, fp) == 1)
E_WARN("Non-empty file beyond end of data\n");
*out_param = out;
fclose(fp);
return 0;
}
dict_t *dict_init (mdef_t *mdef, char *dictfile, char *fillerfile, char comp_sep)
{
FILE *fp, *fp2;
int32 n ;
char line[1024];
dict_t *d;
if (! dictfile)
E_FATAL("No dictionary file\n");
/*
* First obtain #words in dictionary (for hash table allocation).
* Reason: The PC NT system doesn't like to grow memory gradually. Better to allocate
* all the required memory in one go.
*/
if ((fp = fopen(dictfile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", dictfile);
n = 0;
while (fgets (line, sizeof(line), fp) != NULL) {
if (line[0] != '#')
n++;
}
rewind (fp);
if (fillerfile) {
if ((fp2 = fopen(fillerfile, "r")) == NULL)
E_FATAL_SYSTEM("fopen(%s,r) failed\n", fillerfile);
while (fgets (line, sizeof(line), fp2) != NULL) {
if (line[0] != '#')
n++;
}
rewind (fp2);
}
/*
* Allocate dict entries. HACK!! Allow some extra entries for words not in file.
* Also check for type size restrictions.
*/
d = (dict_t *) ckd_calloc (1, sizeof(dict_t));
d->max_words = (n+1024 < MAX_WID) ? n+1024 : MAX_WID;
if (n >= MAX_WID)
E_FATAL("#Words in dictionaries (%d) exceeds limit (%d)\n", n, MAX_WID);
d->word = (dictword_t *) ckd_calloc (d->max_words, sizeof(dictword_t));
d->n_word = 0;
d->mdef = mdef;
if (mdef) {
d->pht = NULL;
d->ciphone_str = NULL;
} else {
d->pht = hash_new (DEFAULT_NUM_PHONE, 1 /* No case */);
d->ciphone_str = (char **) ckd_calloc (DEFAULT_NUM_PHONE, sizeof(char *));
}
d->n_ciphone = 0;
/* Create new hash table for word strings; case-insensitive word strings */
d->ht = hash_new (d->max_words, 1 /* no-case */);
/* Initialize with no compound words */
d->comp_head = NULL;
/* Digest main dictionary file */
E_INFO("Reading main dictionary: %s\n", dictfile);
dict_read (fp, d);
fclose (fp);
E_INFO("%d words read\n", d->n_word);
/* Now the filler dictionary file, if it exists */
d->filler_start = d->n_word;
if (fillerfile) {
E_INFO("Reading filler dictionary: %s\n", fillerfile);
dict_read (fp2, d);
fclose (fp2);
E_INFO("%d words read\n", d->n_word - d->filler_start);
}
d->filler_end = d->n_word-1;
/* Initialize distinguished word-ids */
d->startwid = dict_wordid (d, START_WORD);
d->finishwid = dict_wordid (d, FINISH_WORD);
d->silwid = dict_wordid (d, SILENCE_WORD);
if (NOT_WID(d->startwid))
E_WARN("%s not in dictionary\n", START_WORD);
if (NOT_WID(d->finishwid))
E_WARN("%s not in dictionary\n", FINISH_WORD);
if (NOT_WID(d->silwid))
E_WARN("%s not in dictionary\n", SILENCE_WORD);
/* Identify compound words if indicated */
if (comp_sep) {
E_INFO("Building compound words (separator = '%c')\n", comp_sep);
n = dict_build_comp (d, comp_sep);
E_INFO("%d compound words\n", n);
}
return d;
}
static int
normalize()
{
char file_name[MAXPATHLEN+1];
float32 ***mixw_acc = NULL;
float32 ***in_mixw = NULL;
float64 s;
uint32 n_mixw;
uint32 n_stream;
uint32 n_mllr_class;
uint32 n_density;
float32 ***tmat_acc = NULL;
uint32 n_tmat;
uint32 n_state_pm;
uint32 i, j, k;
vector_t ***in_mean = NULL;
vector_t ***wt_mean = NULL;
vector_t ***in_var = NULL;
vector_t ***wt_var = NULL;
vector_t ****in_fullvar = NULL;
vector_t ****wt_fullvar = NULL;
int32 pass2var = FALSE;
int32 var_is_full = FALSE;
float32 ***dnom = NULL;
uint32 n_mgau;
uint32 n_gau_stream;
uint32 n_gau_density;
const uint32 *veclen = NULL;
const char **accum_dir;
const char *oaccum_dir;
const char *in_mixw_fn;
const char *out_mixw_fn;
const char *out_tmat_fn;
const char *in_mean_fn;
const char *out_mean_fn;
const char *in_var_fn;
const char *out_var_fn;
const char *out_dcount_fn;
int err;
uint32 mllr_mult;
uint32 mllr_add;
float32 *****regl = NULL;
float32 ****regr = NULL;
uint32 no_retries=0;
accum_dir = cmd_ln_str_list("-accumdir");
oaccum_dir = cmd_ln_str("-oaccumdir");
out_mixw_fn = cmd_ln_str("-mixwfn");
out_tmat_fn = cmd_ln_str("-tmatfn");
out_mean_fn = cmd_ln_str("-meanfn");
out_var_fn = cmd_ln_str("-varfn");
in_mixw_fn = cmd_ln_str("-inmixwfn");
in_mean_fn = cmd_ln_str("-inmeanfn");
in_var_fn = cmd_ln_str("-invarfn");
out_dcount_fn = cmd_ln_str("-dcountfn");
var_is_full = cmd_ln_int32("-fullvar");
/* must be at least one accum dir */
assert(accum_dir[0] != NULL);
if (out_mixw_fn == NULL) {
E_INFO("No -mixwfn specified, will skip if any\n");
}
if (out_tmat_fn == NULL) {
E_INFO("No -tmatfn specified, will skip if any\n");
}
if (out_mean_fn == NULL) {
E_INFO("No -meanfn specified, will skip if any\n");
}
if (out_var_fn == NULL) {
E_INFO("No -varfn specified, will skip if any\n");
}
if (in_mixw_fn != NULL) {
E_INFO("Selecting unseen mixing weight parameters from %s\n",
in_mixw_fn);
}
if (in_mean_fn != NULL) {
E_INFO("Selecting unseen density mean parameters from %s\n",
in_mean_fn);
if (s3gau_read(in_mean_fn,
&in_mean,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_mean_fn);
}
ckd_free((void *)veclen);
veclen = NULL;
}
if (in_var_fn != NULL) {
E_INFO("Selecting unseen density variance parameters from %s\n",
in_var_fn);
if (var_is_full) {
if (s3gau_read_full(in_var_fn,
&in_fullvar,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
}
else {
if (s3gau_read(in_var_fn,
&in_var,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
}
ckd_free((void *)veclen);
veclen = NULL;
}
n_stream = 0;
for (i = 0; accum_dir[i]; i++) {
E_INFO("Reading and accumulating counts from %s\n", accum_dir[i]);
if (out_mixw_fn) {
rdacc_mixw(accum_dir[i],
&mixw_acc, &n_mixw, &n_stream, &n_density);
}
if (out_tmat_fn) {
rdacc_tmat(accum_dir[i],
&tmat_acc, &n_tmat, &n_state_pm);
}
if (out_mean_fn || out_var_fn) {
if (var_is_full)
rdacc_den_full(accum_dir[i],
&wt_mean,
&wt_fullvar,
&pass2var,
&dnom,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen);
else
rdacc_den(accum_dir[i],
&wt_mean,
&wt_var,
&pass2var,
&dnom,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen);
if (out_mixw_fn) {
if (n_stream != n_gau_stream) {
E_ERROR("mixw inconsistent w/ densities WRT # "
"streams (%u != %u)\n",
n_stream, n_gau_stream);
}
if (n_density != n_gau_density) {
E_ERROR("mixw inconsistent w/ densities WRT # "
"den/mix (%u != %u)\n",
n_density, n_gau_density);
}
}
else {
n_stream = n_gau_stream;
n_density = n_gau_density;
}
}
}
if (oaccum_dir && mixw_acc) {
/* write the total mixing weight reest. accumulators */
err = 0;
sprintf(file_name, "%s/mixw_counts", oaccum_dir);
if (in_mixw_fn) {
if (s3mixw_read(in_mixw_fn,
&in_mixw,
&i,
&j,
&k) != S3_SUCCESS) {
E_FATAL_SYSTEM("Unable to read %s", in_mixw_fn);
}
if (i != n_mixw) {
E_FATAL("# mixw in input mixw file != # mixw in output mixw file\n");
}
if (j != n_stream) {
E_FATAL("# stream in input mixw file != # stream in output mixw file\n");
}
if (k != n_density) {
E_FATAL("# density in input mixw file != # density in output mixw file\n");
}
for (i = 0; i < n_mixw; i++) {
for (j = 0; j < n_stream; j++) {
for (k = 0, s = 0; k < n_density; k++) {
s += mixw_acc[i][j][k];
}
if ((s == 0) && in_mixw) {
for (k = 0, s = 0; k < n_density; k++) {
mixw_acc[i][j][k] = in_mixw[i][j][k];
}
E_INFO("set mixw %u stream %u to input mixw value\n", i, j);
}
}
}
}
do {
/* Write out the accumulated reestimation sums */
if (s3mixw_write(file_name,
mixw_acc,
n_mixw,
n_stream,
n_density) != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 30 seconds).\n ");
}
}
} while (err > 1);
}
if (pass2var)
E_INFO("-2passvar yes\n");
if (oaccum_dir && (wt_mean || wt_var || wt_fullvar)) {
/* write the total mixing Gau. den reest. accumulators */
err = 0;
sprintf(file_name, "%s/gauden_counts", oaccum_dir);
do {
int32 rv;
if (var_is_full)
rv = s3gaucnt_write_full(file_name,
wt_mean,
wt_fullvar,
pass2var,
dnom,
n_mgau,
n_gau_stream,
n_gau_density,
veclen);
else
rv = s3gaucnt_write(file_name,
wt_mean,
wt_var,
pass2var,
dnom,
n_mgau,
n_gau_stream,
n_gau_density,
veclen);
if (rv != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n ");
}
}
} while (err > 1);
}
if (oaccum_dir && tmat_acc) {
/* write the total transition matrix reest. accumulators */
err = 0;
sprintf(file_name, "%s/tmat_counts", oaccum_dir);
do {
if (s3tmat_write(file_name,
tmat_acc,
n_tmat,
n_state_pm) != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n ");
}
}
} while (err > 1);
}
if (oaccum_dir && regr && regl) {
/* write the total MLLR regression matrix accumulators */
err = 0;
sprintf(file_name, "%s/regmat_counts", oaccum_dir);
do {
if (s3regmatcnt_write(file_name,
regr,
regl,
n_mllr_class,
n_stream,
veclen,
mllr_mult,
mllr_add) != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n ");
}
}
} while (err > 1);
}
if (wt_mean || wt_var || wt_fullvar) {
if (out_mean_fn) {
E_INFO("Normalizing mean for n_mgau= %u, n_stream= %u, n_density= %u\n",
n_mgau, n_stream, n_density);
gauden_norm_wt_mean(in_mean, wt_mean, dnom,
n_mgau, n_stream, n_density, veclen);
}
else {
if (wt_mean) {
E_INFO("Ignoring means since -meanfn not specified\n");
}
}
if (out_var_fn) {
if (var_is_full) {
if (wt_fullvar) {
E_INFO("Normalizing fullvar\n");
gauden_norm_wt_fullvar(in_fullvar, wt_fullvar, pass2var, dnom,
wt_mean, /* wt_mean now just mean */
n_mgau, n_stream, n_density, veclen,
cmd_ln_boolean("-tiedvar"));
}
}
else {
if (wt_var) {
E_INFO("Normalizing var\n");
gauden_norm_wt_var(in_var, wt_var, pass2var, dnom,
wt_mean, /* wt_mean now just mean */
n_mgau, n_stream, n_density, veclen,
cmd_ln_boolean("-tiedvar"));
}
}
}
else {
if (wt_var || wt_fullvar) {
E_INFO("Ignoring variances since -varfn not specified\n");
}
}
}
else {
E_INFO("No means or variances to normalize\n");
}
/*
* Write the parameters to files
*/
if (out_mixw_fn) {
if (mixw_acc) {
if (s3mixw_write(out_mixw_fn,
mixw_acc,
n_mixw,
n_stream,
n_density) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
E_WARN("NO mixing weight accumulators seen, but -mixwfn specified.\n");
}
}
else {
if (mixw_acc) {
E_INFO("Mixing weight accumulators seen, but -mixwfn NOT specified.\n");
}
}
if (out_tmat_fn) {
if (tmat_acc) {
if (s3tmat_write(out_tmat_fn,
tmat_acc,
n_tmat,
n_state_pm) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
E_WARN("NO transition matrix accumulators seen, but -tmatfn specified.\n");
}
}
else {
if (tmat_acc)
E_INFO("Transition matrix accumulators seen, but -tmatfn NOT specified\n");
}
if (out_mean_fn) {
if (wt_mean) {
if (s3gau_write(out_mean_fn,
(const vector_t ***)wt_mean,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS)
return S3_ERROR;
if (out_dcount_fn) {
if (s3gaudnom_write(out_dcount_fn,
dnom,
n_mgau,
n_stream,
n_density) != S3_SUCCESS)
return S3_ERROR;
}
}
else
E_WARN("NO reestimated means seen, but -meanfn specified\n");
}
else {
if (wt_mean) {
E_INFO("Reestimated means seen, but -meanfn NOT specified\n");
}
}
if (out_var_fn) {
if (var_is_full) {
if (wt_fullvar) {
if (s3gau_write_full(out_var_fn,
(const vector_t ****)wt_fullvar,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS)
return S3_ERROR;
}
else
E_WARN("NO reestimated variances seen, but -varfn specified\n");
}
else {
if (wt_var) {
if (s3gau_write(out_var_fn,
(const vector_t ***)wt_var,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS)
return S3_ERROR;
}
else
E_WARN("NO reestimated variances seen, but -varfn specified\n");
}
}
else {
if (wt_var) {
E_INFO("Reestimated variances seen, but -varfn NOT specified\n");
}
}
if (veclen)
ckd_free((void *)veclen);
return S3_SUCCESS;
}
/*
* Continuous recognition from a file
*/
static void
recognize_from_file() {
cont_ad_t *cont;
ad_rec_t file_ad = {0};
int16 adbuf[4096];
const char* hyp;
const char* uttid;
int32 k, ts, start;
char waveheader[44];
if ((rawfd = fopen(cmd_ln_str_r(config, "-infile"), "rb")) == NULL) {
E_FATAL_SYSTEM("Failed to open file '%s' for reading",
cmd_ln_str_r(config, "-infile"));
}
fread(waveheader, 1, 44, rawfd);
file_ad.sps = (int32)cmd_ln_float32_r(config, "-samprate");
file_ad.bps = sizeof(int16);
if ((cont = cont_ad_init(&file_ad, ad_file_read)) == NULL) {
E_FATAL("Failed to initialize voice activity detection\n");
}
if (cont_ad_calib(cont) < 0)
E_INFO("Using default voice activity detection\n");
rewind (rawfd);
for (;;) {
while ((k = cont_ad_read(cont, adbuf, 4096)) == 0);
if (k < 0)
break;
if (ps_start_utt(ps, NULL) < 0)
E_FATAL("ps_start_utt() failed\n");
ps_process_raw(ps, adbuf, k, FALSE, FALSE);
hyp = ps_get_hyp(ps, NULL, &uttid);
printf("= partial_hypothese | %s: %s\n", uttid, hyp);
fflush(stdout);
ts = cont->read_ts;
start = ((ts - k) * 100.0) / file_ad.sps;
for (;;) {
if ((k = cont_ad_read(cont, adbuf, 4096)) < 0)
break;
if (k == 0) {
/*
* No speech data available; check current timestamp with most recent
* speech to see if more than 1 sec elapsed. If so, end of utterance.
*/
if ((cont->read_ts - ts) > 2000) {
printf("= utterance_end | %i\n", (cont->read_ts - ts) );
break;
}
} else {
/* New speech data received; note current timestamp */
ts = cont->read_ts;
}
ps_process_raw(ps, adbuf, k, FALSE, FALSE);
hyp = ps_get_hyp(ps, NULL, &uttid);
printf("= partial_hypothese | %s: %s\n", uttid, hyp);
fflush(stdout);
}
ps_end_utt(ps);
if (cmd_ln_boolean_r(config, "-time")) {
print_word_times(start);
printf("= continue\n");
fflush(stdout);
fgetc( stdin );
} else {
hyp = ps_get_hyp(ps, NULL, &uttid);
printf("= final_hypothese | %s: %s\n\n\n", uttid, hyp);
}
fflush(stdout);
}
cont_ad_close(cont);
fclose(rawfd);
}
dict_t *
dict_init(cmd_ln_t *config, bin_mdef_t * mdef)
{
FILE *fp, *fp2;
int32 n;
lineiter_t *li;
dict_t *d;
s3cipid_t sil;
char const *dictfile = NULL, *fillerfile = NULL;
if (config) {
dictfile = cmd_ln_str_r(config, "-dict");
fillerfile = cmd_ln_str_r(config, "-fdict");
}
/*
* First obtain #words in dictionary (for hash table allocation).
* Reason: The PC NT system doesn't like to grow memory gradually. Better to allocate
* all the required memory in one go.
*/
fp = NULL;
n = 0;
if (dictfile) {
if ((fp = fopen(dictfile, "r")) == NULL)
E_FATAL_SYSTEM("Failed to open dictionary file '%s' for reading", dictfile);
for (li = lineiter_start(fp); li; li = lineiter_next(li)) {
if (li->buf[0] != '#')
n++;
}
rewind(fp);
}
fp2 = NULL;
if (fillerfile) {
if ((fp2 = fopen(fillerfile, "r")) == NULL)
E_FATAL_SYSTEM("Failed to open filler dictionary file '%s' for reading", fillerfile);
for (li = lineiter_start(fp2); li; li = lineiter_next(li)) {
if (li->buf[0] != '#')
n++;
}
rewind(fp2);
}
/*
* Allocate dict entries. HACK!! Allow some extra entries for words not in file.
* Also check for type size restrictions.
*/
d = (dict_t *) ckd_calloc(1, sizeof(dict_t)); /* freed in dict_free() */
d->refcnt = 1;
d->max_words =
(n + S3DICT_INC_SZ < MAX_S3WID) ? n + S3DICT_INC_SZ : MAX_S3WID;
if (n >= MAX_S3WID)
E_FATAL("#Words in dictionaries (%d) exceeds limit (%d)\n", n,
MAX_S3WID);
E_INFO("Allocating %d * %d bytes (%d KiB) for word entries\n",
d->max_words, sizeof(dictword_t),
d->max_words * sizeof(dictword_t) / 1024);
d->word = (dictword_t *) ckd_calloc(d->max_words, sizeof(dictword_t)); /* freed in dict_free() */
d->n_word = 0;
if (mdef)
d->mdef = bin_mdef_retain(mdef);
/* Create new hash table for word strings; case-insensitive word strings */
if (config && cmd_ln_exists_r(config, "-dictcase"))
d->nocase = cmd_ln_boolean_r(config, "-dictcase");
d->ht = hash_table_new(d->max_words, d->nocase);
/* Digest main dictionary file */
if (fp) {
E_INFO("Reading main dictionary: %s\n", dictfile);
dict_read(fp, d);
fclose(fp);
E_INFO("%d words read\n", d->n_word);
}
/* Now the filler dictionary file, if it exists */
d->filler_start = d->n_word;
if (fillerfile) {
E_INFO("Reading filler dictionary: %s\n", fillerfile);
dict_read(fp2, d);
fclose(fp2);
E_INFO("%d words read\n", d->n_word - d->filler_start);
}
if (mdef)
sil = bin_mdef_silphone(mdef);
else
sil = 0;
if (dict_wordid(d, S3_START_WORD) == BAD_S3WID) {
dict_add_word(d, S3_START_WORD, &sil, 1);
}
if (dict_wordid(d, S3_FINISH_WORD) == BAD_S3WID) {
dict_add_word(d, S3_FINISH_WORD, &sil, 1);
}
if (dict_wordid(d, S3_SILENCE_WORD) == BAD_S3WID) {
dict_add_word(d, S3_SILENCE_WORD, &sil, 1);
}
d->filler_end = d->n_word - 1;
/* Initialize distinguished word-ids */
d->startwid = dict_wordid(d, S3_START_WORD);
d->finishwid = dict_wordid(d, S3_FINISH_WORD);
d->silwid = dict_wordid(d, S3_SILENCE_WORD);
if ((d->filler_start > d->filler_end)
|| (!dict_filler_word(d, d->silwid)))
E_FATAL("%s must occur (only) in filler dictionary\n",
S3_SILENCE_WORD);
/* No check that alternative pronunciations for filler words are in filler range!! */
return d;
}
static int32
senone_mixw_read(senone_t * s, char const *file_name, logmath_t *lmath)
{
char eofchk;
FILE *fp;
int32 byteswap, chksum_present;
uint32 chksum;
float32 *pdf;
int32 i, f, c, p, n_err;
char **argname, **argval;
E_INFO("Reading senone mixture weights: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == 0)
E_FATAL_SYSTEM("Failed to open mixture weights file '%s' for reading", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr(fp, &argname, &argval, &byteswap) < 0)
E_FATAL("Failed to read header from file '%s'\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp(argname[i], "version") == 0) {
if (strcmp(argval[i], MIXW_PARAM_VERSION) != 0)
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], MIXW_PARAM_VERSION);
}
else if (strcmp(argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free(argname, argval);
argname = argval = 0;
chksum = 0;
/* Read #senones, #features, #codewords, arraysize */
if ((bio_fread(&(s->n_sen), sizeof(int32), 1, fp, byteswap, &chksum) !=
1)
||
(bio_fread(&(s->n_feat), sizeof(int32), 1, fp, byteswap, &chksum)
!= 1)
|| (bio_fread(&(s->n_cw), sizeof(int32), 1, fp, byteswap, &chksum)
!= 1)
|| (bio_fread(&i, sizeof(int32), 1, fp, byteswap, &chksum) != 1)) {
E_FATAL("bio_fread(%s) (arraysize) failed\n", file_name);
}
if (i != s->n_sen * s->n_feat * s->n_cw) {
E_FATAL
("%s: #float32s(%d) doesn't match dimensions: %d x %d x %d\n",
file_name, i, s->n_sen, s->n_feat, s->n_cw);
}
/*
* Compute #LSB bits to be dropped to represent mixwfloor with 8 bits.
* All PDF values will be truncated (in the LSB positions) by these many bits.
*/
if ((s->mixwfloor <= 0.0) || (s->mixwfloor >= 1.0))
E_FATAL("mixwfloor (%e) not in range (0, 1)\n", s->mixwfloor);
/* Use a fixed shift for compatibility with everything else. */
E_INFO("Truncating senone logs3(pdf) values by %d bits\n", SENSCR_SHIFT);
/*
* Allocate memory for senone PDF data. Organize normally or transposed depending on
* s->n_gauden.
*/
if (s->n_gauden > 1) {
E_INFO("Not transposing mixture weights in memory\n");
s->pdf =
(senprob_t ***) ckd_calloc_3d(s->n_sen, s->n_feat, s->n_cw,
sizeof(senprob_t));
}
else {
E_INFO("Transposing mixture weights in memory\n");
s->pdf =
(senprob_t ***) ckd_calloc_3d(s->n_feat, s->n_cw, s->n_sen,
sizeof(senprob_t));
}
/* Temporary structure to read in floats */
pdf = (float32 *) ckd_calloc(s->n_cw, sizeof(float32));
/* Read senone probs data, normalize, floor, convert to logs3, truncate to 8 bits */
n_err = 0;
for (i = 0; i <(int) s->n_sen; i++) {
for (f = 0; f < (int)s->n_feat; f++) {
if (bio_fread
((void *) pdf, sizeof(float32), s->n_cw, fp, byteswap,
&chksum)
!= s->n_cw) {
E_FATAL("bio_fread(%s) (arraydata) failed\n", file_name);
}
/* Normalize and floor */
if (vector_sum_norm(pdf, s->n_cw) <= 0.0)
n_err++;
vector_floor(pdf, s->n_cw, s->mixwfloor);
vector_sum_norm(pdf, s->n_cw);
/* Convert to logs3, truncate to 8 bits, and store in s->pdf */
for (c = 0; c < (int)s->n_cw; c++) {
p = -(logmath_log(lmath, pdf[c]));
p += (1 << (SENSCR_SHIFT - 1)) - 1; /* Rounding before truncation */
if (s->n_gauden > 1)
s->pdf[i][f][c] =
(p < (255 << SENSCR_SHIFT)) ? (p >> SENSCR_SHIFT) : 255;
else
s->pdf[f][c][i] =
(p < (255 << SENSCR_SHIFT)) ? (p >> SENSCR_SHIFT) : 255;
}
}
}
int
share_ctl_next_utts(uint32 *offset, uint32 *run)
{
uint32 magic;
uint32 i_offset;
uint32 o_offset;
uint32 ns;
int ret;
struct flock lck;
lck.l_type = F_WRLCK;
lck.l_whence = SEEK_SET;
lck.l_start = 0;
lck.l_len = 2 * sizeof(uint32);
/* Get an exclusive lock on the file */
if (fcntl(state_fd, F_SETLKW, &lck) < 0) {
E_FATAL_SYSTEM("file lock failed");
}
printf("*** in crit sec ***\n");
/* read the byte order magic number */
ret = read(state_fd, &magic, sizeof(uint32));
if (ret < 0)
E_FATAL_SYSTEM("read failed");
else if (ret < sizeof(uint32)) {
E_FATAL("Expected to read %u bytes, but got %u instead\n",
sizeof(uint32), ret);
}
if (magic != BYTE_ORDER_MAGIC) {
/* seems to need swap */
SWAP_INT32(&magic);
if (magic != BYTE_ORDER_MAGIC) {
E_FATAL("Couldn't create magic # by swapping\n");
}
ns = TRUE;
}
else
ns = FALSE;
ret = read(state_fd, &i_offset, sizeof(uint32));
if (ret < 0)
E_FATAL_SYSTEM("read failed");
else if (ret < sizeof(uint32)) {
E_FATAL("Expected to read %u bytes, but got %u instead\n",
sizeof(uint32), ret);
}
if (ns)
SWAP_INT32(&i_offset);
o_offset = i_offset + blk_sz;
printf("i_offset= %u\n", i_offset);
sleep(30);
lseek(state_fd, (off_t)0, SEEK_SET);
if (write(state_fd, &magic, sizeof(uint32)) < 0)
E_FATAL_SYSTEM("write failed");
if (write(state_fd, &o_offset, sizeof(uint32)) < 0)
E_FATAL_SYSTEM("write failed");
lck.l_type = F_UNLCK;
if (fcntl(state_fd, F_SETLK, &lck) < 0) {
E_FATAL_SYSTEM("file unlock failed");
}
lseek(state_fd, (off_t)0, SEEK_SET);
printf("*** out crit sec ***\n");
*offset = i_offset;
*run = blk_sz;
return S3_SUCCESS;
}
static int32 senone_mixw_read(logmath_t * logmath, senone_t *s, const char *file_name, float64 mixwfloor)
{
FILE *fp;
char **argname, **argval;
int32 byteswap, chksum_present;
uint32 chksum;
float32 *pdf;
int32 i, j, f, m, c, p, n_sen, n_err, n_cw, nval;
char eofchk;
mixw_t *fw;
E_INFO("Reading senone mixture weights: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr (fp, &argname, &argval, &byteswap) < 0)
E_FATAL("bio_readhdr(%s) failed\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp (argname[i], "version") == 0) {
if (strcmp(argval[i], MIXW_PARAM_VERSION) != 0)
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], MIXW_PARAM_VERSION);
} else if (strcmp (argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free (argname, argval);
argname = argval = NULL;
chksum = 0;
/* Read #senones, #features, #codewords, arraysize */
n_sen = s->n_sen;
if ((bio_fread (&(s->n_sen), sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&(s->n_feat), sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&(n_cw), sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&nval, sizeof(int32), 1, fp, byteswap, &chksum) != 1)) {
E_FATAL("bio_fread(%s) (arraysize) failed\n", file_name);
}
if ((n_sen != 0) && (s->n_sen != n_sen))
E_FATAL("#senones(%d) conflict with mapping file(%d)\n", s->n_sen, n_sen);
if (s->n_sen >= MAX_SENID)
E_FATAL("%s: #senones (%d) exceeds limit (%d)\n", file_name, s->n_sen, MAX_SENID);
if (s->n_feat <= 0)
E_FATAL("Bad #features: %d\n", s->n_feat);
if (n_cw <= 0)
E_FATAL("Bad #mixing-wts/senone: %d\n", n_cw);
/* Allocate sen2mgau map if not yet done so (i.e. no explicit mapping file given */
if (! s->sen2mgau) {
assert ((s->n_mgau == 0) || (s->n_mgau == 1));
s->sen2mgau = (uint32 *) ckd_calloc (s->n_sen, sizeof(int32));
if (s->n_mgau == 1) {
/* Semicontinuous mode; all senones map to single, shared gaussian: 0 */
for (i = 0; i < s->n_sen; i++)
s->sen2mgau[i] = 0;
} else {
/* Fully continuous mode; each senone maps to own parent gaussian */
s->n_mgau = s->n_sen;
for (i = 0; i < s->n_sen; i++)
s->sen2mgau[i] = i;
}
} else
assert (s->n_mgau != 0);
if (s->n_mgau >= MAX_MGAUID)
E_FATAL("%s: #gauden (%d) exceeds limit (%d)\n", file_name, s->n_mgau, MAX_MGAUID);
if (nval != s->n_sen * s->n_feat * n_cw) {
E_FATAL("%s: #float32 values(%d) doesn't match dimensions: %d x %d x %d\n",
file_name, nval, s->n_sen, s->n_feat, n_cw);
}
/*
* Compute #LSB bits to be dropped to represent mixwfloor with 8 bits.
* All PDF values will be truncated (in the LSB positions) by these many bits.
*/
if ((mixwfloor <= 0.0) || (mixwfloor >= 1.0))
E_FATAL("mixwfloor (%e) not in range (0, 1)\n", mixwfloor);
/* Allocate memory for s->mgau2sen and senone PDF data */
build_mgau2sen (s, n_cw);
/* Temporary structure to read in floats */
pdf = (float32 *) ckd_calloc (n_cw, sizeof(float32));
/* Read senone probs data, normalize, floor, convert to logs3, truncate to 8 bits */
n_err = 0;
for (i = 0; i < s->n_sen; i++) {
m = s->sen2mgau[i]; /* Parent mgau */
j = s->mgau2sen_idx[i]; /* Index of senone i within list of senones for mgau m */
fw = s->mgau2sen[m].feat_mixw;
for (f = 0; f < s->n_feat; f++) {
if (bio_fread((void *)pdf, sizeof(float32), n_cw, fp, byteswap, &chksum)
!= n_cw) {
E_FATAL("bio_fread(%s) (arraydata) failed\n", file_name);
}
/* Normalize and floor */
if (vector_sum_norm (pdf, n_cw) == 0.0)
n_err++;
vector_floor (pdf, n_cw, mixwfloor);
vector_sum_norm (pdf, n_cw);
/* Convert to logs3, truncate to 8 bits, and store in s->pdf */
for (c = 0; c < n_cw; c++) {
p = -logmath_log(logmath, pdf[c]);
printf ("%f %d\n", pdf[c], p);
fw[f].prob[j][c] = p;
}
}
}
if (n_err > 0)
E_WARN("Weight normalization failed for %d senones\n", n_err);
ckd_free (pdf);
if (chksum_present)
bio_verify_chksum (fp, byteswap, chksum);
if (fread (&eofchk, 1, 1, fp) == 1)
E_FATAL("More data than expected in %s\n", file_name);
fclose(fp);
E_INFO("Read mixture weights for %d senones: %d features x %d codewords\n",
s->n_sen, s->n_feat, n_cw);
return 0;
}
