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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 语音合成与识别 > 查看源码
FE_endpoint.cpp
资源名称：speech_analysis.rar　[点击查看]
上传用户：italyroyal
上传日期：2013-05-06
资源大小：473k
文件大小：21k
源码类别：

语音合成与识别

开发平台：

Visual C++

FE_endpoint.cpp：源码内容
  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. ///////////////////////////////////////////////////////////////////////////////
  9. #include "StdAfx.h"
  10. #include "FE_feature.h"
  12. #include <limits.h>
  13. #include <math.h>
  14. #include <assert.h>
  17. /*-----------------------------------------------
  18. * Definition of End-point Detection parameters 
  19. *----------------------------------------------*/
  20. #ifndef DEFAULT_SAMPLING_RATE
  21. #define DEFAULT_SAMPLING_RATE       16000
  22. #endif
  23. #define DEFAULT_LONG_PAUSE_IN_MS      100 /* default duration of long-pause in millisecond (=100 ms) (changed for kWaves) */
  25. /* For provision when threre is no speech detected */
  26. #define EPD_OUTPUT_ALWAYS         1 /* write speech even if no speech is detected in order to satisfy the speech recognizer. */
  27. #define EPD_DUMMY_FRAMES                1 /* number of frames to be added when no speech is detected. */
  28. #define EPD_MULTIPLE_END_POINT          1 /* detect multiple speech segments (changed for kWaves) */
  30. /* Use terminology in the Aurora-3 VADNest */
  31. #define EPD_NB_FRAME_THRESHOLD_LTE     10
  32. #define EPD_LAMBDA_LTE               0.97
  33. #define EPD_SNR_THRESHOLD_UPD_LTE       4 /* in dB scale <-- 20 */
  34. #define EPD_MIN_FRAME                  10
  36. /* The minimum power of noise and speech are assumed as 14.5 and 37.5,
  37. which roughly correspond to the amplitude levels of 5 and 71. */
  38. #define EPD_NOISE_ENERGY_FLOOR       14.5 /* ~ 0.5+10*log10(5*5) */
  39. #define EPD_SPEECH_ENERGY_FLOOR      37.5 /* ~ 0.5+10*log10(71*71) */
  40. #define EPD_NOISE_CLEAN              30.5 /* */
  42. /* Input frame is decided as speech if the difference between the log frame energy
  43.    and the log mean energy exceeds the following threshold. The thresholds 40 and 48
  44.    denote that the log frame energy of speech is 6 and 8 times larger than the log 
  45.    mean energy, respectively. Note that the threshold is 15 in the Aurora-3 VADNest. */
  47. /* high noise case: internal microphone */
  48. /* The threshold should be optimized later for the target environment. */
  49. #define EPD_LOW_SNR                    10 /* */
  50. #define EPD_LOW_SNR_ENERGY_TH          12 /* ~ 10*log10(4*4) (changed for kWaves) */
  51. #define EPD_LOW_SNR_ZCR_TH             30 /* */
  53. /* low noise case: headset microphone */
  54. /* We increase the threshold in the denosing case because the input signals have been 
  55.    denoised in the preceding noise reduction module and therefore have larger SNR. */
  56. #define EPD_HIGH_SNR                   20 /* (changed for kWaves) */
  57. #define EPD_HIGH_SNR_ENERGY_TH         20 /* ~ 10*log10(10*10). (changed for kWaves) */
  58. #define EPD_HIGH_SNR_ZCR_TH             4 /* */
  60. /* Update signal energy if frame energy is larger than mean by this value in dB scale */
  61. #define EPD_SNR_THRESHOLD_UPD_SIGNAL_EN    10
  62. #define EPD_LAMBDA_SIGNAL_EN             0.95
  63. #define EPD_LAMBDA_ZCR                   0.98
  64. #define EPD_SPEECH_END_ENERGY_OFFSET        6 /* threshold decrease at the speech end */
  65. #define EPD_ZCR_THRESHOLD_UPD_LTE          20 /* threshold to update mean ZCR */
  68. /*---------------------
  69.  * local variables
  70.  *---------------------*/
  71. static int g_longPauseInMs = 0;
  74. bool Fe::EpdMain(const char *inputfile, int sampleRate, const char *outputfile)
  75. {
  76. FILE *fi;
  78. if( (fi = fopen(inputfile, "rb")) == NULL)
  79. return 0;
  81. fseek(fi,0L,SEEK_END);
  82. int fsize = ftell(fi);
  83. rewind(fi);
  84. vector<short> sample(fsize/sizeof(short));
  85. int sampleN = FREAD(&sample[0],sizeof(short),fsize/sizeof(short),fi);
  86. vector<CSegment> endPointA;
  88. if(!epd_basic(&sample[0], sampleN, sampleRate, endPointA)){
  89. fclose(fi);
  90. return false;
  91. }
  92. FILE *fo = fopen(outputfile, "wb");
  93. if(!fo){
  94. fprintf(stderr, "Cannot open %sn", outputfile);
  95. fclose(fi);
  96. return false;
  97. }
  98. fprintf(fo, "#LABELn");
  99. for(int i=0; i<endPointA.size(); i++){
  100. fprintf(fo,"%f -1 %sn",endPointA[i].m_fSegment, endPointA[i].m_szLabel.c_str());
  101. }
  102. fclose(fi);
  103. fclose(fo);
  104. return true;
  105. }
  108. int Fe::epd_basic(short *sampleA, int sampleN, int sampleRate, vector<CSegment>& endPointA)
  109. {
  110. int i,t,frameX;
  111. Epd epd;
  112. epd.Init(sampleRate,0,1,1);
  113. epd.InitNewUtterance();
  114. vector<float> in(epd.m_config.m_winSize);
  115. vector<float> out(epd.m_config.m_winSize);
  116. int frameSize=epd.m_config.m_winSize;
  117. int shiftSize=epd.m_config.m_shiftSize;
  118. int frameN=(int)((sampleN-(frameSize-shiftSize))/float(shiftSize));
  119. float period=epd.m_config.m_shiftSize/(float)sampleRate;
  120. FeReturnCode prevStatus=FE_NULL;
  121. int prevEndPt=-1;
  122. frameX=0;
  123. for(t=0;;t++){
  124. if(t>frameN) break;
  125. FeReturnCode inStatus;
  126. EpdFrameKind frameKind;
  127. if(t<frameN) {
  128. inStatus=FE_SPEECH;
  129. for(i=0;i<frameSize;i++) in[i]=sampleA[t*shiftSize+i];
  130. }
  131. else{ /* t==frameN */
  132. inStatus=FE_EOF;
  133. }
  134. FeReturnCode status=epd.OneFrame(&in[0], &out[0], frameX, frameSize, inStatus, &frameKind);
  135. if(status==FE_NULL || status==FE_WAITING){
  136. continue;
  137. }
  138. if(((prevStatus==FE_SPEECH) && (status==FE_END_POINT||status==FE_PAUSE)) || t==frameN){
  139. if(prevEndPt<epd.m_uttBeginX && epd.m_uttBeginX<epd.m_uttEndX){
  140. epd_insert_endpoint(endPointA,epd.m_uttBeginX*period,epd.m_uttEndX*period);
  141. prevEndPt=epd.m_uttEndX;
  142. }
  143. }
  144. prevStatus=status;
  145. frameX++;
  146. }
  147. return endPointA.size();
  148. }
  151. bool Fe::epd_insert_endpoint(vector<CSegment>& endPointA, float startPt, float endPt)
  152. {
  153. CSegment segment;
  154. segment.m_fSegment = startPt;
  155. segment.m_szLabel = "1";
  156. endPointA.push_back(segment);
  157. segment.m_fSegment = endPt;
  158. segment.m_szLabel = "0";
  159. endPointA.push_back(segment);
  160. return true;
  161. }
  164. Epd::Epd()
  165. {
  166. ParmInit(&m_config, DEFAULT_SAMPLING_RATE, 1);
  167. m_absTimeX=0;  /* initialized only once */
  168. }
  171. int Epd::ParmInit(EpdParm *epdParm, int samplingRate, int isDenoised)
  172. {
  173. epdParm->m_sampleRate=samplingRate;
  174. if(samplingRate==8000){
  175. epdParm->m_shiftSize        =    80; /* 10 ms. Should be same as frameShift in feature extraction */
  176. epdParm->m_winSize          =   200; /* 25 ms. */
  177. }
  178. else if(samplingRate==11025 || samplingRate==11000){
  179. epdParm->m_shiftSize        =   110; /* 10 ms. Should be same as frameShift in feature extraction */
  180. epdParm->m_winSize          =   256; /* 23.27 ms. */
  181. }
  182. else if(samplingRate==16000){
  183. epdParm->m_shiftSize        =   160; /* 10 ms. Should be same as frameShift in feature extraction */
  184. epdParm->m_winSize          =   400; /* 25 ms. */
  185. }
  186. else{
  187. float shiftMs=10, winMs=25;
  188. epdParm->m_winSize = (int)(winMs/1000*epdParm->m_sampleRate);
  189. epdParm->m_shiftSize = (int)(shiftMs/1000*epdParm->m_sampleRate);
  190. }
  192. epdParm->m_threshFrameN         =  EPD_NB_FRAME_THRESHOLD_LTE; /* 100 ms for determining thresholds (<= m_startSilenceFrameN) */
  193. epdParm->m_startFrameN          =    10; /* 100 ms for speech start detection */
  194. epdParm->m_startSilenceFrameN   =     0; /* add 0 ms of silence before speech start (<= epdParm->m_startFrameN) (changed for kWaves) */
  195. epdParm->m_endFrameN            =    30; /* 300 ms for pause detection */
  196. epdParm->m_endSilenceFrameN     =     5; /* add 50 ms of silence after speech end (changed for kWaves) */
  197. if(g_longPauseInMs>0){
  198. epdParm->m_longPauseFrameN  = g_longPauseInMs/10;
  199. }
  200. else{
  201. epdParm->m_longPauseFrameN  = DEFAULT_LONG_PAUSE_IN_MS/10; /* 500 ms of silence for speech end detection (<= m_endSilenceFrameN) */
  202. }
  203. return 1;
  204. }
  207. int Epd::Init(int samplingRate, int isAudio, int isActive, int isDenoised)
  208. {
  209. m_isAudio=isAudio;
  210. m_isActive=isActive;
  211. ParmInit(&m_config, samplingRate, isDenoised);
  213. m_uttBeginX=0;
  214. m_uttEndX=0;
  215. m_localStatus=EPD_STATUS_WAITING;
  216. m_localFrameX=0;
  217. m_sampleEndX=0;
  218. m_absTimeX=0;  /* initialized only once */
  220. /* initial values defined in the Aurora-3 VADNest */
  221. m_lambdaLTE=(float)EPD_LAMBDA_LTE;
  222. m_lambdaLTEhigherE=(float)0.99;
  223. m_lambdaSignalE=(float)EPD_LAMBDA_SIGNAL_EN;
  224. m_nbSpeechFrame=0;
  225. m_noiseEn=0;
  226. m_signalEn=0;
  227. m_meanZcr=0;
  228. m_lastSnr = (EPD_HIGH_SNR+EPD_LOW_SNR)/2;
  229. m_flagVAD=EPD_FK_SILENCE;
  231. return 1;
  232. }
  235. void Epd::SetMaxPause(int msec)
  236. {
  237. if(msec>EPD_MAX_PAUSE_IN_MS){
  238. fprintf(stderr, "[ERROR] Too large pause duration. Must be less than %dn",EPD_MAX_PAUSE_IN_MS);
  239. assert(0);
  240. }
  241. g_longPauseInMs = msec;
  242. }
  245. Epd::~Epd()
  246. {
  247. }
  250. int Epd::InitNewUtterance()
  251. {
  252. int i;
  253. for(i=0;i<EPD_FRAME_BUF_SIZE;i++) m_isSpeechA[i]=(EpdFrameKind)(-1);
  254. for(i=0;i<EPD_FRAME_BUF_SIZE;i++) m_zcrA[i]=0;
  255. m_localStatus=EPD_STATUS_WAITING;
  256. m_uttBeginX = 0;
  257. m_uttEndX = 0;
  258. m_localFrameX = 0;
  259. m_sampleEndX = 0;
  260. m_speechSegN = 0;
  261. return 1;
  262. }
  265. int Epd::PutSample(float *sampleA, int sampleN)
  266. {
  267. int i;
  268. for(i=0;i<sampleN;i++){
  269. m_epdSpeech[(m_sampleEndX)%EPD_SPEECH_BUF_SIZE]=(short)sampleA[i];
  270. m_sampleEndX=(m_sampleEndX+1)%EPD_SPEECH_BUF_SIZE;
  271. }
  272. return sampleN;
  273. }
  276. void EpdClose(Epd *epd)
  277. {
  278. }
  281. /* This algorithm is complicated for now and I need more elegant way of endpoint detection. */
  282. FeReturnCode Epd::OneFrame(float *in, float *out, int frameX, int winSize, FeReturnCode inStatus, EpdFrameKind *frameKind)
  283. {
  284. int i;
  285. int frameShift=m_config.m_shiftSize;
  286. int maxDataN=EPD_MAX_RECORD_TIME*m_config.m_sampleRate;
  288. if(m_localFrameX==0) PutSample(in,winSize);
  289. else                 PutSample(in+my_max(0,winSize-frameShift),frameShift);
  291. *frameKind=EPD_FK_SILENCE;
  292. if(m_isActive==0){
  293. if(inStatus==FE_EOF){
  294. m_uttEndX=m_localFrameX;
  295. return FE_END_POINT; /* end-point detected */
  296. }
  297. else{
  298. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[(m_localFrameX*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  299. *frameKind=OneFrame(in);
  300. m_uttEndX=m_localFrameX;
  301. return FE_SPEECH; /* in-speech */
  302. }
  303. }
  305. if(inStatus==FE_EOF && frameX+m_uttBeginX+m_config.m_startFrameN >= m_uttEndX){
  306. if(m_isSpeechA[(m_localFrameX-1)%EPD_FRAME_BUF_SIZE]==EPD_FK_SPEECH && m_isSpeechA[(m_localFrameX-2)%EPD_FRAME_BUF_SIZE]==EPD_FK_SPEECH){
  307. /* printf("n"); Error("Epd","[ERROR] EOF found in the middle of speechn"); */
  308. return FE_EARLY_END;
  309. }
  310. else if(m_isAudio==0 && EPD_OUTPUT_ALWAYS && (m_uttBeginX>m_uttEndX || m_speechSegN<1)){
  311. /* Because subsequent frames are all assumed silence, I regard the frame after the last speech as the end-point. */
  312. m_isSpeechA[m_localFrameX%EPD_FRAME_BUF_SIZE]=EPD_FK_SILENCE;
  313. for(i=m_localFrameX-3;i>=m_localFrameX-m_config.m_endFrameN+1 && i>=0;i--){
  314. if(m_isSpeechA[i%EPD_FRAME_BUF_SIZE]==EPD_FK_SPEECH) break;
  315. }
  316. /* Let's make the speech recognizer happy by making one-frame dummy speech */
  317. if(m_uttEndX<m_uttBeginX+EPD_DUMMY_FRAMES){
  318. m_uttEndX=m_uttBeginX+EPD_DUMMY_FRAMES;
  319. }
  320. m_localStatus=EPD_STATUS_ENDPOINT;
  321. m_uttEndX=my_max(0,my_min(m_localFrameX,(i+1)+m_config.m_endSilenceFrameN));
  322. if(m_speechSegN==0) m_speechSegN++;
  323. /* printf("EPD: Endpoint detected (begin=%d, end=%d)n",m_uttBeginX,m_uttEndX); */
  324. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  325. return FE_END_POINT; /* in-speech */
  326. }
  327. else if(m_localStatus==EPD_STATUS_WAITING){
  328. /* printf("n"); Error("Epd","[ERROR] No speechn"); */
  329. return FE_NO_SPEECH;
  330. }
  331. }
  333. if(m_localStatus==EPD_STATUS_WAITING){
  334. /* find begin-point */
  335. /* printf("EPD: Searching for speech...n"); */
  336. *frameKind=OneFrame(in);
  337. if(FindBeginPoint(m_localFrameX-1)) {
  338. /* Add extra frames before the speech start-point of localFrameX-startFrameN */
  339. m_uttBeginX=my_max(0,(m_localFrameX-m_config.m_startFrameN-m_config.m_startSilenceFrameN+1));
  340. m_uttEndX=m_localFrameX;
  341. m_localStatus=EPD_STATUS_SPEECH;
  342. /* printf("EPD: Speech detected (begin=%d)n",m_uttBeginX); */
  343. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  344. return FE_SPEECH; /* in-speech */
  345. }
  346. else{
  347. return FE_WAITING;
  348. }
  349. }
  350. else if(m_localStatus==EPD_STATUS_SPEECH){
  351. if(inStatus==FE_EOF){
  352. /* Because subsequent frames are all assumed silence, I regard the frame after the last speech as the end-point. */
  353. m_isSpeechA[m_localFrameX%EPD_FRAME_BUF_SIZE]=EPD_FK_SILENCE;
  354. for(i=m_localFrameX-3;i>=m_localFrameX-m_config.m_endFrameN+1 && i>=0;i--){
  355. if(m_isSpeechA[i%EPD_FRAME_BUF_SIZE]==EPD_FK_SPEECH) break;
  356. }
  357. m_localStatus=EPD_STATUS_PAUSE;
  358. m_uttEndX=my_max(0,my_min(m_localFrameX,(i+1)+m_config.m_endSilenceFrameN));
  359. /* printf("EPD: Endpoint detected (begin=%d, end=%d)n",m_uttBeginX,m_uttEndX); */
  360. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  361. return FE_SPEECH; /* in-speech */
  362. }
  363. /* prepare to detect end-point */
  364. if(m_localFrameX<m_uttBeginX+m_config.m_endFrameN-1){
  365. *frameKind=OneFrame(in);
  366. return FE_NULL;
  367. }
  368. *frameKind=OneFrame(in);
  369. if(FindEndPoint(m_localFrameX-1, m_config.m_endFrameN)) {
  370. m_uttEndX=m_localFrameX-m_config.m_endFrameN;
  371. m_localStatus=EPD_STATUS_PAUSE;
  372. m_uttEndX=m_uttEndX+my_max(0,m_config.m_endSilenceFrameN-m_config.m_endFrameN);
  373. /* printf("EPD: Endpoint detected (begin=%d, end=%d)n",m_uttBeginX,m_uttEndX); */
  374. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  375. return FE_SPEECH; /* in-speech */
  376. }
  377. else{
  378. m_uttEndX=m_localFrameX;
  379. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  380. return FE_SPEECH; /* in-speech */
  381. }
  382. }
  384. else if(m_localStatus==EPD_STATUS_PAUSE){
  385. if(inStatus!=FE_EOF){
  386. *frameKind=OneFrame(in);
  387. }
  388. if(FindBeginPoint(m_localFrameX-1)) {
  389. m_uttEndX=m_localFrameX;
  390. m_localStatus=EPD_STATUS_SPEECH;
  391. /* printf("EPD: Speech detected again (begin=%d)n",m_localFrameX); */
  392. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  393. return FE_SPEECH; /* in-speech */
  394. }
  395. else if(m_localFrameX<m_uttBeginX+m_config.m_longPauseFrameN-1){
  396. if(frameX+m_uttBeginX < m_uttEndX){
  397. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  398. return FE_SPEECH; /* in-speech */
  399. }
  400. else if(inStatus==FE_EOF){
  401. m_uttEndX=m_uttBeginX+frameX;
  402. m_speechSegN++;
  403. return FE_END_POINT; /* end-point */
  404. }
  405. else{
  406. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  407. return FE_PAUSE; /* pause */
  408. }
  409. }
  410. else{
  411. if(FindEndPoint(m_localFrameX-1, m_config.m_longPauseFrameN)) {
  412. m_localStatus=EPD_STATUS_ENDPOINT;
  413. if(m_uttEndX < m_uttBeginX+frameX){
  414. m_speechSegN++;
  415. /* printf("EPD: Endpoint detected (begin=%d, end=%d)n",m_uttBeginX,m_uttEndX); */
  416. return FE_END_POINT; /* end-point */
  417. }
  418. else{
  419. m_uttEndX=m_uttBeginX+frameX;
  420. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  421. return FE_SPEECH; /* in-speech */
  422. }
  423. }
  424. else{
  425. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  426. return FE_PAUSE; /* pause */
  427. }
  428. }
  429. }
  430. else if(m_localStatus==EPD_STATUS_ENDPOINT){
  431. if(m_uttBeginX+frameX < m_uttEndX){
  432. for(i=0;i<winSize;i++) out[i]=m_epdSpeech[((m_uttBeginX+frameX)*frameShift+i)%EPD_SPEECH_BUF_SIZE];
  433. return FE_SPEECH; /* in-speech */
  434. }
  435. else{
  436. if(EPD_MULTIPLE_END_POINT){
  437. m_uttBeginX=m_localFrameX;
  438. m_uttEndX=m_localFrameX;
  439. m_localStatus=EPD_STATUS_WAITING;
  440. return FE_WAITING; /* wait for another speech */
  441. }
  442. else{
  443. m_speechSegN++;
  444. return FE_END_POINT; /* end-point */
  445. }
  446. }
  447. }
  448. else{
  449. assert(0);
  450. return FE_UNK_ERROR; /* unknown error */
  451. }
  453. return FE_UNK_ERROR; /* unknown error */
  454. }
  457. int Epd::FindBeginPoint(int endX) {
  458. int i, sum=0;
  459. assert(m_isSpeechA[endX%EPD_FRAME_BUF_SIZE] != -1);
  460. assert(m_localStatus==EPD_STATUS_WAITING || m_localStatus==EPD_STATUS_PAUSE);
  461. if(endX<m_config.m_startFrameN) return 0;
  463. for(i=endX;i>=endX-m_config.m_startFrameN+1;i--){ /* look back startFrameN frames */
  464. sum += (int)m_isSpeechA[i%EPD_FRAME_BUF_SIZE];
  465. }
  466. if(m_isSpeechA[endX%EPD_FRAME_BUF_SIZE]==EPD_FK_SPEECH && sum>=m_config.m_startFrameN-2) {
  467. /* Remove breath noise because it has low pitch frequency. */
  468. for(i=endX, sum=0;i>=endX-m_config.m_startFrameN+1;i--){
  469. if(m_zcrA[i%EPD_FRAME_BUF_SIZE] >= EPD_HIGH_SNR_ZCR_TH) sum++;
  470. }
  471. if(sum > m_config.m_startFrameN/2)
  472. return 1;
  473. else
  474. return 0;
  475. }
  476. else return 0;
  477. }
  480. int Epd::FindEndPoint(int endX, int reqSilN) {
  481. int i, sum=0;
  482. assert(m_isSpeechA[endX%EPD_FRAME_BUF_SIZE] != -1);
  483. assert(m_localStatus==EPD_STATUS_SPEECH || m_localStatus==EPD_STATUS_PAUSE);
  484. for(i=endX;i>=endX-reqSilN+1;i--){  /* look back endFrameN frames */
  485. sum += (int)m_isSpeechA[i%EPD_FRAME_BUF_SIZE];
  486. }
  487. if(m_isSpeechA[endX%EPD_FRAME_BUF_SIZE]==EPD_FK_SILENCE && sum<=1) return 1;
  488. else return 0;
  489. }
  492. EpdFrameKind Epd::OneFrame(const float *s)
  493. {
  494. int i, N=m_config.m_winSize;
  495. float frameEn, frameEnTh, sum, zcr, prev, snrEn, zcrTh;
  496. float x[EPD_MAX_WIN_SIZE];
  498. if(m_localFrameX<EPD_NB_FRAME_THRESHOLD_LTE)
  499. m_lambdaLTE=1-1/(float)(m_localFrameX+1);
  500. else
  501. m_lambdaLTE=(float)EPD_LAMBDA_LTE;
  503. if(m_localFrameX<EPD_NB_FRAME_THRESHOLD_LTE)
  504. m_lambdaZcr=1-1/(float)(m_localFrameX+1);
  505. else
  506. m_lambdaZcr=(float)EPD_LAMBDA_ZCR;
  508. /*
  509. owkwon: Prevent DC level from drifting and high frquency babble noise from surviving noise reduction.
  510. Here a band-pass filter with pass band 500-2800 Hz is used by cascading H1(z)=1-z^(-1)
  511. and H2(z)=z+1-z^(-1). This filter may sometimes lose unvoiced frames like /s/ and /ch/.
  512. The output of the Mel FB in the noise reduction module can be used for this purpose
  513. as the Aurora-3 uses the 2nd, 3rd, 4th FB coefficients. A more elaborate method is needed here. 
  514. */
  515. if(1){
  516. /* DC offset removal, H(z)=(1-z^(-1))/(1-0.999*z^(-1)), y[i]=x[i]-x[i-1]+(1-1/1024)*y[i-1] */
  517. float x0=0, y0=0, a=(1-1/(float)1024);
  518. for (i=0; i<N; i++){
  519. y0 = (float)(x[i] - x0 + a * y0); x0 = x[i]; x[i] = y0; /* in-place output */
  520. }
  522. /* low-pass filtering, H(z)=[1 2 1]/4 */
  523. x[0]=(s[1]+2*s[0]+s[0])/4; x[N-1]=(s[N-1]+2*s[N-1]+s[N-2])/4;
  524. for(i=1;i<N-1; i++) {
  525. x[i]=(s[i+1]+2*s[i]+s[i-1])/4;
  526. }
  527. }
  528. for(i=0, sum=0; i<N; i++) {
  529. sum += x[i]*x[i];
  530. }
  531. frameEn = (float)(0.5+10/log(10)*log(1+sum/N));
  533. /*
  534. owkwon: Added the condition (frameEn < EPD_SPEECH_ENERGY_FLOOR) for babble noise.
  535. The babble noise is not removed completely by noise reduction; there exist
  536. residual speech-like signals.
  537. */
  538. if((frameEn-m_noiseEn)<EPD_SNR_THRESHOLD_UPD_LTE || m_localFrameX<EPD_MIN_FRAME || (frameEn < EPD_SPEECH_ENERGY_FLOOR)){
  539. if((frameEn<m_noiseEn) || (m_localFrameX<EPD_MIN_FRAME) || (frameEn < EPD_SPEECH_ENERGY_FLOOR)){
  540. m_noiseEn=m_noiseEn+(1-m_lambdaLTE)*(frameEn-m_noiseEn);
  541. }
  542. else{
  543. m_noiseEn=m_noiseEn+(1-m_lambdaLTEhigherE)*(frameEn-m_noiseEn);
  544. }
  545. if(m_noiseEn<EPD_NOISE_ENERGY_FLOOR) m_noiseEn=(float)EPD_NOISE_ENERGY_FLOOR;
  546. m_noiseLevel=(float)(2*sqrt(exp(log(10)/10*(m_noiseEn-0.5))-1));
  547. }
  549. if((frameEn-m_noiseEn)>EPD_SNR_THRESHOLD_UPD_SIGNAL_EN){
  550. if(m_localFrameX>=EPD_MIN_FRAME){
  551. m_signalEn=m_signalEn+(1-m_lambdaSignalE)*(frameEn-m_signalEn);
  552. }
  553. else{
  554. m_signalEn=m_noiseEn+EPD_SNR_THRESHOLD_UPD_SIGNAL_EN;
  555. }
  556. if(m_signalEn-m_noiseEn < m_lastSnr/2)
  557. m_signalEn = m_noiseEn + m_lastSnr/2;
  558. }
  559. else if(frameEn>m_signalEn){
  560. m_signalEn=frameEn+EPD_SNR_THRESHOLD_UPD_SIGNAL_EN;
  561. if(m_signalEn-m_noiseEn < m_lastSnr/2)
  562. m_signalEn = m_noiseEn + m_lastSnr/2;
  563. }
  565. prev = x[0]-m_noiseLevel;
  566. for(i=1, zcr=0; i<N; i++) {
  567. float val  = x[i]-m_noiseLevel;
  568. float ztmp=val*prev;
  569. if(ztmp<0) zcr++;
  570. prev=val;
  571. }
  573. if((zcr-m_meanZcr) < EPD_ZCR_THRESHOLD_UPD_LTE || m_localFrameX<EPD_MIN_FRAME){
  574. m_meanZcr=m_meanZcr+(1-m_lambdaZcr)*(zcr-m_meanZcr);
  575. }
  577. snrEn=m_signalEn-m_noiseEn;
  578. {
  579. float slopeEn=(EPD_HIGH_SNR_ENERGY_TH-EPD_LOW_SNR_ENERGY_TH)/(float)(EPD_HIGH_SNR-EPD_LOW_SNR);
  580. float slopeZcr=(EPD_HIGH_SNR_ZCR_TH-EPD_LOW_SNR_ZCR_TH)/(float)(EPD_HIGH_SNR-EPD_LOW_SNR);
  581. frameEnTh=(float)(EPD_LOW_SNR_ENERGY_TH+slopeEn*(snrEn-EPD_LOW_SNR));
  582. if(m_localStatus==EPD_STATUS_SPEECH){
  583. frameEnTh = frameEnTh-EPD_SPEECH_END_ENERGY_OFFSET;
  584. }
  585. frameEnTh=my_max(EPD_LOW_SNR_ENERGY_TH,my_min(frameEnTh,EPD_HIGH_SNR_ENERGY_TH));
  586. zcrTh=(float)(EPD_LOW_SNR_ZCR_TH+slopeZcr*(snrEn-EPD_LOW_SNR));
  587. zcrTh=my_max(EPD_HIGH_SNR_ZCR_TH,my_min(zcrTh,EPD_LOW_SNR_ZCR_TH));
  588. }
  590. #if 0
  591. if(m_localFrameX%10==0){
  592. printf("%fn",snrEn);
  593. }
  594. #endif
  596. if(frameEn < EPD_SPEECH_ENERGY_FLOOR){
  597. m_flagVAD=EPD_FK_SILENCE;
  598. }
  599. else if(frameEn-m_noiseEn < EPD_LOW_SNR){
  600. m_flagVAD=EPD_FK_SILENCE;
  601. }
  602. else if((frameEn-m_noiseEn)>frameEnTh){
  603. m_flagVAD=EPD_FK_SPEECH;
  604. m_nbSpeechFrame=m_nbSpeechFrame+1;
  605. m_lastSnr=snrEn;
  606. }
  607. else{
  608. if(m_localFrameX>EPD_MIN_FRAME && m_noiseEn < EPD_NOISE_CLEAN && zcr-m_meanZcr >= zcrTh){
  609. m_flagVAD=EPD_FK_SPEECH;
  610. m_nbSpeechFrame=m_nbSpeechFrame+1;
  611. }
  612. else
  613. {
  614. m_flagVAD=EPD_FK_SILENCE;
  615. }
  616. }
  617. m_zcrA[m_localFrameX%EPD_FRAME_BUF_SIZE]=zcr;
  618. m_isSpeechA[m_localFrameX%EPD_FRAME_BUF_SIZE]=m_flagVAD;
  619. m_localFrameX++;
  620. m_absTimeX++;
  621. return m_flagVAD;
  622. }