FE_feature.h
上传用户:italyroyal
上传日期:2013-05-06
资源大小:473k
文件大小:14k
源码类别:

语音合成与识别

开发平台:

Visual C++

  1. ///////////////////////////////////////////////////////////////////////////////
  2. // This is a part of the Feature program.
  3. // Version: 1.0
  4. // Date: February 22, 2003
  5. // Programmer: Oh-Wook Kwon
  6. // Copyright(c) 2003 Oh-Wook Kwon. All rights reserved. owkwon@ucsd.edu
  7. ///////////////////////////////////////////////////////////////////////////////
  8. #ifndef _FE_FEATURE_H_
  9. #define _FE_FEATURE_H_
  10. #include "FE_common.h"
  11. #include "FE_endpoint.h"
  12. #include "FE_pitch.h"
  13. #include "FE_enhance.h"
  14. #include "FE_window.h"
  15. #include "FE_polynomial.h"
  16. #include "FE_plcc.h"
  17. typedef CPolynomial<float> Polynomial;
  18. typedef Complex<float> CComplex;
  19. // Include definition for interface
  20. #ifdef MAIN_PROGRAM
  21. #include "FE_wave_feature.h"
  22. #else
  23. #include "../kWaves-0.95/Sources/WaveFeature.h"
  24. #endif
  25. class FeComplex { /* Complex number */
  26. public:
  27. float m_re;
  28. float m_im;
  29. };
  30. class FeSpectrum { /* Spectrum for PLP */
  31. public:
  32. int  m_ntime;
  33. int  m_nfreq;
  34. float  m_rate;
  35. float  **m_specData;
  36. };
  37. /* Feature name must be consistent with the declaration of FeatKind */
  38. enum FeatKind { /* feature kind */
  39. FE_LPC=0, FE_LPCC, FE_PLCC, FE_MFCC, FE_FTCC, FE_FBANK, 
  40. FE_LPC_D, FE_LPCC_D, FE_PLCC_D, FE_MFCC_D, FE_FTCC_D, FE_FBANK_D,
  41. FE_FFT_SPEC, FE_LPC_SPEC, FE_LPCC_SPEC, FE_MFCC_SPEC, FE_FTCC_SPEC,
  42. FE_LPCCOV, FE_LAR, FE_LSF, FE_PARCOR, FE_FORMANT,
  43. FE_ZCR, FE_ENERGY, FE_PITCH, FE_VUS, FE_ENDPOINT,
  44. FE_EPOCH, FE_GLOFLOW, FE_GLOPULSE, FE_LPCRES, FE_FFTCEP,
  45. FE_FILE, FE_NUM_FEAT
  46. };
  47. /* Feature name must be consistent with the declaration of FeatKind */
  48. extern const char *FE_featNameA[];
  49. extern const char *FE_featExtA[];
  50. enum FeLifter { /* lifter type */
  51. LIFT_NO, LIFT_SIN, LIFT_LINEAR, LIFT_SQRT, LIFT_CUBE_ROOT
  52. };
  53. enum FeByteOrder { /* Byte order */
  54. MY_BIG_ENDIAN, MY_LITTLE_ENDIAN
  55. };
  56. enum EVusType { /* Silence/Voiced/Unvoiced frame classification */
  57. FRM_SILENCE, FRM_UNVOICED, FRM_VOICED
  58. };
  59. typedef struct { /* mel filter banks */
  60.     int m_lowX;
  61.     int m_centerX;
  62.     int m_highX;
  63. } MfccMelFB;
  64. class Fe { /* Feature extraction parameters */
  65. public:
  66. int *m_pProgress;
  67. int *m_pCancel;
  68. string m_tag;
  69. // common parameters
  70. int m_dither;
  71. int m_lpcOrder;
  72. int m_cepOrder;
  73. int m_fbOrder;
  74. int m_cepSmooth;
  75. int m_fftSize;
  76. int m_sampleRate;
  77. int m_shiftSizeMs;
  78. int m_winSizeMs;
  79. int m_deltaSize;
  80. float m_emphFac;
  81. FeWindow m_window;
  82. FeLifter m_lifter;
  83. FeByteOrder m_byteOrder;
  84. int m_swapByte; /* default byte order is little endian */
  85. int m_covShiftSizeMs, m_covWinSizeMs;
  86. // temporary storage
  87. vector<EVusType> m_vusA;
  88. vector<float> m_pitchA;
  89. vector<FeComplex> m_fftW; /* used to store the m_fftW complex array */
  90. // for MFCC
  91. int m_MelFBfftSize;
  92. vector<MfccMelFB> m_MelFB;
  93. vector<float> m_MelWeight;
  94. vector<float> m_MelCenterFreq;
  95. vector<int> m_MelCenterIdx;
  96. vector<float> m_dctMatrix;
  97. vector<float> m_idctMatrix;
  98. float m_logEnergyFloor;
  99. float m_energyFloor;
  100. // for pitch
  101. float m_meanPitch;
  102. int m_pitchFrameN;
  103. // for PLP
  104. int m_plpOrder; /* PLP model order  */
  105. int m_plccOrder; /* number of parameters */
  106. int m_plpGain; /* gain flag ON/OFF (1/0) */
  107. float m_plpExpon; /* peak enhancemnt factor */
  108. vector<FeComplex> m_plpW;       /* used by FFT() to hold W twiddle   */
  109. int m_plpMofW;
  110. vector<FeComplex> m_plpCF;      /* Trigonometrix Recombination Coeff  */
  111. int m_plpMofCF;
  112. int m_plpIcall;       /* Initialized data                 */
  113. int m_plpNfilt;
  114.     float m_plpHwei[512];     /* hamming window -- weigh speech   */
  115. float m_plpWcos[368];     /* was [23][16]                     */
  116.     float m_plpCb[900];
  117. int m_plpIbegen[69]; /* was [23][3]      */
  118. // basic.cpp
  119. int fftcep_spectrum_basic(short *sample, int frameSize, float *spectrum, int fftSize, int cepFilterLen);
  120. int lpc_spectrum_basic(short *sample, int frameSize, int norder, float *spectrum, int fftSize);
  121. int lpccep_spectrum_basic(short *sample, int frameSize, int ceporder, int norder, float *spectrum, int fftSize);
  122. int melcep_spectrum_basic(short *sample, int frameSize, int ceporder, float *spectrum, int fftSize);
  123. int lpc_basic(short *sample, int frameSize, float *acf, int norder, float *G);
  124. int lpc_cov_basic(short *sample, int frameSize, float *acf, int norder, float *G);
  125. int lpc_error_basic(short *sample, int frameSize, float *acf, int norder, float* residual);
  126. int parcor_basic(short *sample, int frameSize, float *kcf, int norder);
  127. int lar_basic(short *sample, int frameSize, float *lar, int norder);
  128. int formant_basic(short *sample, int frameSize, float *formant, int formantN, int norder);
  129. float calc_lpc_gain_basic(float *r, float *acf, int norder);
  130. int _lpc_parcor_basic(float *sample, int frameSize, float *acf, float *kcf, int norder, float *G);
  131. int _lpc_basic(float *sample, int frameSize, float *acf, int norder, float *G);
  132. int _lpc_error_basic(float *sample, int frameSize, float *acf, int norder, float* residual);
  133. int preprocessing(short *sample, int sampleN, float *out);
  134. float compute_energy(float *sample, int sampleN, float mean);
  135. int compute_zero_cross_rate(float *sample, int sampleN, int level, int dc_bias);
  136. int cepstral_window(float *cep,int ceporder, FeLifter lifter);
  137. int preemphasize(float *sample, int sampleN, float emphFac);
  138. // delta.cpp
  139. int delta_compute(FeMatrix<float>& input, int filterLen, FeMatrix<float>& output);
  140. int delta_basic(FeMatrix<float>& input, FeMatrix<float>& output, float *filterCoeff, int filterLen);
  141. int delta_init_filter(float *filterCoeff, int filterLen);
  142. // endpoint.cpp
  143. bool EpdMain(const char *inputfile, int sampleRate, const char *outputfile);
  144. int epd_basic(short *sampleA, int sampleN, int sampleRate, vector<CSegment>& endPointA);
  145. bool epd_insert_endpoint(vector<CSegment>& endPointA, float startPt, float endPt);
  146. // enhance.cpp
  147. int EnhanceMain(const char *infile, const char *outfile, int sampleRate, int isWiener);
  148. void enhance_basic(short *sample, int sampleN, int samplingRate, int isWiener);
  149. // epoch.cpp
  150. int calc_epoch(float *sample, int sampleN, vector<short>& epoch, short* PitchPeriod = NULL);
  151. float calc_DWT(float *sample, float *a, int len);
  152. // error.cpp
  153. int FE_INFO(char *fmt, ... );
  154. int FE_WARN(char *fmt, ... );
  155. int FE_ERROR(char *fmt, ... );
  156. int FE_FATAL(char *fmt, ... );
  157. int err_quit(char *fmt, ... );
  158. int err_ret(char *fmt, ... );
  159. int err_dump(char *fmt, ... );
  160. int err_fopen (const char *s);
  161. // feature.cpp
  162. Fe();
  163. virtual ~Fe();
  164. void Init(FeatKind fk, CFeature& adcData);
  165. int FeatureMain(FeatKind fk, const char *infile, const char *outfile, const char *parafile = NULL, const char* tag = NULL);
  166. int FeatureMain(FeatKind fk, CFeature& adcData, int beginX, int endX, CFeature& feature, int outBeginX, int outEndX);
  167. void FeatureExtract(FeatKind fk, const char *inputFile, const char *outputFile);
  168. int FeatureExtract(FeatKind fk, CFeature& adcData, int beginX, int endX, CFeature& feature, int outBeginX, int outEndX);
  169. int compute_feature_1d(FeatKind fk, float *sample, int sampleN, vector<short>& featA);
  170. int compute_feature_2d(FeatKind fk, float *sample, int sampleN, FeMatrix<float>& featA);
  171. int ReadParaFile(const char *parafile);
  172. int ReadTag(const char *tag, int* pTag, int ndim);
  173. int GetShiftSize();
  174. int GetFrameSize();
  175. int GetDim(FeatKind fk);
  176. float LogE(float x);
  177. int Integrate(float *a, int n, short *b);
  178. int Integrate(short *a, int n, short *b);
  179. float GetMedian(float* a, int n);
  180. int InitProgress(int* pProgress, int* pCancel);
  181. int CheckWinMessage();
  182. int ShowProgress(int progress);
  183. // formant.cpp
  184. int lpc_to_formant(float* acf, int norder, float* formant, int formantN, vector<CComplex>& rootsA);
  185. int formant_check_range(FeMatrix<float>& formant, int formantN, int frameN);
  186. int formant_median_filter(FeMatrix<float>& formant, int formantN, int frameN);
  187. int formant_linear_filter(FeMatrix<float>& formant, int formantN, int frameN);
  188. int formant_remove_nonvoice(FeMatrix<float>& formant, int formantN, int frameN, vector<float>& pitchA);
  189. // io.cpp
  190. int ad_read(FILE *fp, short *buf, int n);
  191. int ad_write(FILE *fp, short *buf, int n);
  192. int read_feature_basic(FeMatrix<float>& feat, int dim, FILE *fi);
  193. int write_feature_basic(FeMatrix<float>& feat, int num_frames, int dim, FILE *fo);
  194. int write_feature_vectors(FILE *fp, FeMatrix<float>& feat, int* pTag = NULL, const char* featname = NULL);
  195. int FREAD(void *ptr, int size, int nitems, FILE *stream);
  196. int FWRITE(void *ptr, int size, int nitems, FILE *stream);
  197. // lpc_cep.cpp
  198. int lpc_cepstrum_basic(short *sample, int frameSize, float *lpc_cep, int ceporder, int norder);
  199. int auto_correlation(float *wsamp, float *ac, int nsamp, int order);
  200. int levins (float *r, float *kcf, float *acf, int norder);
  201. int durbin(float *r, float *kcf, float *acf, int order);
  202. int stable_k(float *kcf, int norder); 
  203. int normalize_corr(float *r, int norder);
  204. int covariance(float *sample, int frameSize, FeMatrix<float>& cov, int order);
  205. int choldc(FeMatrix<float>& a, int n, float *p);
  206. int cholsl(FeMatrix<float>& a, int n, float *p, float *b, float *x);
  207. int CholeskySol(FeMatrix<float>& a, float *b, float *x, int n);
  208. int lpc_cov(float *sample, int frameSize, FeMatrix<float>& cov, float *acf, int order, float *G);
  209. int lpc_cov_error(float *sample, int frameSize, float *acf, int norder, float* residual);
  210. int lpc_to_cepstrum(float *acf, int norder, float *cep, int ncf, float G);
  211. int bilinear_transform(float *org_seq, int num_org_seq, float *trans_seq, int no_update, float warp_coeff); 
  212. // lsf.cpp
  213. int lsf_basic(short *sample, int frameSize, float *lsp, int norder);
  214. int lpc_to_lsf(float* acf, int norder, float* lsf, vector<CComplex>& oldRootsP, vector<CComplex>& oldRootsQ);
  215. // mel_cep.cpp
  216. int mel_cepstrum_basic(short *sample, int frameSize, float *mel_cep, int ceporder, int fftSize);
  217. int _mel_cepstrum_basic(float *sample, int frameSize, float *mel_cep, int fborder, int ceporder, int fftSize);
  218. void MfccInitMelFilterBanks (float startingFrequency, float samplingRate, int fftLength, int numChannels);
  219. void MfccMelFilterBank (float *sigFFT, int numChannels, float* output, int normalize);
  220. int MfccInitDCTMatrix (float *dctMatrix, int ceporder, int numChannels);
  221. int MfccInitIDCTMatrix (float *idctMatrix, int ceporder, int numChannels);
  222. void MfccDCT (float *x, float *dctMatrix, int ceporder, int numChannels, float *mel_cep);
  223. void MfccIDCT (float *mel_cep, float *idctMatrix, int ceporder, int numChannels, float *x);
  224. // misc_lib.cpp
  225. long lrand48();
  226. void srand48(long seedvar);
  227. void *m_alloc(int size);
  228. void *c_alloc(int num_of_elts, int size);
  229. void *re_alloc(void *block, int size);
  230. char **alloc2d(int dim1, int dim2, int size);
  231. char ***alloc3d(int dim1, int dim2, int dim3, int size);
  232. void free2d(void **p);
  233. void free3d(void ***p);
  234. int little_endian();
  235. float sum(int nstart, int nfinal, float *seq);      
  236. float product (int nstart, int nfinal, float *seq );      
  237. float power(float x, int n);
  238. int ipower(int x, int n);
  239. // noise.cpp
  240. double Random();
  241. double GaussianNoise(double x, double s);
  242. int AddNoise(float *sample, int num_of_samples, float *waveform, int insert_noise, float SNR);
  243. int Dither(float *buf, int n);
  244. // pitch.cpp
  245. int pitch_basic(short *sample, int sampleN, int sampleRate, int shiftSize, vector<EVusType>& vusA, vector<float>& pitchA);
  246. bool pitch_amdf(float *speech, float *amdf, int blockSize, int pmin, int pmax);
  247. float pitch_find(float *speech, int blockSize, float *pitchA, int t, float *amdf, int shiftSize, int sampleRate);
  248. bool pitch_low_pass_filter(short *input, int sampleN, int lpfLen);
  249. bool pitch_find_minmax(float *amdf, int pmin, int pmax, int* smin, int* smax);
  250. int pitch_remove_spike(vector<float>& pitchA);
  251. int pitch_linear_filter(vector<float>& pitchA);
  252. float pitch_fft_one_freq(float *sample, int blockSize, int p);
  253. // plp_cep.cpp
  254. int plp_cepstrum_basic(short *sample, int frameSize, float *plp_cep, int ceporder, int norder);
  255. int _plp_cepstrum_basic(float *sample, int frameSize, float *plp_cep, int ceporder, int norder);
  256. int init_plp();
  257. int _plp_basic(float *sample, int frameSize, float *plp_cep, int ceporder, int norder);
  258. int plp_analysis(float *speech, int frameSize, int m, float *a, float *rc, float *gain, int sf );
  259. int audw_ ( int npoint, int *nfilt, float *cb, int *ibegen, int sf );
  260. int cosf_ ( int m, int nfilt, float *wcos );
  261. int a2gexp_ ( float *a, float *gexp, int i, int nc, float expon );
  262. int TrigRecombFFT ( FeComplex *cx, FeComplex *y, int m );
  263. int PlpFFT( FeComplex *x, int m );
  264. int CalculateW ( int m );
  265. int CalculateCF( int m );
  266. int RastaFilter(FeSpectrum *mfsc, int r_filter, float r_f_param);
  267. // spectrum.cpp
  268. int fft_spectrum_basic(short *sample, int frameSize, float *spectrum, int fftSize);
  269. int _fft_spectrum_basic(short *sample, int frameSize, float *spectrum, int fftSize, int cep_smooth, int cepFilterLen);
  270. int fft_cepstrum_basic(short *sample, int frameSize, float *fft_cep, int ceporder, int fftSize);
  271. int _fft_cepstrum_basic(float *sample, int frameSize, float *fft_cep, int ceporder, int fftSize);
  272. int filterbank_basic(short *sample, int frameSize, float *filter_bank, int fborder, int fftSize);
  273. int _filterbank_basic(float *sample, int frameSize, float *filter_bank, int fborder, int fftSize, int cep_smooth, int cepFilterLen);
  274. int compute_spectrum(float *input, float *spectrum, int winlength, int log2length);
  275. int smooth_spectrum(float *spectrum, int pointsN);
  276. void FAST_new(FeComplex *x, int m);
  277. // vus.cpp
  278. int vus_basic(short *sample, int sampleN, int frameSize, vector<EVusType>& vusA);
  279. int vus_median_filter(vector<EVusType>& vusA);
  280. int vus_remove_short_segments(vector<EVusType>& vusA);
  281. int vus_remove_short_segments_sub(vector<EVusType>& vusA, EVusType type, int minDur);
  282. };
  283. int GetDefaultDim(enum FeatKind fk);
  284. int GetDefaultOrder(enum FeatKind fk);
  285. const char *GetFeatName(FeatKind fk);
  286. string GetFeatExtension(FeatKind fk);
  287. FeatKind GetFeatName2Kind(const char* name);
  288. FeatKind GetBaseFeatKind(FeatKind fk);
  289. int HasDeltaFeat(FeatKind fk);
  290. int HasStftFeat(FeatKind fk);
  291. int FE_CompareFloat(const void *a, const void *b);
  292. void PRFFT_NEW(float *a, float *b, int m, int n_pts, int iff);
  293. #endif