int32
stat_mtime(const char *file)
{
struct stat statbuf;
if (stat_retry(file, &statbuf) != 0)
return -1;
return ((int32) statbuf.st_mtime);
}
int32
stat_mtime(const char *file)
{
struct stat statbuf;
#ifdef HAVE_SYS_STAT_H
if (stat(file, &statbuf) != 0)
return -1;
#else /* HAVE_SYS_STAT_H */
if (stat_retry(file, &statbuf) != 0)
return -1;
#endif /* HAVE_SYS_STAT_H */
return ((int32) statbuf.st_mtime);
}
/**
* 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;
}
