开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 语音合成与识别 > 查看源码
mfcc.c
资源名称：mfcc.rar　[点击查看]
上传用户：qingan1008
上传日期：2022-06-04
资源大小：3k
文件大小：8k
源码类别：

语音合成与识别

开发平台：

C/C++

mfcc.c：源码内容
  1. #include "mfcc.h"
  2. #include <math.h>
  3. #include <stdio.h>
  5. int temp=1;
  6. int m_cepOrder = 12;
  7. int m_fbOrder = 23;
  8. float m_dctMatrix[(12+1)*23];
  9. int m_sampleRate=32000;
  10. WfMelFB m_MelFB[23];
  11. float  m_MelWeight[512/2+1];
  12. float m_logEnergyFloor;
  13. float m_energyFloor;
  15. //预加重
  16. int preemphasize(float *sample, int sampleN)
  17. {
  18. /* Setting emphFac=0 turns off preemphasis. */
  19. int i;
  20. float emphFac = (float)0.97;
  22. for (i = sampleN-1; i > 0; i--) {
  23. sample[i] = sample[i] - emphFac * sample[i-1];
  24. }
  25. sample[0] = (float)(1.0 - emphFac) * sample[0];
  27. return(1);
  28. }
  30. int preprocessing(short *sample, int sampleN, float *out)
  31. {
  32. int i;
  34. for(i=0;i<sampleN;i++)
  35. out[i]=sample[i];
  36. //if (m_dither) Dither(out, sampleN);
  37. preemphasize(out, sampleN);
  38. return 1;
  39. }
  41. //加窗
  42. int Do_hamm_window(float *inputA, int inputN)
  43. {
  44. int i;
  45. float* hamm_window ;
  46. float temp = (float)(2 * M_PI / (float)(inputN-1));
  48. hamm_window = (float*)malloc(inputN*4);
  50.     for (i=0 ; i<inputN ; i++ ) hamm_window[i] = (float)(0.54 - 0.46*cos(temp*i));
  52. for (i=0 ; i<inputN ;i++ ) inputA[i] = hamm_window[i]*inputA[i];
  54. free(hamm_window);
  56. return(1);
  57. }
  59. int mel_cepstrum_basic(short *sample, int frameSize, float *mel_cep, int ceporder, int fft_size)
  60. {
  61. float* frameA = (float*)malloc(frameSize*4);
  63. preprocessing(sample, frameSize, &frameA[0]);
  64. Do_hamm_window(&frameA[0], frameSize);
  66. _mel_cepstrum_basic(&frameA[0], frameSize, mel_cep, m_fbOrder, ceporder, fft_size);
  68. free(frameA);
  69. return 1;
  70. }
  72. int MfccInitDCTMatrix (float *dctMatrix, int ceporder, int numChannels)
  73. {
  74.     int i, j;
  75.     for (i = 0; i <= ceporder; i++){//12+1
  76.         for (j = 0; j < numChannels; j++){//23
  77.             dctMatrix[i * numChannels + j] = (float) cos (M_PI * (float) i / (float) numChannels * ((float) j + 0.5));
  78. if(i==0) dctMatrix[i * numChannels + j]*=(float)sqrt(1/(float)numChannels);
  79. else     dctMatrix[i * numChannels + j]*=(float)sqrt(2/(float)numChannels);
  80. }
  81. }
  82. return 1;
  83. }
  85. int _mel_cepstrum_basic(float *sample, int frameSize, float *mel_cep, int fborder, int ceporder, int fft_size)
  86. {
  87. int i;
  88. float* filter_bank = (float*)malloc(m_fbOrder*4);
  89. float f;
  91. MfccInitDCTMatrix (&m_dctMatrix[0], ceporder, fborder);
  92. _filterbank_basic(sample, frameSize, &filter_bank[0], fborder, fft_size, 0, 0);
  93. MfccDCT (filter_bank, &m_dctMatrix[0], ceporder, fborder, mel_cep);
  94. free(filter_bank);
  95. // /* scale down to be consistent with other kinds of cepstrum coefficients */
  96. f=fborder/(float)fft_size;
  97. for(i=0;i<=ceporder;i++)
  98. mel_cep[i]*=f;
  99. printf("gogogo%dn",temp);
  100.         temp++;
  101.     for(i=0;i<13;i++)
  102. {
  103.    printf("%ft",mel_cep[i]);
  104. }
  105.     return 1;
  106. }
  108. /* Supporting routine for MFCC */
  109. #define MfccRound(x) ((int)((x)+0.5))
  110. void MfccInitMelFilterBanks (float startingFrequency, float samplingRate, int fftLength, int numChannels)
  111. {
  112.     int i, k;
  113.     float* freq=(float*)malloc(numChannels*4+8);
  114. int * bin=(int *)malloc(numChannels*4+8);
  115. float start_mel, fs_per_2_mel;
  117. //m_MelWeight = (float*)malloc(fftLength*2+4);
  118.     /* Constants for calculation */
  119. freq[0] = startingFrequency;
  120.     start_mel = (float)(2595.0 * log10 (1.0 + startingFrequency / 700.0));
  121. bin[0] = MfccRound(fftLength * freq[0] / samplingRate);
  122. freq[numChannels+1] = (float)(samplingRate / 2.0);
  123.     fs_per_2_mel = (float)(2595.0 * log10 (1.0 + (samplingRate / 2.0) / 700.0));
  124. bin[numChannels+1] = MfccRound(fftLength * freq[numChannels+1] / samplingRate);
  126. /* Calculating mel-scaled frequency and the corresponding FFT-bin */
  127.     /* number for the lower edge of the band                          */
  128. for (k = 1; k <= numChannels; k++) {
  129.         freq[k] = (float)(700 * (pow (10, (start_mel + (float) k / (numChannels + 1) * (fs_per_2_mel - start_mel)) / 2595.0) - 1.0));
  130. bin[k] = MfccRound(fftLength * freq[k] / samplingRate);
  131. }
  133. /* This part is never used to compute MFCC coefficients */
  134. /* but initialized for completeness                     */
  137. for(i = 0; i<bin[0]; i++){
  138. m_MelWeight[i]=0;
  139. }
  140. m_MelWeight[fftLength/2]=1;
  142. /* Initialize low, center, high indices to FFT-bin */
  143. for (k = 0; k <= numChannels; k++) {
  144. if(k<numChannels){
  145. m_MelFB[k].m_lowX=bin[k];
  146. m_MelFB[k].m_centerX=bin[k+1];
  147. m_MelFB[k].m_highX=bin[k+2];
  148. }
  149. for(i = bin[k]; i<bin[k+1]; i++){
  150. m_MelWeight[i]=(i-bin[k]+1)/(float)(bin[k+1]-bin[k]+1);
  151. }
  152.     }
  155. free(freq);
  156. free(bin);
  159.     return;
  160. }
  161. float LogE(float x)
  162. {
  163. if(x>m_energyFloor) return log(x);
  164. else return m_logEnergyFloor;
  165. }
  167. void PRFFT_NEW(float *a, float *b, int m, int n_pts, int iff)
  168. {
  169. int l,lmx,lix,lm,li,j1,j2,ii,jj,nv2,nm1,k,lmxy,n;
  170. float scl,s,c,arg,T_a,T_b;
  172. n = 1 << m;
  173. for( l=1 ; l<=m ; l++ ) {
  174. lmx = 1 << (m - l) ;
  175. lix = 2 * lmx ;
  176. scl = 2 * (float)M_PI/(float)lix ;
  178. if(lmx < n_pts) lmxy = lmx ;
  179. else lmxy = n_pts ;
  180. for( lm = 1 ; lm <= lmxy ; lm++ ) {
  181. arg=((float)(lm-1)*scl) ;
  182. c = (float)cos(arg) ;
  183. s = iff * (float)sin(arg) ;
  185. for( li = lix ; li <= n ; li += lix ) {
  186. j1 = li - lix + lm ;
  187. j2 = j1 + lmx ;
  188. if(lmxy != n_pts ) {
  189. T_a=a[j1-1] - a[j2-1] ;
  190. /* T_a : real part */
  191. T_b=b[j1-1] - b[j2-1] ;
  192. /* T_b : imaginary part */
  193. a[j1-1] = a[j1-1] + a[j2-1] ;
  194. b[j1-1] = b[j1-1] + b[j2-1] ;
  195. a[j2-1] = T_a*c + T_b*s ;
  196. b[j2-1] = T_b*c - T_a*s ;
  197. } else{
  198. a[j2-1] = a[j1-1]*c + b[j1-1]*s ;
  199. b[j2-1] = b[j1-1]*c - a[j1-1]*s ;
  200. }
  201. }
  202. }
  203. }
  204. nv2 = n/2 ;
  205. nm1 = n - 1 ;
  206. jj = 1 ;
  208. for( ii = 1 ; ii <= nm1 ;) {
  209. if( ii < jj ) {
  210. T_a = a[jj-1] ;
  211. T_b = b[jj-1] ;
  212. a[jj-1] = a[ii-1] ;
  213. b[jj-1] = b[ii-1] ;
  214. a[ii-1] = T_a ;
  215. b[ii-1] = T_b ;
  216. }
  217. k = nv2 ;
  218. while( k < jj ) {
  219. jj = jj - k ;
  220. k = k/2 ;
  221. }
  222. jj = jj + k ;
  223. ii = ii + 1 ;
  224. }
  225. if(iff == (-1)){
  226. for( l=0 ; l<n ; l++ ) {
  227. a[l]/=(float)n;
  228. b[l]/=(float)n;
  229. }
  230. }
  231. }
  233. void MfccMelFilterBank (float *sigFFT, int numChannels, float* output, int normalize)
  234. {
  235.     float sum, wsum;
  236.     int i, k;
  237. MfccMelFB *melFB;
  239.     for (k=0;k<numChannels;k++){
  240. melFB=&m_MelFB[k];
  241.         sum = sigFFT[melFB->m_centerX];
  242. wsum=1;
  243.         for (i = melFB->m_lowX; i < melFB->m_centerX; i++){
  244.             sum += m_MelWeight[i] * sigFFT[i];
  245. wsum += m_MelWeight[i];
  246. }
  247. for (i = melFB->m_centerX+1; i <= melFB->m_highX; i++){
  248.             sum += (1 - m_MelWeight[i-1]) * sigFFT[i];
  249. wsum += (1 - m_MelWeight[i-1]);
  250. }
  251.         output[k] = sum;
  252. if(normalize) {
  253. // assert(wsum>0);
  254. output[k] /= wsum;
  255. }
  256.     }
  257.     return;
  258. }
  260. int _filterbank_basic(float *sample, int frameSize, float *filter_bank, int fborder, int fftSize, int cep_smooth, int cepFilterLen)
  261. {
  263. int i;
  264. float* a=(float*)malloc(fftSize*4);
  265. float* b=(float*)malloc(fftSize*4);
  267. int uiLogFFTSize = (int)(log((double)fftSize)/log((double)2)+0.5);
  269. MfccInitMelFilterBanks ((float)64.0, (float)m_sampleRate, fftSize, fborder);
  272. for(i=0;i<frameSize;i++){ a[i] = sample[i]; b[i]=0; }
  273. for(i=frameSize;i<fftSize;i++) a[i] = b[i] = 0;
  275. PRFFT_NEW( &a[0], &b[0], uiLogFFTSize, frameSize, 1);
  276. for(i=0;i<fftSize;i++){
  277. a[i] = a[i]*a[i] + b[i]*b[i];
  278. b[i] = 0.0;
  279. }
  280. MfccMelFilterBank (&a[0], fborder, &filter_bank[0], 1);
  281. for (i = 0; i < fborder; i++)
  282. filter_bank[i] = 0.5*LogE(filter_bank[i]);
  284. free(a);
  285. free(b);
  287. return(1);
  288. }
  290. void MfccDCT (float *x, float *dctMatrix, int ceporder, int numChannels, float *mel_cep)
  291. {
  292.     int i, j;
  293.     for (i = 0; i <= ceporder; i++) {
  294.         mel_cep[i] = 0.0;
  295.         for (j = 0; j < numChannels; j++){
  296.             mel_cep[i] += x[j] * dctMatrix[i * numChannels + j];
  297. }
  298.     }
  299.     return;
  300. }
  302. int main(int argc, char* argv[])
  303. {
  304. float mel_cep[12+1];
  305. short sample[512];
  306.     FILE*  fp;
  307. int templen;
  308. int i;
  309. //sample rate=32k 每个样点16BIT frame_size=512  fft_size=512  相邻两帧间重叠128个样点
  310. //滤波器个数＝23  MFCC个数＝12＋1
  311. m_logEnergyFloor=FE_MIN_LOG_ENERGY;
  312. m_energyFloor=(float)exp(m_logEnergyFloor);
  314. if ((fp=fopen(argv[1],"rb"))==NULL)
  315. {
  316. printf("Open Errorn");
  317. }
  320. while ((templen=fread(sample,2,512,fp))==512)
  321. {
  322. mel_cepstrum_basic(sample, 512, mel_cep, 12,512);
  323. fseek(fp,-512,SEEK_CUR);
  324. }
  326. fclose(fp);
  327. printf("lastn");
  328.     for(i=0;i<13;i++)
  329. {
  330.    printf("%ft",mel_cep[i]);
  331. }
  332.     return 0;
  333. }