static int
acmod_process_full_cep(acmod_t *acmod,
mfcc_t ***inout_cep,
int *inout_n_frames)
{
int32 nfr;
/* Write to log file. */
if (acmod->mfcfh)
acmod_log_mfc(acmod, *inout_cep, *inout_n_frames);
/* Resize feat_buf to fit. */
if (acmod->n_feat_alloc < *inout_n_frames) {
if (*inout_n_frames > MAX_N_FRAMES)
E_FATAL("Batch processing can not process more than %d frames "
"at once, requested %d\n", MAX_N_FRAMES, *inout_n_frames);
feat_array_free(acmod->feat_buf);
acmod->feat_buf = feat_array_alloc(acmod->fcb, *inout_n_frames);
acmod->n_feat_alloc = *inout_n_frames;
acmod->n_feat_frame = 0;
acmod->feat_outidx = 0;
}
/* Make dynamic features. */
nfr = feat_s2mfc2feat_live(acmod->fcb, *inout_cep, inout_n_frames,
TRUE, TRUE, acmod->feat_buf);
acmod->n_feat_frame = nfr;
assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
*inout_cep += *inout_n_frames;
*inout_n_frames = 0;
return nfr;
}
static int
acmod_process_full_cep(acmod_t *acmod,
mfcc_t ***inout_cep,
int *inout_n_frames)
{
int32 nfr;
/* Write to log file. */
if (acmod->mfcfh)
acmod_log_mfc(acmod, *inout_cep, *inout_n_frames);
/* Resize feat_buf to fit. */
if (acmod->n_feat_alloc < *inout_n_frames) {
feat_array_free(acmod->feat_buf);
acmod->feat_buf = feat_array_alloc(acmod->fcb, *inout_n_frames);
acmod->n_feat_alloc = *inout_n_frames;
acmod->n_feat_frame = 0;
acmod->feat_outidx = 0;
}
/* Make dynamic features. */
nfr = feat_s2mfc2feat_live(acmod->fcb, *inout_cep, inout_n_frames,
TRUE, TRUE, acmod->feat_buf);
acmod->n_feat_frame = nfr;
assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
*inout_cep += *inout_n_frames;
*inout_n_frames = 0;
return nfr;
}
void
s3_decode_end_utt(s3_decode_t * _decode)
{
int32 num_features;
if (_decode == NULL)
return;
if (_decode->state != S3_DECODE_STATE_DECODING) {
E_WARN("Cannot end utterance in current decoder state.\n");
return;
}
/* Call this with no frames, to update CMN and AGC statistics. */
num_features = feat_s2mfc2feat_live(kbcore_fcb(_decode->kbcore),
NULL, NULL, FALSE,
TRUE, _decode->kb.feat);
if (num_features > 0)
utt_decode_block(_decode->kb.feat,
num_features,
&_decode->num_frames_decoded,
&_decode->kb);
_decode->kb.stat->tot_fr += _decode->kb.stat->nfr;
s3_decode_record_hyps(_decode, TRUE);
utt_end(&_decode->kb);
_decode->state = S3_DECODE_STATE_IDLE;
}
int
s3_decode_process(s3_decode_t * _decode,
float32 ** _cep_frames,
int32 _num_frames)
{
int32 num_features = 0;
int32 begin_utt = _decode->num_frames_entered == 0;
if (_decode == NULL)
return S3_DECODE_ERROR_NULL_POINTER;
if (_num_frames >= S3_MAX_FRAMES)
return S3_DECODE_ERROR_OUT_OF_MEMORY;
if (_num_frames > 0) {
num_features = feat_s2mfc2feat_live(kbcore_fcb(_decode->kbcore),
_cep_frames,
&_num_frames,
begin_utt,
FALSE,
_decode->kb.feat);
_decode->num_frames_entered += _num_frames;
if (num_features > 0) {
if (_decode->num_frames_entered >= S3_MAX_FRAMES)
return S3_DECODE_ERROR_OUT_OF_MEMORY;
utt_decode_block(_decode->kb.feat,
num_features,
&_decode->num_frames_decoded,
&_decode->kb);
}
}
return S3_DECODE_SUCCESS;
}
int
acmod_process_cep(acmod_t *acmod,
mfcc_t ***inout_cep,
int *inout_n_frames,
int full_utt)
{
int32 nfeat, ncep, inptr;
int orig_n_frames;
/* If this is a full utterance, process it all at once. */
if (full_utt)
return acmod_process_full_cep(acmod, inout_cep, inout_n_frames);
/* Write to log file. */
if (acmod->mfcfh)
acmod_log_mfc(acmod, *inout_cep, *inout_n_frames);
/* Maximum number of frames we're going to generate. */
orig_n_frames = ncep = nfeat = *inout_n_frames;
/* FIXME: This behaviour isn't guaranteed... */
if (acmod->state == ACMOD_ENDED)
nfeat += feat_window_size(acmod->fcb);
else if (acmod->state == ACMOD_STARTED)
nfeat -= feat_window_size(acmod->fcb);
/* Clamp number of features to fit available space. */
if (nfeat > acmod->n_feat_alloc - acmod->n_feat_frame) {
/* Grow it as needed - we have to grow it at the end of an
* utterance because we can't return a short read there. */
if (acmod->grow_feat || acmod->state == ACMOD_ENDED)
acmod_grow_feat_buf(acmod, acmod->n_feat_alloc + nfeat);
else
ncep -= (nfeat - (acmod->n_feat_alloc - acmod->n_feat_frame));
}
/* Where to start writing in the feature buffer. */
if (acmod->grow_feat) {
/* Grow to avoid wraparound if grow_feat == TRUE. */
inptr = acmod->feat_outidx + acmod->n_feat_frame;
while (inptr + nfeat >= acmod->n_feat_alloc)
acmod_grow_feat_buf(acmod, acmod->n_feat_alloc * 2);
}
else {
inptr = (acmod->feat_outidx + acmod->n_feat_frame) % acmod->n_feat_alloc;
}
/* FIXME: we can't split the last frame drop properly to be on the bounary,
* so just return
*/
if (inptr + nfeat > acmod->n_feat_alloc && acmod->state == ACMOD_ENDED) {
*inout_n_frames -= ncep;
*inout_cep += ncep;
return 0;
}
/* Write them in two parts if there is wraparound. */
if (inptr + nfeat > acmod->n_feat_alloc) {
int32 ncep1 = acmod->n_feat_alloc - inptr;
/* Make sure we don't end the utterance here. */
nfeat = feat_s2mfc2feat_live(acmod->fcb, *inout_cep,
&ncep1,
(acmod->state == ACMOD_STARTED),
FALSE,
acmod->feat_buf + inptr);
if (nfeat < 0)
return -1;
/* Move the output feature pointer forward. */
acmod->n_feat_frame += nfeat;
assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
inptr += nfeat;
inptr %= acmod->n_feat_alloc;
/* Move the input feature pointers forward. */
*inout_n_frames -= ncep1;
*inout_cep += ncep1;
ncep -= ncep1;
}
nfeat = feat_s2mfc2feat_live(acmod->fcb, *inout_cep,
&ncep,
(acmod->state == ACMOD_STARTED),
(acmod->state == ACMOD_ENDED),
acmod->feat_buf + inptr);
if (nfeat < 0)
return -1;
acmod->n_feat_frame += nfeat;
assert(acmod->n_feat_frame <= acmod->n_feat_alloc);
/* Move the input feature pointers forward. */
*inout_n_frames -= ncep;
*inout_cep += ncep;
if (acmod->state == ACMOD_STARTED)
acmod->state = ACMOD_PROCESSING;
return orig_n_frames - *inout_n_frames;
}
int
agg_phn_seg(lexicon_t *lex,
acmod_set_t *acmod_set,
feat_t *fcb,
segdmp_type_t type)
{
uint16 *seg;
vector_t *mfcc;
vector_t **feat;
int32 n_frame;
uint32 tick_cnt;
acmod_id_t *phone;
uint32 *start;
uint32 *len;
uint32 n_phone;
uint32 s;
char *btw_mark;
char *trans;
char **word;
uint32 n_word;
int32 mfc_veclen = cmd_ln_int32("-ceplen");
uint32 n_stream;
uint32 *veclen;
tick_cnt = 0;
n_stream = feat_dimension1(fcb);
veclen = feat_stream_lengths(fcb);
while (corpus_next_utt()) {
if ((++tick_cnt % 500) == 0) {
E_INFOCONT("[%u] ", tick_cnt);
}
if (corpus_get_sent(&trans) != S3_SUCCESS) {
E_FATAL("Unable to read word transcript for %s\n", corpus_utt_brief_name());
}
if (corpus_get_seg(&seg, &n_frame) != S3_SUCCESS) {
E_FATAL("Unable to read Viterbi state segmentation for %s\n", corpus_utt_brief_name());
}
n_word = str2words(trans, NULL, 0);
word = ckd_calloc(n_word, sizeof(char*));
str2words(trans, word, n_word);
phone = mk_phone_list(&btw_mark, &n_phone, word, n_word, lex);
start = ckd_calloc(n_phone, sizeof(uint32));
len = ckd_calloc(n_phone, sizeof(uint32));
/* check to see whether the word transcript and dictionary entries
agree with the state segmentation */
if (ck_seg(acmod_set, phone, n_phone, seg, n_frame, corpus_utt()) != S3_SUCCESS) {
free(trans); /* alloc'ed using strdup, not ckd_*() */
free(seg); /* alloc'ed using malloc in areadshort(), not ckd_*() */
ckd_free(word);
ckd_free(phone);
E_ERROR("ck_seg failed");
continue;
}
if (cvt2triphone(acmod_set, phone, btw_mark, n_phone) != S3_SUCCESS) {
free(trans); /* alloc'ed using strdup, not ckd_*() */
free(seg); /* alloc'ed using malloc in areadshort(), not ckd_*() */
ckd_free(word);
ckd_free(phone);
E_ERROR("cvt2triphone failed");
continue;
}
ckd_free(btw_mark);
if (mk_seg(acmod_set,
seg,
n_frame,
phone,
start,
len,
n_phone) != S3_SUCCESS) {
free(trans);
free(seg);
ckd_free(word);
ckd_free(phone);
E_ERROR("mk_seg failed");
continue;
}
if (corpus_provides_mfcc()) {
if (corpus_get_generic_featurevec(&mfcc, &n_frame, mfc_veclen) < 0) {
E_FATAL("Can't read input features from %s\n", corpus_utt());
}
if (n_frame < 9) {
E_WARN("utt %s too short\n", corpus_utt());
if (mfcc) {
ckd_free(mfcc[0]);
ckd_free(mfcc);
mfcc = NULL;
}
continue;
}
feat = feat_array_alloc(fcb, n_frame + feat_window_size(fcb));
feat_s2mfc2feat_live(fcb, mfcc, &n_frame, TRUE, TRUE, feat);
for (s = 0; s < n_phone; s++) {
segdmp_add_feat(phone[s],
&feat[start[s]],
len[s]);
}
feat_array_free(feat);
free(&mfcc[0][0]);
ckd_free(mfcc);
}
else {
E_FATAL("No data type specified\n");
}
free(trans); /* alloc'ed using strdup, not ckd_*() */
free(seg); /* alloc'ed using malloc in areadshort(), not ckd_*() */
ckd_free(word);
ckd_free(phone);
ckd_free(start);
ckd_free(len);
}
return 0;
}
int
main(int argc, char *argv[])
{
feat_t *fcb;
mfcc_t **in_feats, ***out_feats, ***out_feats2, ***optr;
int32 i, j, ncep, nfr, nfr1, nfr2;
in_feats = (mfcc_t **)ckd_alloc_2d_ptr(6, 13, data, sizeof(mfcc_t));
out_feats = (mfcc_t ***)ckd_calloc_3d(8, 1, 39, sizeof(mfcc_t));
/* Test 1s_c_d_dd features */
fcb = feat_init("1s_c_d_dd", CMN_NONE, 0, AGC_NONE, 1, 13);
ncep = 6;
nfr1 = feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
printf("Processed %d input %d output frames\n", ncep, nfr1);
for (i = 0; i < nfr1; ++i) {
printf("%d: ", i);
for (j = 0; j < 39; ++j) {
printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
}
printf("\n");
}
feat_free(fcb);
/* Test in "live" mode. */
fcb = feat_init("1s_c_d_dd", CMN_NONE, 0, AGC_NONE, 1, 13);
optr = out_feats2 = (mfcc_t ***)ckd_calloc_3d(8, 1, 39, sizeof(mfcc_t));
nfr2 = 0;
ncep = 2;
nfr = feat_s2mfc2feat_live(fcb, in_feats, &ncep, TRUE, FALSE, optr);
printf("Processed %d input %d output frames\n", ncep, nfr);
nfr2 += nfr;
for (i = 0; i < nfr; ++i) {
printf("%d: ", i);
for (j = 0; j < 39; ++j) {
printf("%.3f ", MFCC2FLOAT(optr[i][0][j]));
}
printf("\n");
}
optr += nfr;
ncep = 2;
nfr = feat_s2mfc2feat_live(fcb, in_feats + 2, &ncep, FALSE, FALSE, optr);
nfr2 += nfr;
printf("Processed %d input %d output frames\n", ncep, nfr);
for (i = 0; i < nfr; ++i) {
printf("%d: ", i);
for (j = 0; j < 39; ++j) {
printf("%.3f ", MFCC2FLOAT(optr[i][0][j]));
}
printf("\n");
}
optr += nfr;
ncep = 2;
nfr = feat_s2mfc2feat_live(fcb, in_feats + 4, &ncep, FALSE, TRUE, optr);
nfr2 += nfr;
printf("Processed %d input %d output frames\n", ncep, nfr);
for (i = 0; i < nfr; ++i) {
printf("%d: ", i);
for (j = 0; j < 39; ++j) {
printf("%.3f ", MFCC2FLOAT(optr[i][0][j]));
}
printf("\n");
}
optr += nfr;
feat_free(fcb);
TEST_EQUAL(nfr1, nfr2);
for (i = 0; i < nfr1; ++i) {
for (j = 0; j < 39; ++j) {
TEST_EQUAL(out_feats[i][0][j], out_feats2[i][0][j]);
}
}
ckd_free_3d(out_feats2);
ckd_free_3d(out_feats);
ckd_free(in_feats);
return 0;
}
static void
utt_align(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
int32 nfr;
int k, i;
const char *cepdir;
const char *cepext;
char sent[16384];
cmd_ln_t *config = (cmd_ln_t*) data;
cepdir = cmd_ln_str_r(kbc->config, "-cepdir");
cepext = cmd_ln_str_r(kbc->config, "-cepext");
/* UGLY! */
/* Read utterance transcript and match it with the control file. */
if (fgets(sent, sizeof(sent), sentfp) == NULL) {
E_FATAL("EOF(%s) of the transcription\n", sentfile);
}
/* E_INFO("SENT %s\n",sent); */
/* Strip utterance id from the end of the transcript */
for (k = strlen(sent) - 1;
(k > 0) && ((sent[k] == '\n') || (sent[k] == '\t')
|| (sent[k] == ' ')); --k);
if ((k > 0) && (sent[k] == ')')) {
for (--k; (k >= 0) && (sent[k] != '('); --k);
if ((k >= 0) && (sent[k] == '(')) {
sent[k] = '\0';
/* Check that uttid in transcript and control file match */
for (i = ++k;
sent[i] && (sent[i] != ')') &&
(sent[i] != '\n') && (sent[i] != '\t')
&& (sent[i] != ' '); i++);
sent[i] = '\0';
if (id_cmp(sent + k, uttid) != 0)
E_ERROR
("Uttid mismatch: ctlfile = \"%s\"; transcript = \"%s\"\n",
uttid, sent + k);
}
}
/* Convert input file to cepstra if waveform input is selected */
if (cmd_ln_boolean_r(config, "-adcin")) {
int16 *adcdata;
int32 nsamps = 0;
mfcc_t **mfcc;
if ((adcdata = bio_read_wavfile(cmd_ln_str_r(config, "-cepdir"),
ur->uttfile,
cmd_ln_str_r(config, "-cepext"),
cmd_ln_int32_r(config, "-adchdr"),
strcmp(cmd_ln_str_r(config, "-input_endian"), "big"),
&nsamps)) == NULL) {
E_FATAL("Cannot read file %s\n", ur->uttfile);
}
fe_start_utt(fe);
if (fe_process_utt(fe, adcdata, nsamps, &mfcc, &nfr) < 0) {
E_FATAL("MFCC calculation failed\n", ur->uttfile);
}
ckd_free(adcdata);
if (nfr > S3_MAX_FRAMES) {
E_FATAL("Maximum number of frames (%d) exceeded\n", S3_MAX_FRAMES);
}
if ((nfr = feat_s2mfc2feat_live(kbcore_fcb(kbc),
mfcc,
&nfr,
TRUE, TRUE,
feat)) < 0) {
E_FATAL("Feature computation failed\n");
}
if (mfcc)
ckd_free_2d((void **)mfcc);
}
else {
nfr =
feat_s2mfc2feat(kbcore_fcb(kbc), ur->uttfile, cepdir, cepext, sf, ef, feat,
S3_MAX_FRAMES);
}
if (ur->regmatname) {
if (kbc->mgau)
adapt_set_mllr(adapt_am, kbc->mgau, ur->regmatname,
ur->cb2mllrname, kbc->mdef, kbc->config);
else if (kbc->ms_mgau)
model_set_mllr(kbc->ms_mgau, ur->regmatname, ur->cb2mllrname,
kbcore_fcb(kbc), kbc->mdef, kbc->config);
else
E_WARN("Can't use MLLR matrices with .s2semi. yet\n");
}
if (nfr <= 0) {
if (cepdir != NULL) {
E_ERROR
("Utt %s: Input file read (%s) with dir (%s) and extension (%s) failed \n",
uttid, ur->uttfile, cepdir, cepext);
}
else {
E_ERROR
("Utt %s: Input file read (%s) with extension (%s) failed \n",
uttid, ur->uttfile, cepext);
}
}
else {
E_INFO("%s: %d input frames\n", uttid, nfr);
align_utt(sent, nfr, ur->uttfile, uttid);
}
}
void
utt_decode(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
kb_t *kb;
kbcore_t *kbcore;
cmd_ln_t *config;
int32 num_decode_frame;
int32 total_frame;
stat_t *st;
srch_t *s;
num_decode_frame = 0;
E_INFO("Processing: %s\n", uttid);
kb = (kb_t *) data;
kbcore = kb->kbcore;
config = kbcore_config(kbcore);
kb_set_uttid(uttid, ur->uttfile, kb);
st = kb->stat;
/* Convert input file to cepstra if waveform input is selected */
if (cmd_ln_boolean_r(config, "-adcin")) {
int16 *adcdata;
int32 nsamps = 0;
if ((adcdata = bio_read_wavfile(cmd_ln_str_r(config, "-cepdir"),
ur->uttfile,
cmd_ln_str_r(config, "-cepext"),
cmd_ln_int32_r(config, "-adchdr"),
strcmp(cmd_ln_str_r(config, "-input_endian"), "big"),
&nsamps)) == NULL) {
E_FATAL("Cannot read file %s\n", ur->uttfile);
}
if (kb->mfcc) {
ckd_free_2d((void **)kb->mfcc);
}
fe_start_utt(kb->fe);
if (fe_process_utt(kb->fe, adcdata, nsamps, &kb->mfcc, &total_frame) < 0) {
E_FATAL("MFCC calculation failed\n", ur->uttfile);
}
ckd_free(adcdata);
if (total_frame > S3_MAX_FRAMES) {
E_FATAL("Maximum number of frames (%d) exceeded\n", S3_MAX_FRAMES);
}
if ((total_frame = feat_s2mfc2feat_live(kbcore_fcb(kbcore),
kb->mfcc,
&total_frame,
TRUE, TRUE,
kb->feat)) < 0) {
E_FATAL("Feature computation failed\n");
}
}
else {
/* Read mfc file and build feature vectors for entire utterance */
if ((total_frame = feat_s2mfc2feat(kbcore_fcb(kbcore), ur->uttfile,
cmd_ln_str_r(config, "-cepdir"),
cmd_ln_str_r(config, "-cepext"), sf, ef,
kb->feat, S3_MAX_FRAMES)) < 0) {
E_FATAL("Cannot read file %s. Forced exit\n", ur->uttfile);
}
}
/* Also need to make sure we don't set resource if it is the same. Well, this mechanism
could be provided inside the following function.
*/
s = kb->srch;
if (ur->lmname != NULL)
srch_set_lm(s, ur->lmname);
if (ur->regmatname != NULL)
kb_setmllr(ur->regmatname, ur->cb2mllrname, kb);
/* These are necessary! */
s->uttid = kb->uttid;
s->uttfile = kb->uttfile;
utt_begin(kb);
utt_decode_block(kb->feat, total_frame, &num_decode_frame, kb);
utt_end(kb);
st->tot_fr += st->nfr;
}
int
agg_all_seg(feat_t *fcb,
segdmp_type_t type,
const char *fn,
uint32 stride)
{
uint32 seq_no;
vector_t *mfcc = NULL;
uint32 mfc_veclen = cmd_ln_int32("-ceplen");
uint32 n_frame;
uint32 n_out_frame;
uint32 blksz=0;
vector_t **feat = NULL;
uint32 i, j;
uint32 t;
uint32 n_stream;
const uint32 *veclen;
FILE *fp;
uint32 ignore = 0;
long start;
int32 no_retries=0;
n_stream = feat_dimension1(fcb);
veclen = feat_stream_lengths(fcb);
for (i = 0, blksz = 0; i < n_stream; i++)
blksz += veclen[i];
fp = open_dmp(fn);
start = ftell(fp);
if (s3write(&i, sizeof(uint32), 1, fp, &ignore) != 1) {
E_ERROR_SYSTEM("Unable to write to dmp file");
return S3_ERROR;
}
for (seq_no = corpus_get_begin(), j = 0, n_out_frame = 0;
corpus_next_utt(); seq_no++) {
if (mfcc) {
free(mfcc[0]);
ckd_free(mfcc);
mfcc = NULL;
}
/* get the MFCC data for the utterance */
if (corpus_get_generic_featurevec(&mfcc, &n_frame, mfc_veclen) < 0) {
E_FATAL("Can't read input features from %s\n", corpus_utt());
}
if ((seq_no % 1000) == 0) {
E_INFO("[%u]\n", seq_no);
}
if (feat) {
feat_array_free(feat);
feat = NULL;
}
if (n_frame < 9) {
E_WARN("utt %s too short\n", corpus_utt());
if (mfcc) {
ckd_free(mfcc[0]);
ckd_free(mfcc);
mfcc = NULL;
}
continue;
}
feat = feat_array_alloc(fcb, n_frame + feat_window_size(fcb));
feat_s2mfc2feat_live(fcb, mfcc, &n_frame, TRUE, TRUE, feat);
for (t = 0; t < n_frame; t++, j++) {
if ((j % stride) == 0) {
while (s3write(&feat[t][0][0],
sizeof(float32),
blksz,
fp, &ignore) != blksz) {
static int rpt = 0;
if (!rpt) {
E_ERROR_SYSTEM("Unable to write to dmp file");
E_INFO("sleeping...\n");
no_retries++;
}
sleep(3);
if(no_retries > 10){
E_FATAL("Failed to write to a dmp file after 10 retries of getting MFCC(about 30 seconds)\n ");
}
}
++n_out_frame;
}
}
}
if (fseek(fp, start, SEEK_SET) < 0) {
E_ERROR_SYSTEM("Unable to seek to begin of dmp");
return S3_ERROR;
}
E_INFO("Wrote %u frames to %s\n", n_out_frame, fn);
if (s3write((void *)&n_out_frame, sizeof(uint32), 1, fp, &ignore) != 1) {
E_ERROR_SYSTEM("Unable to write to dmp file");
return S3_ERROR;
}
return S3_SUCCESS;
}
int
main(int argc, char *argv[])
{
feat_t *fcb;
mfcc_t **in_feats, ***out_feats;
int32 i, j, ncep;
/* Test "raw" features without concatenation */
fcb = feat_init("13", CMN_NONE, 0, AGC_NONE, 1, 13);
in_feats = (mfcc_t **)ckd_alloc_2d_ptr(6, 13, data, sizeof(mfcc_t));
out_feats = (mfcc_t ***)ckd_calloc_3d(6, 1, 13, sizeof(mfcc_t));
ncep = 6;
feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
for (i = 0; i < 6; ++i) {
for (j = 0; j < 13; ++j) {
printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
}
printf("\n");
}
feat_free(fcb);
ckd_free(in_feats);
ckd_free_3d(out_feats);
/* Test "raw" features with concatenation */
fcb = feat_init("13:1", CMN_NONE, 0, AGC_NONE, 1, 13);
in_feats = (mfcc_t **)ckd_alloc_2d_ptr(6, 13, data, sizeof(mfcc_t));
out_feats = (mfcc_t ***)ckd_calloc_3d(8, 1, 39, sizeof(mfcc_t));
ncep = 6;
feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
for (i = 0; i < 6; ++i) {
for (j = 0; j < 39; ++j) {
printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
}
printf("\n");
}
feat_free(fcb);
/* Test 1s_c_d_dd features */
fcb = feat_init("1s_c_d_dd", CMN_NONE, 0, AGC_NONE, 1, 13);
ncep = 6;
feat_s2mfc2feat_live(fcb, in_feats, &ncep, 1, 1, out_feats);
for (i = 0; i < 6; ++i) {
for (j = 0; j < 39; ++j) {
printf("%.3f ", MFCC2FLOAT(out_feats[i][0][j]));
}
printf("\n");
}
/* Verify that the deltas are correct. */
for (i = 2; i < 4; ++i) {
for (j = 0; j < 13; ++j) {
if (fabs(MFCC2FLOAT(out_feats[i][0][13+j] -
(out_feats[i+2][0][j]
- out_feats[i-2][0][j]))) > 0.01) {
printf("Delta mismatch in [%d][%d]\n", i, j);
return 1;
}
}
}
feat_free(fcb);
ckd_free(in_feats);
ckd_free_3d(out_feats);
return 0;
}
