libsent/include/sent/mfcc.h

Go to the documentation of this file.

/************************************************************************/
/*    mfcc.h                                                            */
/*                                                                      */
/*    Author    : Yuichiro Nakano                                       */
/************************************************************************/

#ifndef __MFCC_H__
#define __MFCC_H__

#undef MFCC_TABLE_DEBUG

#define CPMAX 500               
#define CPSTEP 5                

#include <sent/stddefs.h>
#include <sent/htk_defs.h>
#include <ctype.h>

#define DEF_SMPPERIOD   625     
#define DEF_FRAMESIZE   400     
#define DEF_FFTNUM      512     
#define DEF_FRAMESHIFT  160     
#define DEF_PREENPH     0.97    
#define DEF_MFCCDIM     12      
#define DEF_CEPLIF      22      
#define DEF_FBANK       24      
#define DEF_DELWIN      2       
#define DEF_ACCWIN      2       
#define DEF_SILFLOOR    50.0    
#define DEF_ESCALE      1.0     

#define DEF_SSALPHA     2.0     
#define DEF_SSFLOOR     0.5     

/* version 2 ... ss_floor and ss_alpha removed */
#define VALUE_VERSION 2 

typedef struct {
  long smp_period;      
  long smp_freq;        
  int framesize;        
  int frameshift;       
  float preEmph;        
  int lifter;           
  int fbank_num;        
  int delWin;           
  int accWin;           
  float silFloor;       
  float escale;         
  int hipass;           
  int lopass;           
  int enormal;          
  int raw_e;            
  int zmeanframe;       

  /* items below does not need to be embedded, because they can be
     detemined from the acoustic model header, or should be computed
     from run-time variables */
  int delta;            
  int acc;              
  int energy;           
  int c0;               
  int absesup;          
  int cmn;              
  int mfcc_dim;         
  int baselen;          
  int vecbuflen;        
  int veclen;           

  int loaded;           
}Value;

typedef struct {
   int fftN;            
   int n;               
   int klo;             
   int khi;             
   float fres;          
   float *cf;           
   short *loChan;       
   float *loWt;         
   float *Re;           
   float *Im;           
} FBankInfo;

typedef struct {
  float **mfcc;                 
  int veclen;                   
  float *vec;                   
  int win;                      
  int len;                      
  int store;                    
  boolean *is_on;               
  int B;                        
} DeltaBuf;

typedef struct {
  float *bf;                    
  double *fbank;   
  FBankInfo fb; 
  int bflen;                    
#ifdef MFCC_SINCOS_TABLE
  double *costbl_hamming; 
  int costbl_hamming_len; 
  /* cos/-sin table for FFT */
  double *costbl_fft; 
  double *sintbl_fft; 
  int tbllen; 
  /* cos table for MakeMFCC */
  double *costbl_makemfcc; 
  int costbl_makemfcc_len; 
  /* sin table for WeightCepstrum */
  double *sintbl_wcep; 
  int sintbl_wcep_len; 
#endif /* MFCC_SINCOS_TABLE */
  float sqrt2var; 
  float *ssbuf;                 
  int ssbuflen;                 
  float ss_floor;               
  float ss_alpha;               
} MFCCWork;

typedef struct {
  float *mfcc_sum;              
  int framenum;                 
} CMEAN;

typedef struct {
  CMEAN *clist;         
  int clist_max;                
  int clist_num;                
  int dim;                      
  float cweight;                
  float *cmean_init;    
  boolean cmean_init_set;       
  CMEAN now;            
} CMNWork;

typedef struct {
  LOGPROB max_last;     
  LOGPROB min_last;     
  LOGPROB max;  
} ENERGYWork;

/**** mfcc-core.c ****/
MFCCWork *WMP_work_new(Value *para);
void WMP_calc(MFCCWork *w, float *mfcc, Value *para);
void WMP_free(MFCCWork *w);
/* Get filterbank information */
void InitFBank(MFCCWork *w, Value *para);
void FreeFBank(FBankInfo *fb);
/* Apply hamming window */
void Hamming (float *wave, int framesize, MFCCWork *w);
/* Apply pre-emphasis filter */
void PreEmphasise (float *wave, int framesize, float preEmph);
/* Return mel-frequency */
float Mel(int k, float fres);
/* Apply FFT */
void FFT(float *xRe, float *xIm, int p, MFCCWork *w);
/* Convert wave -> mel-frequency filterbank */
void MakeFBank(float *wave, MFCCWork *w, Value *para);
/* Apply the DCT to filterbank */ 
void MakeMFCC(float *mfcc, Value *para, MFCCWork *w);
/* Calculate 0'th Cepstral parameter*/
float CalcC0(MFCCWork *w, Value *para);
/* Calculate Log Raw Energy */
float CalcLogRawE(float *wave, int framesize);
/* Zero Mean Souce by frame */
void ZMeanFrame(float *wave, int framesize);
/* Re-scale cepstral coefficients */
void WeightCepstrum (float *mfcc, Value *para, MFCCWork *w);

/**** wav2mfcc-buffer.c ****/
/* Convert wave -> MFCC_E_D_(Z) (batch) */
int Wav2MFCC(SP16 *wave, float **mfcc, Value *para, int nSamples, MFCCWork *w);
/* Calculate delta coefficients (batch) */
void Delta(float **c, int frame, Value *para);
/* Calculate acceleration coefficients (batch) */
void Accel(float **c, int frame, Value *para);
/* Normalise log energy (batch) */
void NormaliseLogE(float **c, int frame_num, Value *para);
/* Cepstrum Mean Normalization (batch) */
void CMN(float **mfcc, int frame_num, int dim);

/**** wav2mfcc-pipe.c ****/
DeltaBuf *WMP_deltabuf_new(int veclen, int windowlen);
void WMP_deltabuf_free(DeltaBuf *db);
void WMP_deltabuf_prepare(DeltaBuf *db);
boolean WMP_deltabuf_proceed(DeltaBuf *db, float *new_mfcc);
boolean WMP_deltabuf_flush(DeltaBuf *db);

CMNWork *CMN_realtime_new(int dimension, float weight);
void CMN_realtime_free(CMNWork *c);
void CMN_realtime_prepare(CMNWork *c);
void CMN_realtime(CMNWork *c, float *mfcc);
void CMN_realtime_update(CMNWork *c);
boolean CMN_load_from_file(CMNWork *c, char *filename);
boolean CMN_save_to_file(CMNWork *c, char *filename);

void energy_max_init(ENERGYWork *energy);
void energy_max_prepare(ENERGYWork *energy, Value *para);
LOGPROB energy_max_normalize(ENERGYWork *energy, LOGPROB f, Value *para);

/**** ss.c ****/
/* spectral subtraction */
float *new_SS_load_from_file(char *filename, int *slen);
float *new_SS_calculate(SP16 *wave, int wavelen, int *slen, MFCCWork *w, Value *para);

/**** para.c *****/
void undef_para(Value *para);
void make_default_para(Value *para);
void make_default_para_htk(Value *para);
void apply_para(Value *dst, Value *src);
boolean htk_config_file_parse(char *HTKconffile, Value *para);
void calc_para_from_header(Value *para, short param_type, short vec_size);
void put_para(FILE *fp, Value *para);


#endif /* __MFCC_H__ */

---