/**
* Output frames in HTK format.
*/
static int
output_frames_htk(sphinx_wave2feat_t *wtf, mfcc_t **frames, int nfr)
{
int i, j, swap, htk_reorder, nfloat = 0;
fe_mfcc_to_float(wtf->fe, frames, (float32 **)frames, nfr);
/* This is possibly inefficient, but probably not a big deal. */
swap = (0 == strcmp("little", cmd_ln_str_r(wtf->config, "-mach_endian")));
htk_reorder = (0 == strcmp("htk", wtf->ot->name)
&& !(cmd_ln_boolean_r(wtf->config, "-logspec")
|| cmd_ln_boolean_r(wtf->config, "-cep2spec")));
for (i = 0; i < nfr; ++i) {
if (htk_reorder) {
mfcc_t c0 = frames[i][0];
memmove(frames[i] + 1, frames[i], (wtf->veclen - 1) * 4);
frames[i][wtf->veclen - 1] = c0;
}
if (swap)
for (j = 0; j < wtf->veclen; ++j)
SWAP_FLOAT32(frames[i] + j);
if (fwrite(frames[i], sizeof(float32), wtf->veclen, wtf->outfh) != wtf->veclen) {
E_ERROR_SYSTEM("Writing %d values to %s failed",
wtf->veclen, wtf->outfile);
return -1;
}
nfloat += wtf->veclen;
}
return nfloat;
}
/**
* Process Sphinx MFCCs/logspectra from a filehandle. Assume that
* wtf->infh is positioned just after the file header.
*/
static int
decode_sphinx_mfc(sphinx_wave2feat_t *wtf)
{
int nfloat = 0, n;
int featsize = wtf->featsize;
/* If the input vector length is less than the output length, we
* need to do this one frame at a time, because there's empty
* space at the end of each vector in wtf->feat. */
if (wtf->in_veclen < wtf->veclen)
featsize = 1;
while ((n = fread(wtf->feat[0], sizeof(**wtf->feat),
featsize * wtf->in_veclen, wtf->infh)) != 0) {
int i, nfr = n / wtf->in_veclen;
if (n % wtf->in_veclen) {
E_ERROR("Size of file %d not a multiple of veclen %d\n",
n, wtf->in_veclen);
return -1;
}
/* Byteswap stuff here if necessary. */
if (wtf->byteswap) {
for (i = 0; i < n; ++i)
SWAP_FLOAT32(wtf->feat[0] + i);
}
fe_float_to_mfcc(wtf->fe, (float32 **)wtf->feat, wtf->feat, nfr);
for (i = 0; i < nfr; ++i) {
if (cmd_ln_boolean_r(wtf->config, "-spec2cep")) {
if (0 == strcmp(cmd_ln_str_r(wtf->config, "-transform"), "legacy"))
fe_logspec_to_mfcc(wtf->fe, wtf->feat[i], wtf->feat[i]);
else
fe_logspec_dct2(wtf->fe, wtf->feat[i], wtf->feat[i]);
}
else if (cmd_ln_boolean_r(wtf->config, "-cep2spec")) {
fe_mfcc_dct3(wtf->fe, wtf->feat[i], wtf->feat[i]);
}
}
if ((n = (*wtf->ot->output_frames)(wtf, wtf->feat, nfr)) < 0)
return -1;
nfloat += n;
}
if (fclose(wtf->infh) == EOF)
E_ERROR_SYSTEM("Failed to close input file");
wtf->infh = NULL;
return nfloat;
}
/**
* Read Sphinx-II format mfc file (s2mfc = Sphinx-II format MFC data).
* If out_mfc is 0, no actual reading will be done, and the number of
* frames (plus padding) that would be read is returned.
*
* It's important that normalization is done before padding because
* frames outside the data we are interested in shouldn't be taken
* into normalization stats.
*
* @return # frames read (plus padding) if successful, -1 if
* error (e.g., mfc array too small).
*/
static int32
feat_s2mfc_read_norm_pad(feat_t *fcb, char *file, int32 win,
int32 sf, int32 ef,
mfcc_t ***out_mfc,
int32 maxfr,
int32 cepsize)
{
FILE *fp;
int32 n_float32;
float32 *float_feat;
struct stat statbuf;
int32 i, n, byterev;
int32 start_pad, end_pad;
mfcc_t **mfc;
/* Initialize the output pointer to 0, so that any attempts to
free() it if we fail before allocating it will not segfault! */
if (out_mfc)
*out_mfc = 0;
E_INFO("Reading mfc file: '%s'[%d..%d]\n", file, sf, ef);
if (ef >= 0 && ef <= sf) {
E_ERROR("%s: End frame (%d) <= Start frame (%d)\n", file, ef, sf);
return -1;
}
/* Find filesize; HACK!! To get around intermittent NFS failures, use stat_retry */
if ((stat_retry(file, &statbuf) < 0)
|| ((fp = fopen(file, "rb")) == 0)) {
#ifndef POCKETSPHINX_NET
E_ERROR("Failed to open file '%s' for reading: %s\n", file, strerror(errno));
#endif
return -1;
}
/* Read #floats in header */
if (fread_retry(&n_float32, sizeof(int32), 1, fp) != 1) {
E_ERROR("%s: fread(#floats) failed\n", file);
fclose(fp);
return -1;
}
/* Check if n_float32 matches file size */
byterev = 0;
if ((int32) (n_float32 * sizeof(float32) + 4) != (int32) statbuf.st_size) { /* RAH, typecast both sides to remove compile warning */
n = n_float32;
SWAP_INT32(&n);
if ((int32) (n * sizeof(float32) + 4) != (int32) (statbuf.st_size)) { /* RAH, typecast both sides to remove compile warning */
E_ERROR
("%s: Header size field: %d(%08x); filesize: %d(%08x)\n",
file, n_float32, n_float32, statbuf.st_size,
statbuf.st_size);
fclose(fp);
return -1;
}
n_float32 = n;
byterev = 1;
}
if (n_float32 <= 0) {
E_ERROR("%s: Header size field (#floats) = %d\n", file, n_float32);
fclose(fp);
return -1;
}
/* Convert n to #frames of input */
n = n_float32 / cepsize;
if (n * cepsize != n_float32) {
E_ERROR("Header size field: %d; not multiple of %d\n", n_float32,
cepsize);
fclose(fp);
return -1;
}
/* Check start and end frames */
if (sf > 0) {
if (sf >= n) {
E_ERROR("%s: Start frame (%d) beyond file size (%d)\n", file,
sf, n);
fclose(fp);
return -1;
}
}
if (ef < 0)
ef = n-1;
else if (ef >= n) {
E_WARN("%s: End frame (%d) beyond file size (%d), will truncate\n",
file, ef, n);
ef = n-1;
}
/* Add window to start and end frames */
sf -= win;
ef += win;
if (sf < 0) {
start_pad = -sf;
sf = 0;
}
else
start_pad = 0;
if (ef >= n) {
end_pad = ef - n + 1;
ef = n - 1;
}
else
end_pad = 0;
/* Limit n if indicated by [sf..ef] */
if ((ef - sf + 1) < n)
n = (ef - sf + 1);
if (maxfr > 0 && n + start_pad + end_pad > maxfr) {
E_ERROR("%s: Maximum output size(%d frames) < actual #frames(%d)\n",
file, maxfr, n + start_pad + end_pad);
fclose(fp);
return -1;
}
/* If no output buffer was supplied, then skip the actual data reading. */
if (out_mfc != 0) {
/* Position at desired start frame and read actual MFC data */
mfc = (mfcc_t **)ckd_calloc_2d(n + start_pad + end_pad, cepsize, sizeof(mfcc_t));
if (sf > 0)
fseek(fp, sf * cepsize * sizeof(float32), SEEK_CUR);
n_float32 = n * cepsize;
#ifdef FIXED_POINT
float_feat = ckd_calloc(n_float32, sizeof(float32));
#else
float_feat = mfc[start_pad];
#endif
if (fread_retry(float_feat, sizeof(float32), n_float32, fp) != n_float32) {
E_ERROR("%s: fread(%dx%d) (MFC data) failed\n", file, n, cepsize);
ckd_free_2d(mfc);
fclose(fp);
return -1;
}
if (byterev) {
for (i = 0; i < n_float32; i++) {
SWAP_FLOAT32(&float_feat[i]);
}
}
#ifdef FIXED_POINT
for (i = 0; i < n_float32; ++i) {
mfc[start_pad][i] = FLOAT2MFCC(float_feat[i]);
}
ckd_free(float_feat);
#endif
/* Normalize */
feat_cmn(fcb, mfc + start_pad, n, 1, 1);
feat_agc(fcb, mfc + start_pad, n, 1, 1);
/* Replicate start and end frames if necessary. */
for (i = 0; i < start_pad; ++i)
memcpy(mfc[i], mfc[start_pad], cepsize * sizeof(mfcc_t));
for (i = 0; i < end_pad; ++i)
memcpy(mfc[start_pad + n + i], mfc[start_pad + n - 1],
cepsize * sizeof(mfcc_t));
*out_mfc = mfc;
}
fclose(fp);
return n + start_pad + end_pad;
}
int
read_cep(char const *file, float ***cep, int *numframes, int cepsize)
{
FILE *fp;
int n_float;
struct stat statbuf;
int i, n, byterev, sf, ef;
float32 **mfcbuf;
if (stat_retry(file, &statbuf) < 0) {
printf("stat(%s) failed\n", file);
return IO_ERR;
}
if ((fp = fopen(file, "rb")) == NULL) {
printf("fopen(%s, rb) failed\n", file);
return IO_ERR;
}
/* Read #floats in header */
if (fread(&n_float, sizeof(int), 1, fp) != 1) {
fclose(fp);
return IO_ERR;
}
/* Check if n_float matches file size */
byterev = FALSE;
if ((int) (n_float * sizeof(float) + 4) != statbuf.st_size) {
n = n_float;
SWAP_INT32(&n);
if ((int) (n * sizeof(float) + 4) != statbuf.st_size) {
printf
("Header size field: %d(%08x); filesize: %d(%08x)\n",
n_float, n_float, (int) statbuf.st_size,
(int) statbuf.st_size);
fclose(fp);
return IO_ERR;
}
n_float = n;
byterev = TRUE;
}
if (n_float <= 0) {
printf("Header size field: %d\n", n_float);
fclose(fp);
return IO_ERR;
}
/* n = #frames of input */
n = n_float / cepsize;
if (n * cepsize != n_float) {
printf("Header size field: %d; not multiple of %d\n",
n_float, cepsize);
fclose(fp);
return IO_ERR;
}
sf = 0;
ef = n;
mfcbuf = (float **) ckd_calloc_2d(n, cepsize, sizeof(float32));
/* Read mfc data and byteswap if necessary */
n_float = n * cepsize;
if ((int) fread(mfcbuf[0], sizeof(float), n_float, fp) != n_float) {
printf("Error reading mfc data\n");
fclose(fp);
return IO_ERR;
}
if (byterev) {
for (i = 0; i < n_float; i++)
SWAP_FLOAT32(&(mfcbuf[0][i]));
}
fclose(fp);
*numframes = n;
*cep = mfcbuf;
return IO_SUCCESS;
}
/*
* Read specified segment [sf..ef] of Sphinx-II format mfc file read and return
* #frames read. Return -1 if error.
*/
int32 s2mfc_read (char *file, int32 sf, int32 ef, float32 ***mfc, int32 veclen)
{
FILE *fp;
int32 n_float32;
struct stat statbuf;
int32 i, n, byterev, cepsize;
char tmp;
E_INFO("Reading mfc file: %s\n", file);
assert (fcb.cepsize != NULL);
cepsize = ( *(fcb.cepsize) ) (veclen);
/* Find filesize; HACK!! To get around intermittent NFS failures, use stat_retry */
if (stat_retry (file, &statbuf) < 0) {
E_ERROR("stat_retry(%s) failed\n", file);
return -1;
}
if ((fp = fopen(file, "rb")) == NULL) {
E_ERROR("fopen(%s,rb) failed\n", file);
return -1;
}
/* Read #floats in header */
if (fread_retry (&n_float32, sizeof(int32), 1, fp) != 1) {
fclose (fp);
return -1;
}
/* Check if n_float32 matches file size */
/* pip: this is a hack to get it to run on simulator:
we always know the endianess of the sim (big-e),
so always swap_int32
byterev = FALSE;
if ((n_float32*sizeof(float32) + 4) != statbuf.st_size) {
n = n_float32;
SWAP_INT32(&n);
if ((n*sizeof(float32) + 4) != statbuf.st_size) {
E_ERROR("Header size field: %d(%08x); filesize: %d(%08x)\n",
n_float32, n_float32, statbuf.st_size, statbuf.st_size);
fclose (fp);
return -1;
}
n_float32 = n;
byterev = TRUE;
}
pip */
/* pip : */ byterev = FALSE;
if (n_float32 <= 0) {
E_ERROR("Header size field: %d\n", n_float32);
fclose (fp);
return -1;
}
E_INFO("pip: n = %d, n_float32 = %d, cepsize = %d, veclen = %d\n", n, n_float32, cepsize, veclen);
E_INFO("pip: forcing cepsize to feat_s3_1x39_cepsize()\n");
cepsize = ((*feat_s3_1x39_cepsize))(veclen);
E_INFO("pip again: n = %d, n_float32 = %d, cepsize = %d\n", n, n_float32, cepsize);
E_INFO("pip: forcing cepsize to 13\n");
cepsize = 13;
E_INFO("pip again: n = %d, n_float32 = %d, cepsize = %d\n", n, n_float32, cepsize);
/* n = #frames of input */
n = n_float32/cepsize;
if (n * cepsize != n_float32) {
E_ERROR("Header size field: %d; not multiple of %d\n", n_float32, cepsize);
fclose (fp);
return -1;
}
if (sf > 0) {
if (sf >= n) {
E_ERROR("Start frame (%d) beyond MFC file size (%d)\n", sf, n);
fclose (fp);
return -1;
}
n -= sf;
}
/* Limit n if indicated by [sf..ef] */
if ((ef-sf+1) < n)
n = (ef-sf+1);
if (n > mfcbufsize) {
if (mfcbufsize > 0)
E_FATAL("Increase MAX_MFCBUFSIZE\n");
mfcbufsize = MAX_MFCBUFSIZE;
mfcbuf = (float32 **) ckd_calloc_2d (mfcbufsize, cepsize, sizeof(float32));
}
if (sf > 0)
fseek (fp, sf*cepsize*sizeof(float32), SEEK_CUR);
/* Read mfc data and byteswap if necessary */
n_float32 = n * cepsize;
if (fread_retry (mfcbuf[0], sizeof(float32), n_float32, fp) != n_float32) {
E_ERROR("Error reading mfc data\n");
fclose (fp);
return -1;
}
if (byterev) {
for (i = 0; i < n_float32; i++)
SWAP_FLOAT32(&(mfcbuf[0][i]));
}
fclose (fp);
*mfc = mfcbuf;
return n;
}
main (int argc, char *argv[])
{
struct stat statbuf;
char *file;
FILE *fp;
int32 byterev;
int32 i, n, n_float32, fr, numbered, sd, ed, smooth;
float32 cep[13], cep_1[13], cep_2[13], c; /* Hack!! Hardwired 13 */
if (argc < 2)
usagemsg (argv[0]);
numbered = 0;
file = NULL;
sd = -1; /* Start and end dimensions to output */
ed = -1;
smooth = 0;
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'n':
if (numbered)
usagemsg (argv[0]);
numbered = 1;
break;
case 'l':
if (smooth)
usagemsg (argv[0]);
smooth = 1;
break;
case 's':
if ((sd >= 0) || (sscanf (&(argv[i][2]), "%d", &sd) != 1) ||
(sd < 0) || (sd > 12))
usagemsg (argv[0]);
break;
case 'e':
if ((ed >= 0) || (sscanf (&(argv[i][2]), "%d", &ed) != 1) ||
(ed < 0) || (ed > 12))
usagemsg (argv[0]);
break;
default:
usagemsg (argv[0]);
break;
}
} else {
if (file)
usagemsg (argv[0]);
file = argv[i];
}
}
if (! file)
usagemsg (argv[0]);
if (sd < 0)
sd = 0;
if (ed < 0)
ed = 12;
if (stat (file, &statbuf) != 0) {
E_ERROR("stat(%s) failed\n", file);
return -1;
}
if ((fp = fopen(file, "rb")) == NULL) {
E_ERROR("fopen(%s,rb) failed\n", file);
return -1;
}
/* Read #floats in header */
if (fread_retry (&n_float32, sizeof(int32), 1, fp) != 1) {
fclose (fp);
return -1;
}
/* Check of n_float32 matches file size */
byterev = FALSE;
if ((n_float32*sizeof(float32) + 4) != statbuf.st_size) {
n = n_float32;
SWAP_INT32(&n);
if ((n*sizeof(float32) + 4) != statbuf.st_size) {
E_ERROR("Header size field: %d(%08x); filesize: %d(%08x)\n",
n_float32, n_float32, statbuf.st_size, statbuf.st_size);
fclose (fp);
return -1;
}
n_float32 = n;
byterev = TRUE;
}
if (n_float32 <= 0) {
E_ERROR("Header size field: %d\n", n_float32);
fclose (fp);
return -1;
}
if (byterev)
E_INFO("Byte-reversing %s\n", file);
E_INFO("Dimensions %d..%d%s\n", sd, ed, (smooth ? " (LPFed)" : ""));
fr = 0;
while (fread (cep, sizeof(float32), 13, fp) == 13) {
if (byterev) {
for (i = 0; i < 13; i++) {
SWAP_FLOAT32(cep+i);
}
}
if (smooth) {
/* Smoothing (LPF-ing): 0.25, 0.5, 0.25; except at the ends: 0.5, 0.5 */
if ((fr > 0) && numbered)
printf ("%10d ", fr-1);
if (fr == 1) {
for (i = sd; i <= ed; i++) {
c = 0.5 * cep_1[i] + 0.5 * cep[i];
printf (" %11.7f", c);
}
} else if (fr > 1) {
for (i = sd; i <= ed; i++) {
c = 0.25 * cep_2[i] + 0.5 * cep_1[i] + 0.25 * cep[i];
printf (" %11.7f", c);
}
}
memcpy (cep_2, cep_1, sizeof(float32) * 13);
memcpy (cep_1, cep, sizeof(float32) * 13);
} else {
if (numbered)
printf ("%10d ", fr);
for (i = sd; i <= ed; i++) {
printf (" %11.7f", cep[i]);
}
}
if ((! smooth) || (fr > 0))
printf ("\n");
fflush (stdout);
fr++;
}
if (smooth && (fr > 0)) {
if (numbered)
printf ("%10d ", fr-1);
if (fr > 1) {
for (i = sd; i <= ed; i++) {
c = 0.5 * cep_2[i] + 0.5 * cep_1[i];
printf (" %11.7f", c);
}
} else if (fr == 1) {
for (i = sd; i <= ed; i++)
printf (" %11.7f", cep_1[i]);
}
printf ("\n");
fflush (stdout);
}
}
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;
}
