int
fft( void *snd_sample, unsigned long size, double *outbuf, int typ )
{
unsigned long n;
if( nn != size ) {
if( _fft_init( size ) != 0 )
return -1;
}
if( typ == BYTE ) {
for( n = 0; n < nn; n++ ) {
#ifndef HAVE_FFTW
rout[bit_reverse[n]] = (((unsigned char*)snd_sample)[n] - 128) * window[n];
iout[bit_reverse[n]] = 0;
#else
rin[n] = (((unsigned char*)snd_sample)[n] - 128) * window[n];
#endif
}
} else {
for( n = 0; n < nn; n++ ) {
#ifndef HAVE_FFTW
rout[bit_reverse[n]] = ((unsigned int*)snd_sample)[n];
iout[bit_reverse[n]] = 0;
#else
rin[n] = ((int*)snd_sample)[n];
#endif
}
}
__fft_calculate;
for( n = 0; n < size / 2; n ++ )
#ifndef HAVE_FFTW
outbuf[n] = rout[n] * rout[n] + iout[n] * iout[n];
#else
outbuf[n] = rout[n] * rout[n] + rout[size - n] * rout[size - n];
#endif
return 0;
}
/*
** MFCC feature extraction.
** Input: sph - input speech signal
** param - input feature extraction parameters
** Output: feat - extracted features
**
** Tips: Before calling this function, you should have the *sph* and *param* input initialized and
** memory allocated. *param* can be initialized by *set_param* function, if it havn't been initialized,
** we will call the *init_param* function to initialize it with a group of default parameters.
*/
int mfcc(PTRSPH sph, PTRFEAT feat, PTRPARAM param) {
int i,j;
Frames frame;
//unsigned short *idx = NULL;
double *frm = NULL,*e = NULL,*c = NULL;
/* some initialization */
// initialize feature extraction parameters
if(_isParamInit==false){
_init_param(param);
}
// FFT initialize
if(_isFFTInit==false ){
if(_fft_init(param->fftNpts, &(param->_fftm))){ // first initialize
fprintf(stderr,"initialize FFT kernel failed. In line %d, in file: %s\n",__LINE__,__FILE__);
_isFFTInit = false;
return -1;
}
}
// filter_bank initialize
e = (double*)malloc(param->nFilters*sizeof(double));
if(!e){
fprintf(stderr,"memory realloc failed in line %d, in file: %s\n",__LINE__,__FILE__);
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0);
return -1;
}
if(_isFBinit == false){
if( _set_mel_idx(param->nFilters,param,sph->fs)){
fprintf(stderr,"_set_mel_idx failed in line %d, in file: %s\n", __LINE__,__FILE__);
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e);
return -1;
}
}
// DCT initialize
if(_isDCTInit==false ){
if(_dct_init(param->nFilters, param->nCeps)){ // first initialize
fprintf(stderr,"initialize DCT kernel failed. In line %d, in file: %s\n",__LINE__,__FILE__);
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e); free(idx);
_isDCTInit = false;
return -1;
}
}
c = (double*)malloc((param->nCeps+1)*sizeof(double));
if(!c){
fprintf(stderr,"memory realloc failed in line %d, in file: %s\n",__LINE__,__FILE__);
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e); free(idx); free(_dctk);
return -1;
}
// lifter initialize
if(_isLifter==false) {
if(_lifter_set(param->nLifter, param->nCeps)){
fprintf(stderr,"liftering initialize failed!\n");
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e); free(idx); free(_dctk);free(c);
return -1;
}
}
/* front-end process */
// pre-emphasis
_premphasis(sph, param->emphco);
// divide the signal into frames
if(_vec2frame(sph, &frame, param->frameLen, param->frameShift)){ return -1; }
// weighting window
if(_weightwin(&frame,param->win)){ return -1; }
// alloc memory for feature results
feat->vl = param->nCeps;
feat->vs = frame.nf;
feat->data = (double*)realloc(feat->data, sizeof(double)*feat->vl*feat->vs);
if(!feat->data){
fprintf(stderr,"memory realloc failed for feat->data in line %d, in file %s.\n",__LINE__,__FILE__);
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e); free(idx); free(_dctk); free(c);
return -1;
}
/* key transformations for each frame */
frm = frame.data;
for(i=0;i<frame.nf;i++){
// copy frame to buffer
memcpy(_fftbuf,frm+i*frame.fs,sizeof(double)*frame.fs);
for(j=frame.fs;j<param->fftNpts;j++)
*(_fftbuf+j) = (double)0.0;
if(_fft(param)){ // apply FFT
fprintf(stderr, "apply FFT failed!\n");
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e); free(idx); free(_dctk); free(c);
return -1;
}
if(_filterbank(_fftbuf,param->fftNpts, param->nFilters, 0, 1, e)) { // apply the filter bank
fprintf(stderr,"apply filter bank failed\n");
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e); free(idx); free(_dctk); free(c);
return -1;
}
if(_dct(e,c)){ // apply DCT
fprintf(stderr,"apply DCT failed\n");
free(_fftbuf); free(_w1c); free(_w3c); free(_jx0); free(e); free(idx); free(_dctk); free(c);
return -1;
}
for(j=0;j<param->nCeps;j++)
*(c+j) *= *(_rlifter+j);
/* save the extracted feature to feat->data */
memcpy(feat->data+feat->vl*i, c, sizeof(double)*feat->vl);
}
/* clear up */
free(e); free(c);free(frame.data);
return 0;
}
