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

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

语音合成与识别

开发平台：

Visual C++

FE_feature.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. /*************************************************************************
  10. * Feature extraction
  11. * sampleN = Number of speech samples
  12. * frameN = Number of output parameter frames
  13. * frameN = int((sampleN-(frameSize-shiftSize))/shiftSize)
  14. *************************************************************************/
  16. #include "StdAfx.h"
  17. #include "FE_feature.h"
  20. /* Feature name must be consistent with the declaration of FeatKind */
  21. const char *FE_featNameA[]={
  22. "LPC", "LPCC", "PLCC", "MFCC", "FTCC", "FBANK", 
  23. "LPC_D", "LPCC_D", "PLCC_D", "MFCC_D", "FTCC_D", "FBANK_D",
  24. "FFT_SPEC", "LPC_SPEC", "LPCC_SPEC", "MFCC_SPEC", "FTCC_SPEC",
  25. "LPCCOV", "LAR", "LSF", "PARCOR", "FORMANT",
  26. "ZCR", "ENERGY", "PITCH", "VUS", "ENDPOINT",
  27. "EPOCH", "GLOFLOW", "GLOPULSE", "LPCRES", "FFTCEP",
  28. "FILE",0
  29. };
  32. #ifdef WIN32
  33. static char* strtok_r(char *s1, const char *s2, char **savept);
  34. #endif
  37. /************************************************************************
  38.  * Analysis Condition (Default)
  39.  *   ---- Don't Change !!
  40.  *************************************************************************/
  42. Fe::Fe()
  43. {
  44. /* set core parameters for adc data */
  45. m_sampleRate = DEFAULT_SAMPLING_RATE;
  46. m_emphFac = (float)FE_PRE_EMPH_FAC;
  48. /* set core parameters for analysis */
  49. m_shiftSizeMs = DEFAULT_SHIFT_SIZE_IN_MS;
  50. m_winSizeMs = DEFAULT_WINDOW_SIZE_IN_MS;
  51. m_lpcOrder = FE_LPC_ORDER;
  52. m_cepOrder = FE_CEP_ORDER;
  53. m_fbOrder = FE_NUM_CHANNELS;
  54. m_fftSize = DEFAULT_FFT_SIZE;
  55. m_deltaSize = FE_DELTA;
  56. m_lifter = LIFT_SIN;
  58. /* set extra parameters */
  59. m_dither = FALSE; // set to TRUE in order to prevent underflow in taking log energy
  60. m_covShiftSizeMs = m_shiftSizeMs/5;
  61. m_covWinSizeMs = m_winSizeMs/6;
  62. m_cepSmooth = FALSE;
  63. if ( little_endian() ) {
  64. m_byteOrder = MY_LITTLE_ENDIAN;
  65. m_swapByte = 0;
  66. }
  67. else{
  68. m_byteOrder = MY_BIG_ENDIAN;
  69. m_swapByte = 1;
  70. }
  72. /* PLP */
  73. init_plp();
  75. /* MFCC */
  76. m_MelFBfftSize=0;
  77. m_logEnergyFloor=FE_MIN_LOG_ENERGY;
  78. m_energyFloor=(float)exp(m_logEnergyFloor);
  80. /* control parameters */
  81. m_pProgress = NULL;
  82. m_pCancel = NULL;
  83. }
  86. Fe::~Fe()
  87. {
  88. }
  91. void Fe::Init(FeatKind fk, CFeature& adcData)
  92. {
  93. if(fk==FE_PLCC) m_winSizeMs = PLP_WINDOW_SIZE_IN_MS;
  94. if(adcData.sampleFreqN>0) m_sampleRate = adcData.sampleFreqN;
  95. else if(m_sampleRate>0)adcData.sampleFreqN=m_sampleRate;
  97. if(m_sampleRate==8000){
  98. m_lpcOrder = FE_LPC_ORDER_1;
  99. }
  100. else if(m_sampleRate==16000){
  101. m_lpcOrder = FE_LPC_ORDER_2;
  102. }
  103. if(adcData.shiftN>0)
  104. m_shiftSizeMs = (int)((adcData.shiftN*1000)/adcData.sampleFreqN+0.5);
  105. else if(m_shiftSizeMs>0)
  106. adcData.shiftN=(int)(m_shiftSizeMs*adcData.sampleFreqN/1000);
  107. m_covShiftSizeMs = m_shiftSizeMs/5;
  108. }
  111. int Fe::FeatureMain(FeatKind fk, const char *infile, const char *outfile, const char *parafile, const char* tag)
  112. {
  113. if(parafile){
  114. ReadParaFile(parafile);
  115. }
  116. if(tag){
  117. m_tag=tag;
  118. }
  120. FILE *fi, *fo;
  121. if( (fi = fopen(infile, "rb")) == NULL)
  122. err_fopen(infile);
  123. if( (fo = fopen(outfile, "wb")) == NULL)
  124. err_fopen(outfile);
  126. fseek(fi,0L,SEEK_END);
  127. int fsize = ftell(fi);
  128. rewind(fi);
  129. CFeature adcData;
  130. adcData.vec.resize(fsize/sizeof(short));
  131. int sampleN = ad_read(fi,&adcData.vec[0],fsize/sizeof(short));
  133. CFeature feature;
  134. int frameN = FeatureMain(fk, adcData, 0, sampleN, feature, -1, -1);
  136. int dimN = GetDim(fk);
  137. vector<int> pTag(dimN);
  138. ReadTag(m_tag.c_str(), &pTag[0], dimN);
  139. string featname = GetFeatName(fk);
  140. switch(fk){
  141. case FE_LPCRES:
  142. case FE_EPOCH:
  143. case FE_GLOFLOW:
  144. ad_write(fo, &feature.vec[0], sampleN);
  145. break;
  146. default:
  147. write_feature_vectors(fo, feature.mat, &pTag[0], featname.c_str());
  148. break;
  149. }
  150. fclose(fi);
  151. fclose(fo);
  153. return 1;
  154. }
  157. int Fe::FeatureMain(FeatKind fk, CFeature& adcData, int beginX, int endX, CFeature& feature, int outBeginX, int outEndX)
  158. {
  159. if(adcData.shiftN != feature.shiftN){
  160. FE_ERROR("FeatureMain: The shift sizes of adaData and feature are different.n");
  161. if(feature.shiftN>0) adcData.shiftN=feature.shiftN;
  162. assert(0);
  163. }
  165. if(adcData.sampleFreqN != feature.sampleFreqN){
  166. FE_ERROR("FeatureMain: The sampling rates of adaData and feature are different.n");
  167. if(feature.sampleFreqN>0) adcData.sampleFreqN=feature.sampleFreqN;
  168. }
  170. Init(fk, adcData);
  172. if(fk==FE_VUS || fk==FE_FORMANT || fk==FE_PITCH || fk==FE_VUS || FE_ENDPOINT){
  173. /* First reduce noise by Wiener filtering */
  174. enhance_basic(&adcData.vec[beginX],(endX-beginX),m_sampleRate,1);
  175. }
  177. int i;
  178. int frameN;
  179. int sampleN=(endX-beginX);
  180. vector<float> pitchA;
  181. switch(fk){
  182. case FE_PITCH:
  183. frameN = vus_basic(&adcData.vec[beginX], sampleN, GetFrameSize(), m_vusA);
  184. frameN = pitch_basic(&adcData.vec[beginX], sampleN, m_sampleRate, GetShiftSize(), m_vusA, pitchA);
  185. feature.frameN = frameN; feature.dimN = 1; feature.byteN = 4;
  186. feature.mat.Resize(frameN,1);
  187. if(outBeginX<0 || outEndX<0){
  188. outBeginX=0;
  189. outEndX=frameN;
  190. }
  191. for(i=0; i<frameN;i++) feature.mat[outBeginX+i][0] = pitchA[i];
  192. break;
  193. case FE_ENDPOINT:
  194. epd_basic(&adcData.vec[beginX], sampleN, m_sampleRate, feature.label);
  195. break;
  196. default:
  197. frameN = FeatureExtract(fk, adcData, beginX, endX, feature, outBeginX, outEndX);
  198. break;
  199. }
  200. return frameN;
  201. }
  204. int Fe::FeatureExtract(FeatKind fk, CFeature& adcData, int beginX, int endX, CFeature& feature, int outBeginX, int outEndX)
  205. {
  206. int n,k;
  207. vector<short> wave1d;
  208. FeMatrix<float> feature2d;
  209. short *sample = &adcData.vec[beginX];
  210. int sampleN = endX-beginX;
  211. int frameN = 0;
  212. int dimN = GetDim(fk);
  213. int frameSize = GetFrameSize();
  215. /* V/U/S classification works for utterance only */
  216. if(fk==FE_VUS){
  217. frameN = vus_basic(sample, sampleN, frameSize, m_vusA);
  218. if(outBeginX<0) outBeginX=0; if(outEndX<0) outEndX=frameN;
  219. feature.frameN = frameN; feature.dimN = dimN; feature.byteN = 4; feature.mat.Resize(outEndX,1);
  220. for(n=0; n<frameN && n+outBeginX<outEndX; n++) feature.mat[outBeginX+n][0] = m_vusA[n];
  221. return frameN;
  222. }
  224. /* formant tracking requires pitch information to remove non-voice parts */
  225. if(fk==FE_FORMANT){
  226. frameN = vus_basic(sample, sampleN, frameSize, m_vusA);
  227. int shiftSize = GetShiftSize();
  228. int n_pitch_frames = pitch_basic(sample, sampleN, m_sampleRate, shiftSize, m_vusA, m_pitchA);
  229. }
  231. vector<float> preprocessedA;
  232. preprocessedA.resize(sampleN);
  234. /* Preprocessing */
  235. if(fk==FE_ZCR || fk==FE_ENERGY || fk==FE_EPOCH || fk==FE_GLOFLOW || fk==FE_GLOPULSE || fk==FE_VUS){
  236. /* just convert to float */
  237. for(int i=0;i<sampleN;i++) preprocessedA[i] = (float)sample[i];
  238. } else {
  239. preprocessing(sample, sampleN, &preprocessedA[0]);
  240. }
  242. /* Feature extraction */
  243. if(fk==FE_LPCRES || fk==FE_EPOCH || fk==FE_GLOFLOW){
  244. /* result is a 1-dim short vector */
  245. frameN = compute_feature_1d(fk,&preprocessedA[0],sampleN,wave1d);
  246. }
  247. else{
  248. /* result is a 2-dim float matrix */
  249. frameN = compute_feature_2d(fk,&preprocessedA[0],sampleN,feature2d);
  250. }
  252. /* Reorder cepstrum coefficients to follow the convention [c1, c2, c3, ..., c12, c0] */
  253. FeatKind bk=GetBaseFeatKind(fk);
  254. if(bk==FE_LPCC || bk==FE_PLCC || bk==FE_MFCC || bk==FE_FTCC){
  255. for(n=0;n<frameN;n++){
  256. float atmp=feature2d[n][0];
  257. for(k=0;k<m_cepOrder;k++) feature2d[n][k]=feature2d[n][k+1];
  258. feature2d[n][m_cepOrder]=atmp;
  259. }
  260. }
  262. /* Compute delta coefficients */
  263. if(HasDeltaFeat(fk)){
  264. FeMatrix<float> tmp2d=feature2d;
  265. delta_compute(tmp2d, m_deltaSize, feature2d);
  266. }
  268. /* Copy the resulting features */
  269. if(outBeginX<0) outBeginX=0; if(outEndX<0 || outEndX>frameN) outEndX=frameN;
  270. if(fk==FE_LPCRES || fk==FE_EPOCH || fk==FE_GLOFLOW){
  271. assert(sampleN==frameN);
  272. feature.frameN = sampleN; feature.dimN = 1; feature.byteN = 2; feature.vec.resize(sampleN);
  273. for(n=0; n<sampleN; n++) feature.vec[n] = wave1d[n];
  274. }
  275. else{
  276. feature.frameN = frameN; feature.dimN = dimN; feature.byteN = 4; feature.mat.Resize(outEndX,dimN);
  277. for(n=0; n<frameN && n+outBeginX<outEndX; n++){
  278. for(k=0; k<dimN; k++) feature.mat[outBeginX+n][k] = feature2d[n][k];
  279. }
  280. }
  282. return frameN;
  283. }
  286. int Fe::compute_feature_1d(FeatKind fk, float *sample, int sampleN, vector<short>& featA)
  287. {
  288. int n;
  289. int shiftSize, frameSize;
  290. if(fk==FE_GLOFLOW){
  291. shiftSize = (int)(m_covShiftSizeMs*m_sampleRate/1000.0+0.5); if(shiftSize%2) shiftSize += 1;
  292. frameSize = (int)(m_covWinSizeMs*m_sampleRate/1000.0+0.5); if(frameSize%2) frameSize += 1;
  293. if(frameSize < 2*m_lpcOrder) frameSize = 2*m_lpcOrder;
  294. }
  295. else{
  296. shiftSize = GetShiftSize();
  297. frameSize = GetFrameSize();
  298. }
  300. int frameN = (int)((float)(sampleN-(frameSize-shiftSize))/shiftSize);
  301. int dimN = 1;
  302. vector<float> frameA(frameSize);
  303. vector<float> acf(m_lpcOrder+1);
  304. vector<float> kcf(m_lpcOrder+1);
  305. featA.resize(sampleN);
  306. if(fk==FE_EPOCH) return calc_epoch(sample, sampleN, featA, NULL);
  308. vector<float> residual_data(frameSize);
  309. FeMatrix<float> cov(m_lpcOrder+1, m_lpcOrder+1);
  310. int remainN;
  311. for (n=0; ; n++){
  312. int i;
  313. int begX=n*shiftSize;
  314. if(!CheckWinMessage()) break;
  315. ShowProgress((int)((n*100)/frameN));
  316. remainN=my_min(sampleN-begX,frameSize);
  317. if(remainN<=0) break;
  318. for(i=0;i<remainN;i++) frameA[i]=sample[begX+i];
  319. for(i=remainN;i<frameSize;i++) frameA[i]=0;
  320. m_window.Windowing(&frameA[0], remainN, WIN_HAMMING);
  322. switch(fk){
  323. case FE_LPCRES:
  324. {
  325. int k;
  326. float G;
  327. if(remainN == frameSize)
  328. _lpc_basic(&frameA[0], frameSize, &acf[0], m_lpcOrder, &G);
  329. _lpc_error_basic(&frameA[0], remainN, &acf[0], m_lpcOrder, &residual_data[0]);
  330. for(k=0; k<shiftSize && begX+k<sampleN;k++) featA[begX+k] = (short)(residual_data[k]);
  331. }
  332. break;
  333. case FE_GLOFLOW:
  334. {
  335. float G;
  336. if(remainN == frameSize)
  337. lpc_cov(&frameA[0], frameSize, cov, &acf[0], m_lpcOrder, &G);
  338. lpc_cov_error(&frameA[0], remainN, &acf[0], m_lpcOrder, &residual_data[0]);
  339. // differentiated glottal flow
  340. Integrate(&residual_data[0], remainN, &featA[begX]);
  341. // glottal flow
  342. //Integrate(&((*featA)[i]), remainN, featA+i);
  343. }
  344. break;
  345. default:
  346. assert(0);
  347. return 0;
  348. break;
  349. }
  350. }
  351. return sampleN;
  352. }
  355. int Fe::compute_feature_2d(FeatKind fk, float *sample, int sampleN, FeMatrix<float>& featA)
  356. {
  357. int n;
  358. int shiftSize = GetShiftSize();
  359. int frameSize = GetFrameSize();
  360. int frameN = (int)((float)(sampleN-(frameSize-shiftSize))/shiftSize);
  361. int dimN = GetDim(fk);
  362. int fft_size; for (fft_size=1; fft_size<frameSize; fft_size*=2) ;
  363. vector<float> frameA(frameSize);
  364. vector<float> acf(m_lpcOrder+1);
  365. vector<float> kcf(m_lpcOrder+1);
  366. featA.Resize(frameN,dimN);
  367. FeMatrix<float> featTmpA;
  368. if(fk==FE_FORMANT) featTmpA.Resize(frameN, m_lpcOrder/2+1);
  370. fk=GetBaseFeatKind(fk);
  371. int dc_bias=0, level=0;
  372. float mean=0;
  373. if(fk==FE_ENERGY || fk==FE_ZCR){
  374. int i;
  375. for(i=0;i<sampleN;i++) mean += sample[i]; mean = mean/sampleN;
  376. dc_bias = (int)((mean >= 0) ? mean+0.5 : mean-0.5);
  377. if(frameN>10){
  378. /* Assume that there are at least 3 frames of silence at the beginning */
  379. float v=0; int m=3*shiftSize;
  380. for (i=0; i<m;i++) v+=(sample[i]-dc_bias)*(sample[i]-dc_bias);
  381. v=(float)sqrt(v/m);
  382. level=(int)(2*v); /* Set ZCR threshold to 2*noiseLevel */
  383. }
  384. }
  386. for (n=0; n<frameN; n++){
  387. float G=0;
  388. int begX=n*shiftSize;
  389. int i, k;
  390. float energy;
  391. if(!CheckWinMessage()) break;
  392. ShowProgress((int)((n*100)/frameN));
  394. if(!(fk==FE_ENERGY || fk==FE_ZCR)){
  395. for(i=0;i<frameSize;i++) frameA[i]=sample[begX+i];
  396. m_window.Windowing(&frameA[0], frameSize, WIN_HAMMING);
  397. }
  399. switch(fk){
  400. case FE_ENERGY:
  401. energy=compute_energy(sample+begX, frameSize, mean);
  402. featA[n][0] = 10*LOG10((energy>FE_MIN_ENERGY ? energy : FE_MIN_ENERGY));
  403. break;
  404. case FE_ZCR:
  405. featA[n][0] = (float)compute_zero_cross_rate(sample+begX, frameSize, level, dc_bias);
  406. break;
  407. case FE_LAR:
  408. _lpc_parcor_basic(&frameA[0], frameSize, &acf[0], &kcf[0], m_lpcOrder, &G);
  409. featA[n][0] = 0;
  410. for(k=1; k<=m_lpcOrder; k++) featA[n][k] = (float)log((1-kcf[k])/(1+kcf[k]));
  411. break;
  412. case FE_LSF:
  413. {
  414. vector<CComplex> oldRootsP;
  415. vector<CComplex> oldRootsQ;
  416. _lpc_basic(&frameA[0], frameSize, &acf[0], m_lpcOrder, &G);
  417. lpc_to_lsf(&acf[0],m_lpcOrder,&featA[n][0], oldRootsP, oldRootsQ);
  418. }
  419. break;
  420. case FE_PARCOR:
  421. _lpc_parcor_basic(&frameA[0], frameSize, &acf[0], &featA[n][0], m_lpcOrder, &G);
  422. featA[n][0] = 0;
  423. break;
  424. case FE_FORMANT:
  425. {
  426. vector<CComplex> rootsA(m_lpcOrder+1);
  427. for(i=0;i<=m_lpcOrder;i++) rootsA[i] = 0;
  428. _lpc_basic(&frameA[0], frameSize, &acf[0], m_lpcOrder, &G);
  429. /* Note that we compute all formant frequencies for post-processing */
  430. int ntmp=lpc_to_formant(&acf[0],m_lpcOrder,&featTmpA[n][0],m_lpcOrder/2,rootsA);
  431. for(k=0;k<=m_lpcOrder/2;k++) featTmpA[n][k] *= (m_sampleRate/(float)(2*M_PI));
  432. }
  433. break;
  434. case FE_LPC:
  435. _lpc_basic(&frameA[0], frameSize, &featA[n][0], m_lpcOrder, &G);
  436. break;
  437. case FE_FBANK:
  438. _filterbank_basic(&frameA[0], frameSize, &featA[n][0], m_fbOrder, fft_size, m_cepSmooth, (int)(m_sampleRate/MAX_PITCH_FREQ));
  439. break;
  440. case FE_MFCC:
  441. _mel_cepstrum_basic(&frameA[0], frameSize, &featA[n][0], m_fbOrder, m_cepOrder, m_fftSize);
  442. cepstral_window(&featA[n][0],m_cepOrder,m_lifter);
  443. break;
  444. case FE_PLCC:
  445. _plp_basic(&frameA[0], frameSize, &featA[n][0], m_plccOrder, m_plpOrder);
  446. cepstral_window(&featA[n][0],m_plccOrder,m_lifter);
  447. break;
  448. case FE_LPCC:
  449. _lpc_basic(&frameA[0], frameSize, &acf[0], m_lpcOrder, &G);
  450. lpc_to_cepstrum(&acf[0], m_lpcOrder, &featA[n][0], m_cepOrder, G);
  451. cepstral_window(&featA[n][0],m_cepOrder,m_lifter);
  452. break;
  453. case FE_FTCC:
  454. _fft_cepstrum_basic(&frameA[0], frameSize, &featA[n][0], m_cepOrder, fft_size);
  455. cepstral_window(&featA[n][0],m_cepOrder,m_lifter);
  456. break;
  457. default:
  458. assert(0);
  459. return 0;
  460. break;
  461. }
  462. }
  464. if(fk==FE_FORMANT){
  465. /* check formant range, noting that F0 is always zero */
  466. formant_check_range(featTmpA, m_lpcOrder/2, frameN);
  468. /* smooth formant trajectory */
  469. formant_median_filter(featTmpA, m_lpcOrder/2, frameN);
  470. formant_linear_filter(featTmpA, m_lpcOrder/2, frameN);
  472. /* Make formant consistent with pitch information */
  473. assert(m_pitchA.size()>0);
  474. frameN = formant_remove_nonvoice(featTmpA, m_lpcOrder/2, frameN, m_pitchA);
  476. /* Copy to the result variable, skipping F0  */
  477. for(n=0;n<frameN;n++){
  478. for(int k=0;k<dimN && k<m_lpcOrder/2+1;k++){
  479. featA[n][k]=featTmpA[n][k+1];
  480. }
  481. }
  483. }
  484. return frameN;
  485. }
  488. int Fe::ReadParaFile(const char *parafile)
  489. {
  490. FILE *fi = fopen(parafile,"r");
  491. if(!fi) return 0;
  492. char line[1024], arg1[256], arg2[256];
  493. string name;
  494. while(fgets(line,sizeof(line)-1,fi)){
  495. if(line[0]==0) break; // end of file
  496. if(line[0]=='#') continue; // skip comment line
  497. sscanf(line,"%s%s", arg1, arg2);
  498. name=arg1;
  499. if(name=="SAMPLING_RATE"){ m_sampleRate = atoi(arg2); } 
  500. else if(name=="WINDOW_SIZE"){ m_winSizeMs = atoi(arg2); } 
  501. else if(name=="SHIFT_SIZE"){ m_shiftSizeMs = atoi(arg2); } 
  502. else if(name=="PREEMPHASIS_FACTOR"){ m_emphFac = (float)atof(arg2); } 
  503. else if(name=="FFT_SIZE"){ m_fftSize = atoi(arg2); } 
  504. else if(name=="LPC_ORDER"){ m_lpcOrder = atoi(arg2); } 
  505. else if(name=="CEPSTRUM_ORDER"){ m_cepOrder = atoi(arg2); } 
  506. else if(name=="PLP_ORDER"){ m_plpOrder = atoi(arg2); } 
  507. else if(name=="PLP_CEPSTRUM_ORDER"){ m_plccOrder = atoi(arg2); } 
  508. else if(name=="FILTER_BANK_ORDER"){ m_fbOrder = atoi(arg2); } 
  509. else if(name=="CEPSTRAL_SMOOTHING"){ m_cepSmooth = (strcmp(arg2,"ON")==0); } 
  510. else if(name=="DITHERING"){ m_dither = (strcmp(arg2,"ON")==0); } 
  511. else if(name=="TEMPORAL_FILTER_SIZE"){ m_deltaSize = atoi(arg2); }
  512. }
  513. fclose(fi);
  514. return 1;
  515. }
  518. int Fe::ReadTag(const char *tag, int* pTag, int ndim)
  519. {
  520. int i;
  521. for(i=0;i<ndim;i++) pTag[i] = 0;
  522. if(!tag){
  523. for(i=0;i<ndim;i++) pTag[i] = 1;
  524. return 1;
  525. }
  527. vector<char> tmp(strlen(tag)+1);
  528. strcpy(&tmp[0],tag);
  529. char* tmp_save = NULL;
  530. char* p = strtok_r(&tmp[0], " ,", &tmp_save);
  531. if(!p){
  532. for(i=0;i<ndim;i++) pTag[i] = 1;
  533. }
  535. while(p){
  536. int begin = 0, end = 0;
  537. int len = strlen(p);
  538. char* p_save = NULL;
  539. if(*p == '-'){
  540. begin = 0;
  541. if(*(p+1) != '')
  542. end = atoi(p+1);
  543. else
  544. end = -1;
  545. }
  546. else if(*(p+len-1) == '-'){
  547. end = ndim-1;
  548. *(p+len-1) = '';
  549. begin = atoi(p);
  550. }
  551. else{
  552. char* q = strtok_r(p, "-", &p_save);
  553. if(q) begin = end = atoi(q);
  554. q = strtok_r(NULL, "-", &p_save);
  555. if(q) end = atoi(q);
  556. }
  557. for(i=begin; i<=end; i++) pTag[i] = 1;
  558. p = strtok_r(NULL, " ,", &tmp_save);
  559. }
  560. return 1;
  561. }
  564. int Fe::GetShiftSize()
  565. {
  566. int nshift = (int)((m_shiftSizeMs*m_sampleRate)/1000.0+0.5);
  567. if(nshift%2) nshift += 1;
  568. return nshift;
  569. }
  572. int Fe::GetFrameSize()
  573. {
  574. int frameSize = (int)((m_winSizeMs*m_sampleRate)/1000.0+0.5);
  575. if(frameSize%2) frameSize += 1;
  576. return frameSize;
  577. }
  580. const char *GetFeatName(FeatKind fk)
  581. {
  582. assert((int)fk>=0 && (int)fk<(int)FE_NUM_FEAT);
  583. return FE_featNameA[(int)fk];
  584. }
  587. string GetFeatExtension(FeatKind fk)
  588. {
  589. FeatKind bk=GetBaseFeatKind(fk);
  590. string name=GetFeatName(bk);
  591. for(int i=0;i<name.size();i++) name[i]=tolower(name[i]);
  592. if(HasDeltaFeat(fk)) name=name+"_d";
  593. if(HasStftFeat(fk)) {
  594. int k=name.find("_stft");
  595. name=name.substr(0,k);
  596. name=name+"_s";
  597. }
  598. return name;
  599. }
  602. FeatKind GetBaseFeatKind(FeatKind fk)
  603. {
  604. string name=GetFeatName(fk);
  605. int k=name.find("_D");
  606. if(k==string::npos) return fk;
  607. if(name[k+2]==0 || name[k+2]=='_'){
  608. name=name.substr(0,k);
  609. for(int i=0;i<FE_NUM_FEAT-1;i++){
  610. if(strcmp(FE_featNameA[i],name.c_str())==0) return (FeatKind)i;
  611. }
  612. }
  613. return fk;
  614. }
  617. FeatKind FeatName2Kind(const char* name)
  618. {
  619. int i;
  620. for(i=0;i<FE_NUM_FEAT-1;i++){
  621. if(strcmp(FE_featNameA[i],name)==0) return (FeatKind)i;
  622. }
  623. return (FeatKind)i;
  624. }
  627. int HasDeltaFeat(FeatKind fk)
  628. {
  629. const char *name=GetFeatName(fk);
  630. char *i=strstr(name,"_D");
  631. if(i) return 1;
  632. else return 0;
  633. }
  636. int HasStftFeat(FeatKind fk)
  637. {
  638. const char *name=GetFeatName(fk);
  639. char *i=strstr(name,"_SPEC");
  640. if(i) return 1;
  641. else return 0;
  642. }
  645. int Fe::GetDim(FeatKind fk)
  646. {
  647. int ndim = 0;
  648. fk=GetBaseFeatKind(fk);
  649. switch(fk){
  650. case FE_LPC: case FE_LPCCOV:
  651. ndim = m_lpcOrder + 1; break;
  652. case FE_LPCC: case FE_MFCC: case FE_FTCC:
  653. ndim = m_cepOrder + 1; break;
  654. case FE_PLCC:
  655. ndim = m_plccOrder + 1; break;
  656. case FE_FBANK:
  657. ndim = m_fbOrder; break;
  658. case FE_LAR: case FE_LSF: case FE_PARCOR:
  659. ndim = m_lpcOrder + 1; break;
  660. case FE_FORMANT:
  661. /* F1, F2, F3, F4 */
  662. ndim = 4; break;
  663. case FE_FFT_SPEC: case FE_LPC_SPEC: case FE_LPCC_SPEC:
  664. case FE_MFCC_SPEC: case FE_FTCC_SPEC:
  665. ndim = m_fftSize; break;
  666. case FE_FFTCEP:
  667. ndim = m_fftSize; break;
  668. case FE_ZCR: case FE_ENERGY: case FE_PITCH: case FE_VUS: case FE_ENDPOINT:
  669. case FE_EPOCH: case FE_GLOFLOW: case FE_GLOPULSE: case FE_LPCRES:
  670. ndim = 1; break;
  671. default:
  672. ndim = 1; break;
  673. }
  674. return ndim;
  675. }
  678. int GetDefaultDim(enum FeatKind fk)
  679. {
  680. int dim=0;
  681. fk=GetBaseFeatKind(fk);
  682. switch(fk){
  683. case FE_FFT_SPEC: case FE_LPC_SPEC: case FE_LPCC_SPEC: case FE_MFCC_SPEC: case FE_FTCC_SPEC:
  684. dim = DEFAULT_FFT_SIZE/2+1; break;
  685. case FE_FFTCEP:
  686. dim = DEFAULT_FFT_SIZE/2+1; break;
  687. case FE_LPC: case FE_LPCCOV: case FE_LAR: case FE_LSF: case FE_PARCOR:
  688. dim = FE_LPC_ORDER+1; break;
  689. case FE_FBANK:
  690. dim = FE_NUM_CHANNELS+1; break;
  691. case FE_LPCC: case FE_FTCC: case FE_MFCC:
  692. dim = FE_CEP_ORDER+1; break;
  693. case FE_PLCC:
  694. dim = PLP_CEP_ORDER+1; break;
  695. case FE_FORMANT:
  696. dim = 4; break;
  697. default:
  698. dim = 1; break;
  699. }
  700. return dim;
  701. }
  704. int GetDefaultOrder(enum FeatKind fk)
  705. {
  706. int order=1;
  707. fk=GetBaseFeatKind(fk);
  708. switch(fk){
  709. case FE_FFT_SPEC:
  710. order = DEFAULT_FFT_SIZE/2+1; break;
  711. case FE_FFTCEP:
  712. order = DEFAULT_FFT_SIZE/2+1; break;
  713. case FE_LPC_SPEC:
  714. order = FE_LPC_ORDER; break;
  715. case FE_LPCC_SPEC: case FE_MFCC_SPEC: case FE_FTCC_SPEC:
  716. order = FE_CEP_ORDER; break;
  717. case FE_LPC: case FE_LPCCOV: case FE_LAR: case FE_LSF: case FE_PARCOR:
  718. order = FE_LPC_ORDER; break;
  719. case FE_FBANK:
  720. order = FE_NUM_CHANNELS; break;
  721. case FE_LPCC: case FE_FTCC: case FE_MFCC: case FE_PLCC:
  722. order = PLP_CEP_ORDER; break;
  723. case FE_FORMANT:
  724. order = 4; break;
  725. default:
  726. order = 1; break;
  727. }
  728. return order;
  729. }
  732. float Fe::LogE(float x)
  733. {
  734. if(x>m_energyFloor) return log(x);
  735. else return m_logEnergyFloor;
  736. }
  739. int Fe::Integrate(float *a, int n, short *b)
  740. {
  741. float alpha = (float)0.98;
  742. static float prev = 0;
  743. for(int i=0;i<n;i++){
  744. prev = a[i] + alpha*prev;
  745. b[i] = (short)(prev);
  746. }
  747. return 1;
  748. }
  751. int Fe::Integrate(short *a, int n, short *b)
  752. {
  753. float alpha = (float)0.98;
  754. static float prev = 0;
  755. for(int i=0;i<n;i++){
  756. prev = a[i] + alpha*prev;
  757. b[i] = (short)(prev);
  758. }
  759. return 1;
  760. }
  763. float Fe::GetMedian(float* a, int n)
  764. {
  765. int i;
  766. float median = 0;
  767. vector<float> tmp(n);;
  768. for(i=0;i<n;i++)
  769. tmp[i] = a[i];
  771. qsort(&tmp[0],n,sizeof(float),FE_CompareFloat);
  772. median = tmp[(n-1)/2];
  773. return median;
  774. }
  777. int Fe::InitProgress(int* pProgress, int* pCancel)
  778. {
  779. m_pProgress = pProgress;
  780. m_pCancel = pCancel;
  781. return 1;
  782. }
  785. int Fe::CheckWinMessage()
  786. {
  787. #if defined(_WIN32) && defined(ANALYSIS_LIB)
  788. MSG message;
  789. if(PeekMessage(&message, NULL, 0, 0, PM_REMOVE)) {
  790. TranslateMessage(&message);
  791. DispatchMessage(&message);
  792. }
  793. #endif
  794. if(m_pCancel && (*m_pCancel)) return 0;
  795. else return 1;
  796. }
  799. int Fe::ShowProgress(int progress)
  800. {
  801. #if defined(_WIN32) && defined(ANALYSIS_LIB)
  802. if(m_pProgress) *m_pProgress = progress;
  803. #endif
  804. return 1;
  805. }
  808. int FE_CompareFloat(const void *a, const void *b)
  809. {
  810. float *aa = (float*)a;
  811. float *bb = (float*)b;
  812. if(*aa > *bb) return 1;
  813. else if(*aa < *bb) return -1;
  814. else return 0;
  815. }
  818. #ifdef WIN32
  819. char* strtok_r(char *s1, const char *s2, char **savept)
  820. {
  821. char *p = NULL;
  822. char *z = NULL;
  824. if(s1) *savept = s1;
  825. if((*savept) == NULL) return NULL;
  826. z = *savept + strlen(*savept);
  827. p = strtok(*savept,s2);
  828. if(p != NULL && (p + strlen(p) + 1) < z)
  829. *savept = p + strlen(p) + 1;
  830. else
  831. *savept = NULL;
  832. return p;
  833. }
  834. #endif