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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
main_VAD_0909.cpp
资源名称：se06.rar　[点击查看]
上传用户：kepeng103
上传日期：2022-07-27
资源大小：2653k
文件大小：23k
源码类别：

DSP编程

开发平台：

C/C++

main_VAD_0909.cpp：源码内容
  1. /**********本函数的功能是用能量和自相*******************
  2. ***********关向量方差相结合的算法来进*******************
  3. ******************行VAD检测*****************************/
  5. /**********胡曙辉,2008年4月完成********************/
  7. /*4.3  加入了一些必须的初始化语句，*/
  8. /*4.7  在判断语音起始点和结束点加入了窗移动函数，即用连续多帧来进行判断*
  9. *******解决了训练过程的一个bug*******/
  10. /*4.8  把整个代码用函数实现**********/
  11. /*4.14 对语音的结束点判断采用了另一种方法*/
  12. /*4.16 静噪时候的压缩倍数必须增大，否则当输入信号的能量较大时，可以听到较小的压缩后输出。到1000倍左右，目前是150倍***
  13. ********为了减少误报率，必须提高能量门限，8倍到10倍左右，第二级门限设定到5至7倍，**
  14. ********找语音结束点的时候，采用的是两级判决方法，首先在50帧内计算出能量少于某一门限的帧数，如果帧数大于某一个值，这个值需要进行一定的试验调整（选15~25帧），然后对最后一帧用avv判决，这里好像有一定的偶然性，可能会提前终止语音。是否可以将avv加到能量判决那一部分中，统计同时满足两个条件的总帧数。*****
  15. ********当找到语音起始点的时候，默认输出100帧（1.6s），可能在换台的时候会使系统的静噪关断时延超过3s。因为后面还有50帧的统计，总时间为2.4s，如果第一次未能准确判决，将会有4.8s才能关断。将100帧换为75帧，时延减少0.4s，换为50帧，时延减少0.8s。********/
  16. /*k值有变换，今天试验的时候需要选择10，以前是2.5，有点奇怪。*/
  17. /*4.17 语音起始点判断的时候，连续两帧满足avv才判为语音起始点(效果很好，噪声误判率极低，试听了很久)*/
  18. /* 4.18 根据试验结果修改了一些参数值*/
  19. /* 4.23 改变了语音起始点的检测，起始点和结束点的参数也不一样，并不是判为噪声才进行噪声更新，在能量低于1.5倍门限的时候也进行噪声更新，防止长时间不更新噪声影响系统的判决。
  20.    每次找语音起始点之前重新训练信道*/
  21. #include "..commonhal.h"
  22. #include "device.h"
  23. #include "buf.h"
  24. #include <stdio.h>
  25. #include <math.h>
  26. #define FRAMELEN  256   
  27. #define PI       4.0*atan(1.0)
  29. float noise_energy[10]={0};
  30. float subframe_energy[32]={0}; 
  31. float input_signal[128]={0};
  32. float energy_threshhold=0;
  33. float average_noiseenergy=0;
  34. float signal_energy=0;
  35. float signal_temp[128];
  36. float frame_energyvariance=0;
  37. float frame_noisereference=0;
  38. float frame_energyreference;
  39. int16 qq[128]={0};
  40. int16 *p;
  43. /////////////////
  44. int16 cm[128];
  46. float w1[FRAMELEN]; //蝶形因子
  47. float fft1[FRAMELEN*2];    //每帧语音信号的FFT 
  48. float yp[FRAMELEN]; //未处理语音信号的功率谱
  49. float dp[129]; //噪声功率谱
  50. float xp[129]; //增强后语音信号的功率谱
  51. float predp[129];         //前一帧噪声信号的功率谱
  52. float prexp[129];         //前一帧增强后语音信号的功率谱
  53. float yo[FRAMELEN]; //增强后的时域信号
  54. float sita[FRAMELEN]; //相角
  55. float amp[FRAMELEN]; //幅度值
  56. float pre_energy[200]; //统计直方图所用每帧信号能量
  57. unsigned quota[129];
  58. float dm[FRAMELEN]; 
  59. float d1[FRAMELEN];
  60. float const hamming[FRAMELEN] = {0.0800, 0.0801, 0.0806, 0.0812, 0.0822, 0.0835, 0.0850, 0.0868, 
  61.      0.0888, 0.0912, 0.0938, 0.0967, 0.0998, 0.1032, 0.1069, 0.1108, 
  62.  0.1150, 0.1195, 0.1242, 0.1291, 0.1343, 0.1398, 0.1454, 0.1514, 
  63.                      0.1575, 0.1639, 0.1705, 0.1774, 0.1844, 0.1917, 0.1992, 0.2068, 
  64.                      0.2147, 0.2228, 0.2311, 0.2395, 0.2482, 0.2570, 0.2660, 0.2751, 
  65.                      0.2844, 0.2939, 0.3035, 0.3133, 0.3232, 0.3332, 0.3433, 0.3536, 
  66.                      0.3640, 0.3744, 0.3850, 0.3957, 0.4065, 0.4173, 0.4282, 0.4392, 
  67.                      0.4503, 0.4614, 0.4725, 0.4837, 0.4949, 0.5062, 0.5174, 0.5287, 
  68.                      0.5400, 0.5513, 0.5626, 0.5738, 0.5851, 0.5963, 0.6075, 0.6186, 
  69.                      0.6297, 0.6408, 0.6518, 0.6627, 0.6735, 0.6843, 0.6950, 0.7056, 
  70.                      0.7160, 0.7264, 0.7367, 0.7468, 0.7568, 0.7667, 0.7765, 0.7861, 
  71.                      0.7956, 0.8049, 0.8140, 0.8230, 0.8318, 0.8405, 0.8489, 0.8572, 
  72.                      0.8653, 0.8732, 0.8808, 0.8883, 0.8956, 0.9026, 0.9095, 0.9161, 
  73.                      0.9225, 0.9286, 0.9346, 0.9402, 0.9457, 0.9509, 0.9558, 0.9605, 
  74.                      0.9650, 0.9692, 0.9731, 0.9768, 0.9802, 0.9833, 0.9862, 0.9888, 
  75.                      0.9912, 0.9932, 0.9950, 0.9965, 0.9978, 0.9988, 0.9994, 0.9999, 
  76.                      1.0000, 0.9999, 0.9994, 0.9988, 0.9978, 0.9965, 0.9950, 0.9932, 
  77.                      0.9912, 0.9888, 0.9862, 0.9833, 0.9802, 0.9768, 0.9731, 0.9692, 
  78.                      0.9650, 0.9605, 0.9558, 0.9509, 0.9457, 0.9402, 0.9346, 0.9286, 
  79.                      0.9225, 0.9161, 0.9095, 0.9026, 0.8956, 0.8883, 0.8808, 0.8732, 
  80.                      0.8653, 0.8572, 0.8489, 0.8405, 0.8318, 0.8230, 0.8140, 0.8049, 
  81.                      0.7956, 0.7861, 0.7765, 0.7667, 0.7568, 0.7468, 0.7367, 0.7264, 
  82.                      0.7160, 0.7056, 0.6950, 0.6843, 0.6735, 0.6627, 0.6518, 0.6408, 
  83.                      0.6297, 0.6186, 0.6075, 0.5963, 0.5851, 0.5738, 0.5626, 0.5513, 
  84.                      0.5400, 0.5287, 0.5174, 0.5062, 0.4949, 0.4837, 0.4725, 0.4614, 
  85.                      0.4503, 0.4392, 0.4282, 0.4173, 0.4065, 0.3957, 0.3850, 0.3744, 
  86.                      0.3640, 0.3536, 0.3433, 0.3332, 0.3232, 0.3133, 0.3035, 0.2939, 
  87.                      0.2844, 0.2751, 0.2660, 0.2570, 0.2482, 0.2395, 0.2311, 0.2228, 
  88.                      0.2147, 0.2068, 0.1992, 0.1917, 0.1844, 0.1774, 0.1705, 0.1639, 
  89.                      0.1575, 0.1514, 0.1454, 0.1398, 0.1343, 0.1291, 0.1242, 0.1195, 
  90.                      0.1150, 0.1108, 0.1069, 0.1032, 0.0998, 0.0967, 0.0938, 0.0912, 
  91.                      0.0888, 0.0868, 0.0850, 0.0835, 0.0822, 0.0812, 0.0806, 0.0801}; //hamming窗
  92. float out1[FRAMELEN/2];
  93. ///////////
  96. void train(void);
  97. void read_signal(void);
  98. void compress_signal(void);
  99. void subframe_energyvar(void);
  100. void noise_update(void);
  102. void sys_init(void)
  103. {
  104. gpio_init();
  105. dac_reset();
  106. mcbsp0_init_serial();
  107. adc_init();
  108. mcasp_init();
  109. timer0_init();
  110. ADC_SE_HI();
  112. ISTP = 0x00000400;
  113. IER |= 0x00000002;
  114. CSR |= 0x00000001;
  115. }
  117. void spark_led(void)
  118. {
  119. REG32(MCASP1_PFUNC) |= 0x0000003e;
  120. REG32(MCASP1_PDIR) |= 0x0000003e;
  121. REG32(MCASP1_PDOUT) = 0x00000000;
  123. uint8 code = 1;  
  124. for(int k=0; k<10; k++) 
  125. {
  126. set_led(0xff, code);
  127. code <<= 1;
  128. code = (code == 0x20? 1:code);
  129. delay_ms(100);
  130. }
  131. REG32(MCASP1_PDOUT) = 0x00000000;
  132. }
  134. int16 data[128];
  136. void data_init(void)
  137. {
  138. for(int i=0; i<128; i++) 
  139. {
  140. data[i] = 30000*sin(i*PI*2/64);
  141. }
  142. }
  144. //////////////////////////
  145. void gen_w_r2(float* w, int n)     //产生旋转因子（n个）的函数
  146. {
  147.     int i;
  148.     float pi = 4.0*atan(1.0);
  149.     float e = pi*2.0/n;
  151.     for(i=0; i < ( n>>1 ); i++) {
  152.         w[2*i]   = cos(i*e);
  153.         w[2*i+1] = sin(i*e);
  154.     }
  155. }
  157. void bit_rev(float* x, int n)     //产生n比特翻转的函数,将x[]做n比特翻转
  158. {
  159.     int i, j, k;
  160.     float rtemp, itemp;
  161.     j = 0;
  163.     for(i=1; i < (n-1); i++) {
  164.         k = n >> 1;
  165.         while(k <= j) {
  166.             j -= k;
  167.             k >>= 1;
  168.         }
  169.         j += k;
  170.         if(i < j) {
  171.             rtemp    = x[j*2];
  172.             x[j*2]   = x[i*2];
  173.             x[i*2]   = rtemp;
  174.             itemp    = x[j*2+1];
  175.             x[j*2+1] = x[i*2+1];
  176.             x[i*2+1] = itemp;
  177.         }
  178.     }
  179. }
  182. void DSPF_sp_cfftr2_dit(float* x, float* w, short n)       //计算n点FFT的函数
  183. {                                                                   
  184.     short n2, ie, ia, i, j, k, m;                                    
  185.     float rtemp, itemp, c, s;                                        
  187.     n2 = n;                                                          
  188.     ie = 1;                                                          
  190.     for(k=n; k > 1; k >>= 1) {                                                                
  191.         n2 >>= 1; 
  192.         ia = 0;
  193.         for(j=0; j < ie; j++) {                                                             
  194.             c = w[2*j];
  195.             s = w[2*j+1];
  196.             for(i=0; i < n2; i++) {                                                          
  197.                 m = ia + n2;
  198.                 rtemp     = c * x[2*m]   + s * x[2*m+1];
  199.                 itemp     = c * x[2*m+1] - s * x[2*m];
  200.                 x[2*m]    = x[2*ia]   - rtemp;
  201.                 x[2*m+1]  = x[2*ia+1] - itemp;
  202.                 x[2*ia]   = x[2*ia]   + rtemp;
  203.                 x[2*ia+1] = x[2*ia+1] + itemp;
  204.                 ia++;
  205.             }
  206.         ia += n2;
  207.         }
  208.         ie <<= 1;                                               
  209.     }
  210. }
  213. void Stastic(void)
  214. {
  215. int h;
  216.    
  217. float term; //统计直方图的幅度间隔
  218. unsigned maxScript;     //记录统计直方图最大值下标
  219. float MAX; //200帧信号能量最大值
  220. float signal_energy;    //本帧信号能量
  221. float Threshold;        //直方图门限
  222. // float sum = 0.0; //本帧信号幅度值之和
  223. // float mean = 0.0; //平均每个点平均幅度
  225. float const coeffience1 = 3.8;   //3.8
  226. float const coeffience2 = 0.005; //0.007
  227. float const coeffience3 = 0.5;   //0.6
  230.     //做每帧信号的FFT
  231. for (h = 0; h < FRAMELEN; h++) 
  232. {
  233. fft1[h*2] = d1[h];      
  234.         fft1[h*2+1] = 0.0;    
  235. }
  237.         
  238. //做FRAMELEN个点FFT
  239.     gen_w_r2(w1, FRAMELEN);
  240.     bit_rev(w1, FRAMELEN/2);
  241.     DSPF_sp_cfftr2_dit(fft1, w1, FRAMELEN);   
  242.     bit_rev(fft1, FRAMELEN);
  243.           
  244.     
  245.     for (h=0; h < FRAMELEN; h++) 
  246.     {
  247.         yp[h] = fft1[h*2]*fft1[h*2] + fft1[h*2+1]*fft1[h*2+1];    //未处理语音信号的功率谱
  248.         sita[h] = atan2( fft1[h*2+1], fft1[h*2] );   //保留相角  
  249. } 
  251. /////////////////////////////////////////////////////////////////////////////////////////////////
  252. //                    下面的代码作能量值方图的统计,其原理为:
  253. //        短时能量的概率密度最大值点对应着噪声帧能量概率密度最大值点.因此具体实
  254. //    现时maxScript为带噪语音信号的短时能量概率密度达到最大值时对应的点，可以通
  255. //    过连续统计一定长度带噪语音信号的短时能量直方图得到.计算统计直方图的门限由
  256. //    maxScript可以得到判别有声帧和无声帧的门限.
  257. /////////////////////////////////////////////////////////////////////////////////////////////////
  259. signal_energy = 0.0;
  260. for(h = 0; h < FRAMELEN; h++)
  261. {
  262. signal_energy += d1[h]*d1[h];
  263. }
  265.     //计算统计直方图的门限
  266. MAX = 0.0;                                      
  267. for(h = 0; h < 199; h++)               
  268. {
  269. pre_energy[h] = pre_energy[h+1];
  270. }
  271. pre_energy[199] = signal_energy;
  273. for(h = 0; h < 200; h++)
  274. {
  275. if(pre_energy[h] > MAX)
  276. MAX = pre_energy[h];
  277. }
  279. term = MAX / 128;
  281. for(h = 0; h < 129; h++)
  282. {
  283. quota[h] = 0;
  284. }
  286. int flag;
  287. for(h = 0; h < 200; h++)
  288. {
  289. flag = ceil(pre_energy[h]/term);
  290. quota[flag]++;
  291. }
  293. maxScript = 0;
  294. for(h = 1; h < 129; h++)
  295. {
  296. if(quota[h] > quota[maxScript])
  297. maxScript = h;
  298. }
  300. Threshold = 285.0*(maxScript+0.5)*term/254.0;  //门限
  301.     
  302. /////////////////////////////////////////////////////////////////////////////////////////////////
  303. //                    下面的代码作噪声估计和语音增强,其原理为:
  304. //        由本帧信号短时能量与上述门限值比较,判别有声/无声帧.判为有声帧时,
  305. //    不更新噪声;判为噪声值时,更新噪声功率谱.
  306. /////////////////////////////////////////////////////////////////////////////////////////////////
  308.     for (h = 0; h < 129; h++)
  309. {
  310. if( signal_energy < Threshold )
  311. {
  312. dp[h] = 0.84*predp[h]+0.16*yp[h]; 
  313. xp[h] = coeffience3*(0.2*prexp[h]+0.8*((yp[h]-coeffience1*dp[h]>0.0) ? (yp[h]-coeffience1*dp[h]) : coeffience2*yp[h]));//为减小音乐噪声，噪声帧作衰减
  314. }
  315. else
  316. {
  317. dp[h] = predp[h];
  318.          xp[h] = 0.2*prexp[h]+0.8*((yp[h]-coeffience1*dp[h]>0.0) ? (yp[h]-coeffience1*dp[h]) : coeffience2*yp[h]); 
  319. }
  320. predp[h] = dp[h];
  321. prexp[h] = xp[h]; 
  322.         
  323.      //计算信号幅度
  324. amp[h] = sqrt( xp[h] );
  325.             
  326.         //计算了前129点的幅度，后面的127点利用FFT幅度的对称关系计算
  327.         if( h == 0 || h == 128 )
  328.             ;
  329.         else
  330.             amp[256-h] = amp[h];  
  331. }
  333.     //做IFFT   
  334. for (h = 0; h < FRAMELEN; h++) 
  335. {
  336.         fft1[h*2] = amp[h]*cos(sita[h]);         //IFFT变换输出结果的实部赋初值（输入信号的虚部）  
  337.         fft1[h*2+1] = -amp[h]*sin(sita[h]);      //IFFT变换输出结果的虚部赋初值（输入信号的实部）
  338.     }
  339.     DSPF_sp_cfftr2_dit(fft1, w1, FRAMELEN);   
  340.     bit_rev(fft1, FRAMELEN);
  342.     for(h=0; h < FRAMELEN; h++)
  343. { 
  344.         yo[h] = fft1[h*2]/FRAMELEN;
  345.     }
  346. }
  349. void Enhance(void)
  350. {
  351. int t, h;
  352. float const coeffience4 = 4.0; //3.0
  353. void Stastic(void);
  355. p = read_data();
  357. for(t = 0; t < 128; t++)
  358. {
  359. dm[t+128] = (float)p[t]; 
  360. }
  362. for (h = 0; h < FRAMELEN; h++)
  363. {
  364. d1[h] = dm[h]*hamming[h];   //加hamming窗处理
  365. }
  367. Stastic();
  369. for(t = 0; t < 128; t++)
  370. { 
  371.     cm[t] = (int16)( (yo[t]+out1[t])*0.5*coeffience4 ); 
  372. out1[t] = yo[t+128];   
  373. }
  374.   
  375. for(t=0; t < 128; t++)
  376. {
  377. dm[t] = dm[t+128];
  378. }
  380. }
  381. ///////////////////////////////////////////
  383. /**本函数的目的是训练信道******
  384. ***输入:读入10帧数据     ******
  385. ***输出:得到average_noiseenergy值和energy_threshhold值*/
  386. void train(void)
  387. {
  388. int i;
  389. int j;
  390. for(i=0; i<10; i++)
  391. {
  392. noise_energy[i] = 0.0;
  393. }
  394. for(i=0; i<10; i++)
  395. {
  396. p = read_data();
  397. for(j=0; j<128; j++)
  398. {
  399. input_signal[j] = (float)p[j];
  400. noise_energy[i] += input_signal[j]*input_signal[j]; 
  401. qq[j] = input_signal[j];
  402. }
  403. noise_energy[i]/=128;
  404. compress_signal();//训练的时候默认是关断输出
  405. write_data(qq);
  406. }
  407. average_noiseenergy = 0.0;
  408. for(i=0; i<10; i++)
  409. {
  410. average_noiseenergy += noise_energy[i];
  411. }
  412. average_noiseenergy /= 10;
  414. //能量判决门限初始化为起始10帧数据的平均能量值;        
  415. energy_threshhold = average_noiseenergy;
  417. }//训练结束
  419. /*****功能:读取一帧数据，并计算出signal_energy****
  420. ******输入:无                                 ****
  421. ******输出:一帧数据和此数据帧的signal_energy值***/
  422. void read_signal(void)
  423. {
  424. int i;
  425. // p = read_data();
  426. signal_energy = 0.0;
  427. for(i=0; i<128; i++)
  428. {
  429. input_signal[i] = (float)cm[i];
  430. qq[i] = (int16)input_signal[i];
  431. signal_energy += input_signal[i]*input_signal[i];
  432.     
  433. }     
  434. signal_energy /= 128;
  435. }
  437. /****功能:对qq[128]赋值零****
  438. *****输入:无             ****
  439. *****输出:qq[128]        ***/
  440. void compress_signal(void)
  441. {
  442. int i;
  443. for(i=0; i<128; i++)
  444.     {
  445. qq[i] = 0;
  446. }
  447. }
  450. /*****功能:把一帧数据分成32个子帧，计算出子帧      ****
  451. ******的frame_energyvariance与frame_energyreference****
  452. ******输入:一帧数据                                ****
  453. ******输出:frame_energyvariance与frame_energyreference值***/
  454. void subframe_energyvar(void)
  455. {
  456. int i;
  457. int j;
  458. int subframe_number = 32;
  459. float subframe_total;
  460. float subframelength=128/subframe_number;
  461.         
  462. for(i=0; i<subframe_number; i++)
  463. {
  464. subframe_energy[i]=0;
  465. }
  466. for(i=0; i<subframe_number; i++)
  467. {
  468. for(j=0; j<subframelength; j++)
  469. subframe_energy[i] += input_signal[i*4+j]*input_signal[i*4+j];
  470. subframe_energy[i] /= subframelength;
  471. }
  472. subframe_total = 0;
  473. for(i=0; i<subframe_number; i++)
  474. {
  475. subframe_total += subframe_energy[i];
  476. }
  477. frame_energyreference = subframe_total/subframe_number;
  478. frame_energyvariance = 0.0;
  479. for(i=0; i<subframe_number; i++)
  480. {
  481. frame_energyvariance += (subframe_energy[i]-frame_energyreference)*(subframe_energy[i]-frame_energyreference);
  482. }
  483. frame_energyvariance = sqrt(frame_energyvariance);
  484. }
  487. /*****功能:更新门限energy_threshhold****
  488. ******使之能自适应信道的变化        ****
  489. ******输入:一帧数据                 ****
  490. ******输出:门限energy_threshhold值  ***/
  491. void noise_update(void)
  492. {
  493. int i;
  494. float old_noiseenergyvar;
  495. float new_noiseenergyvar;
  496. float ratio;
  497. float t;
  499.         
  500. average_noiseenergy = 0.0;
  501. for(i=0; i<10; i++)
  502. {
  503. average_noiseenergy += noise_energy[i];
  504. }
  505. average_noiseenergy /= 10;
  506.         
  507. old_noiseenergyvar = 0.0;
  508. for(i=0; i<10; i++)
  509. old_noiseenergyvar += (noise_energy[i]-average_noiseenergy)*(noise_energy[i]-average_noiseenergy);
  510.         
  511. for(i=8; i<0; i++) //这里i最高只能取8！！！        
  512. {
  513. noise_energy[i+1] = noise_energy[i];
  514. noise_energy[0] =  signal_energy;
  515. }
  516. average_noiseenergy = 0.0;
  517. for(i=0; i<10; i++)
  518. {
  519. average_noiseenergy += noise_energy[i];
  520. }
  521. average_noiseenergy /= 100;
  522. new_noiseenergyvar = 0.0;
  523. for(i=0; i<10; i++)
  524. new_noiseenergyvar += (noise_energy[i]-average_noiseenergy)*(noise_energy[i]-average_noiseenergy);
  525. old_noiseenergyvar = sqrt(old_noiseenergyvar);
  526. new_noiseenergyvar = sqrt(new_noiseenergyvar);
  527. //根据当前噪声能量方差与先澳芰糠讲畹谋戎道炊詐赋值,借此自适应的跟踪信道的噪声变化;                    
  528.         
  529. ratio = new_noiseenergyvar/old_noiseenergyvar;
  530. if(ratio>=1.25)
  531. t=0.45;
  532. else if(ratio>=1.10)
  533. t=0.35;
  534. else if(ratio>=1.00)
  535. t=0.25;        
  536. else
  537. t=0.15;
  538. energy_threshhold = energy_threshhold*(1-t)+t*noise_energy[0];
  539.        
  541. }
  545. int main(void)
  546. {
  547. float a; //avv判决语音起始点的倍数
  548. float b;  //avv判决语音结束点的倍数
  549. float c; //第一级能量倍数
  550. float d;   //第二级能量倍数
  551. float f;
  552. int dip1,dip2,dip3,dip4;
  553. int value;  
  554. bool flag;
  556.     void Enhance(void);
  558. CSR &= (~0x00000001);
  559. IER = 0;
  561. data_init();
  562. buf_init();
  563. timer1_init();
  564. spark_led();
  565. sys_init();
  567. for(int t = 0; t < 128; t++)
  568. {
  569. out1[t] = 0.0;
  570.         dm[t] = 0.0;
  571. }
  572.     for(int t = 0; t < 129; t++)
  573. {
  574.         predp[t] = 0.0;
  575. prexp[t] = 0.0;
  576. }
  578. for(int i = 0; i < 200; i++)   //取200帧，用于能量直方图的更新，放音           
  579. {
  580. p = read_data();
  582.         for(int t = 0; t < 128; t++)
  583.         {
  584. dm[t+128] = (float)p[t];   
  585. }
  587. for (int h = 0; h < FRAMELEN; h++)
  588. {
  589. d1[h] = dm[h]*hamming[h];   //加hamming窗处理
  590. }
  592.         //计算信号能量
  593. pre_energy[i] = 0.0;
  594. for(int h = 0; h < FRAMELEN; h++)
  595. {
  596. pre_energy[i] += d1[h]*d1[h];
  597. }
  599. for(int t = 0; t < 128; t++)
  600.         {
  601. cm[t] = (int16)( (d1[t]+out1[t])*0.5 ); 
  602.      out1[t] = d1[t+128]; 
  603.      }
  605. write_data(cm);
  607. for(int t = 0; t < 128; t++)
  608. {
  609. dm[t] = dm[t+128];
  610. }
  611. }
  613. //循环判断每帧数据    
  615. while(1)
  616. {         
  617. //用十帧数据来训练整个算法,并得到相关参数.
  618. train();
  619. flag = false;//初始化flag:语音有无标志
  620. //找语音的起始点
  621.         
  622. while(!flag)
  623. {            
  624. value = REG32(GPIO_GPVAL);
  625. dip1 = value & 0x00000001;
  626. dip2 = value & 0x00000080;
  627. dip3 = value & 0x00000040;
  628. dip4 = value & 0x00000020; 
  630. if((!dip1) && (dip2) && (dip3) && (dip4))
  631. {
  632. a = 0.6;
  633. b = 0.2;
  634. c = 5;
  635. d = 3;
  636. f = 1.2;
  637. }
  639. else if((!dip1) && (dip2) && (dip3) && (!dip4))
  640. {
  641. a = 1.0;
  642. b = 1;
  643. c = 5;
  644. d = 4;
  645. f = 1.5;
  646. }
  648. else if((!dip1) && (dip2) && (!dip3) && (dip4))
  649. {
  650. a = 1.5;
  651. b = 1.5;
  652. c = 6;
  653. d = 4;
  654. f = 1.8;
  655. }
  658. else if((!dip1) && (dip2) && (!dip3) && (!dip4))
  659. {
  660. a = 4;
  661. b = 4;
  662. c = 6;
  663. d = 4;
  664. f=1.8;
  665. }
  666. else 
  667. ;
  668. Enhance();
  669. read_signal();
  670. //能量判决,如果读入帧的能量与门限值比较,如果大于门限,则输出                            
  671. if(signal_energy > c*energy_threshhold)
  672. {                  
  673. subframe_energyvar();
  674.           
  675. if(frame_energyvariance>(a)*(average_noiseenergy))
  676. {            
  677. flag = true;                       
  678. write_data(qq);   
  679. }
  680. else
  681. {
  682. compress_signal();
  683. flag = false;
  684. write_data(qq);
  685. noise_update();
  686. }
  688. }
  689.     //如果是d倍门限以上则需看avv;         
  690. else if(signal_energy > d*energy_threshhold)
  691. {
  692. subframe_energyvar();
  694. //avv判决           
  695. if(frame_energyvariance > (a)*(average_noiseenergy))
  696. {            
  697. flag = true;
  698. write_data(qq);
  699. }           
  700. else
  701. {                            
  702. compress_signal();
  703. flag = false;
  704. write_data(qq);
  705. noise_update();
  706. }
  707. }
  708.     
  709.         
  710. else if(signal_energy > 1.8*energy_threshhold)
  711. {                  
  712. subframe_energyvar();
  714. //avv判决;
  715. if(frame_energyvariance>a*(average_noiseenergy))
  716. {                        
  718. compress_signal();
  719. write_data(qq);
  720. Enhance();
  721. read_signal();
  722. subframe_energyvar();
  724. //avv判决;
  725. if(frame_energyvariance>(a)*(average_noiseenergy))
  726. {
  727. flag = true;
  728. write_data(qq);
  729. }
  730. else
  731. {
  732. compress_signal();
  733. write_data(qq);
  734. flag = false;
  735. noise_update();
  736. }
  737. }                
  738. //当判为静音帧时进行噪声更新;                  
  739. else                  
  740. {                        
  741. compress_signal();                        
  742. write_data(qq);
  743. flag = false;                        
  744. noise_update();                  
  745. }             
  746. }
  748. //小能量帧用avv判决 
  749. else
  750. {
  751. subframe_energyvar();
  752. if(frame_energyvariance>(a)*(average_noiseenergy))//文献中用的是frame_noisereference
  753. {
  754. compress_signal();
  755. write_data(qq);
  756. Enhance();
  757. read_signal();
  758. subframe_energyvar();
  760. //进一步avv判决;
  761. if(frame_energyvariance>(a)*(average_noiseenergy))
  762. {
  763. flag = true;
  764. write_data(qq);
  765. }
  766. else
  767. {
  768. compress_signal();
  769. write_data(qq);
  770. flag = false;
  771. noise_update();
  772. }
  773. }
  774. else
  775. {
  776. compress_signal();
  777. write_data(qq);
  778. flag = false;
  779. noise_update();
  780. }
  781. }//if(signal_energy > 8*energy_threshhold)
  782. }//while(!flag)结束
  784.         //找语音的结束点
  785. //如果有连续        
  786. while(flag)
  787. {    
  788.     value = REG32(GPIO_GPVAL);
  789. dip1 = value & 0x00000001;
  790. dip2 = value & 0x00000080;
  791. dip3 = value & 0x00000040;
  792. dip4 = value & 0x00000020;
  794. if((!dip1) && (dip2) && (dip3) && (dip4))
  795. {
  796. a = 0.6;
  797. b = 0.2;
  798. c = 5;
  799. d = 3;
  800. f = 1.2;
  801. }
  803. else if((!dip1) && (dip2) && (dip3) && (!dip4))
  804. {
  805. a = 1.0;
  806. b = 1;
  807. c = 5;
  808. d = 4;
  809. f = 1.5;
  810. }
  812. else if((!dip1) && (dip2) && (!dip3) && (dip4))
  813. {
  814. a = 1.5;
  815. b = 1.5;
  816. c = 6;
  817. d = 4;
  818. f = 1.8;
  819. }
  822. else if((!dip1) && (dip2) && (!dip3) && (!dip4))
  823. {
  824. a = 3;
  825. b = 3;
  826. c = 6;
  827. d = 4;
  828. f = 2.0;
  829. }
  830. else 
  831. ;
  832. //这种判断方法是在50帧中如果有15帧的能量小于1.5倍门限则进一步用avv判决  
  833. int s = 100;
  834. int totalenergynum = 0;
  835. int totalavvnum = 0;
  836. int totalnum = 0;
  837. // read_signal();
  838. Enhance();
  839. read_signal();
  840. //能量判决,如果读入k帧的能量与门限值比较,如果大于门限,则输出,否则进一步用AVV判决;               
  841. while(s!=0)
  842. {
  843. if(signal_energy < f*energy_threshhold)
  844. {
  845. totalenergynum++;
  846. noise_update();
  847. }
  848. else if(signal_energy < 1.8*energy_threshhold)
  849. {
  850. totalnum++;
  851. }
  852. else
  853. ;
  855. subframe_energyvar();
  857. //根据子帧能量方差与子帧的平均能量比较来做判决;
  858. if(frame_energyvariance<(b)*(average_noiseenergy))
  859. {
  860. totalavvnum++;
  861. }
  862.                    
  863. write_data(qq);
  864. Enhance();
  865. read_signal();
  866. s--;
  867. }
  869. //if(totalnum>60 && totalavvnum<60)
  870. //{
  871. // flag = true;  
  872. // write_data(qq);
  873. //}
  874. //else
  875. {
  876. if(totalenergynum>80 && totalavvnum>85)
  877. {
  878. totalenergynum=0;
  879. //语音结束点，并更新噪声
  880. flag = false;
  881. compress_signal();
  882. write_data(qq);
  883. noise_update();//当判为静音帧时进行噪声更新          
  884. }//if(totalenergynum>70 && totalavvnum>50)结束
  885. else
  886. {
  887. flag = true;
  888. write_data(qq);
  889. }
  891. }//while(s!=0)结束
  893. }//while(flag)结束
  895.     }//while(1)结束
  897. }//主函数结束