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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
WaveProcess.cpp
资源名称：AudioWave.rar　[点击查看]
上传用户：huifengb
上传日期：2007-12-27
资源大小：334k
文件大小：11k
源码类别：

多媒体

开发平台：

Visual C++

WaveProcess.cpp：源码内容
  1. // WaveProcess.cpp: implementation of the CWaveProcess class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Audio.h"
  7. #include "WaveProcess.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  14. #include "DCT.h"
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////
  20. CWaveProcess::CWaveProcess()
  21. {
  23. }
  25. CWaveProcess::~CWaveProcess()
  26. {
  28. }
  30. void CWaveProcess::WaveSignalFFT(float *pfSignal, DWORD dwLenSignal, int nPower, double *pdReFFT, double *pdImFFT)
  31. {
  32. int nSamples = 1<<nPower;
  33. CFFT *pFFT = new CFFT;
  34. double *pdReSignal, *pdImSignal;
  35. int nBlock = (dwLenSignal+nSamples-1)/nSamples;
  36. int i,j;
  37. pdReSignal = new double[nSamples];
  38. pdImSignal = new double[nSamples];
  40. for(i=0; i<nBlock; i++)
  41. {
  42. for(j=0; j<nSamples; j++)
  43. {
  44. if((DWORD)(i*nSamples+j)<dwLenSignal)
  45. {
  46. pdReSignal[j] = pfSignal[i*nSamples+j];
  47. }else
  48. {
  49. pdReSignal[j] = 0.0;
  50. }
  52. pdImSignal[j] = 0.0;
  53. }
  54. pFFT->FFTSignal(nPower, pdReSignal, pdImSignal, pdReFFT+i*nSamples, pdImFFT+i*nSamples);
  55. }
  56. delete[] pdReSignal;
  57. delete[] pdImSignal;
  58. delete pFFT;
  59. }
  61. void CWaveProcess::WaveSignalFFT_I(float *pfSignal, DWORD dwLenSignal, int nPower, double *pdReFFT, double *pdImFFT)
  62. {
  63. int nSamples = 1<<nPower;
  64. CFFT *pFFT = new CFFT;
  65. double *pdReSignal, *pdImSignal;
  66. int nBlock = (dwLenSignal+nSamples-1)/nSamples;
  67. int i,j;
  68. pdReSignal = new double[nSamples];
  69. pdImSignal = new double[nSamples];
  71. for(i=0; i<nBlock; i++)
  72. {
  73. pFFT->IFFTSignal(nPower, pdReSignal, pdImSignal, pdReFFT+i*nSamples, pdImFFT+i*nSamples);
  74. for(j=0; j<nSamples; j++)
  75. {
  76. if((DWORD)(i*nSamples+j)<dwLenSignal)
  77. {
  78. pfSignal[i*nSamples+j] = (float)pdReSignal[j];
  79. }
  80. }
  81. }
  82. delete[] pdReSignal;
  83. delete[] pdImSignal;
  84. delete pFFT;
  85. }
  87. void CWaveProcess::WaveSignalDCTIV(float *pfSignal, float *pfDCT, DWORD dwLenSignal, int nPower)
  88. {
  89. int nSamples = 1<<nPower;
  90. CDCT *pDCT = new CDCT;
  91. int nBlock = (dwLenSignal+nSamples-1)/nSamples;
  92. int i,j;
  94. for(i=0; i<nBlock; i++)
  95. {
  96. for(j=0; j<nSamples; j++)
  97. {
  98. if((DWORD)(i*nSamples+j)<dwLenSignal)
  99. {
  100. pfDCT[i*nSamples+j] = pfSignal[i*nSamples+j];
  101. }
  102. }
  103. pDCT->DCTIV(pfDCT+i*nSamples,nPower);
  104. }
  105. delete pDCT;
  106. }
  108. void CWaveProcess::WaveSignalIDCTIV(float *pfSignal, float *pfDCT, DWORD dwLenSignal, int nPower)
  109. {
  110. int nSamples = 1<<nPower;
  111. CDCT *pDCT = new CDCT;
  112. int nBlock = (dwLenSignal+nSamples-1)/nSamples;
  113. int i,j;
  115. for(i=0; i<nBlock; i++)
  116. {
  117. pDCT->IDCTIV(pfDCT+i*nSamples,nPower);
  118. for(j=0; j<nSamples; j++)
  119. {
  120. if((DWORD)(i*nSamples+j)<dwLenSignal)
  121. {
  122. pfSignal[i*nSamples+j] = pfDCT[i*nSamples+j];
  123. }
  124. }
  125. }
  126. delete pDCT;
  127. }
  129. void CWaveProcess::LowPass(float *pfSignal, DWORD dwLenSignal, int nStep)
  130. {
  131. float *pfData = new float[dwLenSignal];
  132. memcpy(pfData, pfSignal, dwLenSignal*sizeof(float));
  133. float fMaxS, fMaxD;
  134. fMaxS = MaxData(pfSignal, dwLenSignal);
  135. DWORD i;
  136. int k;
  137. float fQ = (float)nStep*2+1;
  138. float fSum;
  139. for(i=nStep; i<dwLenSignal-nStep; i++)
  140. {
  141. fSum = 0;
  142. for(k=-nStep; k<=nStep; k++)
  143. {
  144. fSum = fSum +pfData[i+k];
  145. }
  146. pfSignal[i] = fSum/fQ;
  147. }
  148. fMaxD = MaxData(pfSignal, dwLenSignal);
  149. for(i=0; i<(int)dwLenSignal; i++)
  150. {
  151. pfSignal[i] = pfSignal[i]*(fMaxS/fMaxD+0.25f);
  152. // pfSignal[i] = pfSignal[i]*2;
  153. }
  155. delete[] pfData;
  156. }
  158. void CWaveProcess::HighPass(float *pfSignal, DWORD dwLenSignal, int nStep, int nTh, float fRate)
  159. {
  160. float *pfData = new float[dwLenSignal];
  161. memcpy(pfData, pfSignal, dwLenSignal*sizeof(float));
  162. float fMaxS, fMaxD;
  163. fMaxS = MaxData(pfSignal, dwLenSignal);
  164. DWORD i;
  165. int k;
  166. float fSum;
  168. for(i=nStep; i<dwLenSignal-nStep; i++)
  169. {
  170. fSum = 0;
  171. for(k=-nStep; k<=nStep; k++)
  172. {
  173. fSum = fSum +(float)fabs(pfData[i+k]-pfData[i]);
  174. }
  176. if(fSum>nTh)
  177. {
  178. pfSignal[i] = pfSignal[i]*fRate;
  179. }
  180. }
  181. fMaxD = MaxData(pfSignal, dwLenSignal);
  182. // for(i=0; i<(int)dwLenSignal; i++)
  183. // {
  184. // pfSignal[i] = pfSignal[i]*(fMaxS/fMaxD);
  185. // }
  187. delete[] pfData;
  188. }
  190. void CWaveProcess::FFTLowFrequencyShift(float *pfSoundData, DWORD dwLenSound, int nShift, int nPower)
  191. {
  192. int nSamples = 1<<nPower;
  193. CFFT *pFFT = new CFFT;
  194. int nBlock = (dwLenSound+nSamples-1)/nSamples;
  195. int i,j;
  197. double *pdReSignal = new double[nSamples];
  198. double *pdImSignal = new double[nSamples];
  199. double *pdReFFT    = new double[nSamples];
  200. double *pdImFFT    = new double[nSamples];
  202. float fMaxS, fMaxD;
  203. fMaxS = MaxData(pfSoundData, dwLenSound);
  205. for(i=0; i<nBlock; i++)
  206. {
  207. for(j=0; j<nSamples; j++)
  208. {
  209. if((DWORD)(i*nSamples+j)<dwLenSound)
  210. {
  211. pdReSignal[j] = pfSoundData[i*nSamples+j];
  212. }else
  213. {
  214. pdReSignal[j] = 0.0;
  215. }
  217. pdImSignal[j] = 0.0;
  218. }
  219. pFFT->FFTSignal(nPower, pdReSignal, pdImSignal, pdReFFT, pdImFFT);
  220. for(j=0; j<nSamples-nShift; j++)
  221. {
  222. pdReFFT[j] = pdReFFT[j+nShift];
  223. pdImFFT[j] = pdImFFT[j+nShift];
  224. }
  225. for(j=nSamples-nShift; j<nSamples; j++)
  226. {
  227. pdReFFT[j] = 0.0;
  228. pdImFFT[j] = 0.0;
  229. }
  230. pFFT->IFFTSignal(nPower, pdReSignal, pdImSignal, pdReFFT, pdImFFT);
  231. for(j=0; j<nSamples; j++)
  232. {
  233. if((DWORD)(i*nSamples+j)<dwLenSound)
  234. {
  235. pfSoundData[i*nSamples+j] = (float)pdReSignal[j];
  236. }
  237. }
  238. }
  239. fMaxD = MaxData(pfSoundData, dwLenSound);
  240. for(i=0; i<(int)dwLenSound; i++)
  241. {
  242. pfSoundData[i] = pfSoundData[i]*fMaxS/fMaxD;
  243. }
  244. delete[] pdReSignal;
  245. delete[] pdImSignal;
  246. delete[] pdReFFT;
  247. delete[] pdImFFT;
  248. delete pFFT;
  249. }
  251. void CWaveProcess::FFTHighFrequencyShift(float *pfSoundData, DWORD dwLenSound, int nShift, int nPower)
  252. {
  253. int nSamples = 1<<nPower;
  254. CFFT *pFFT = new CFFT;
  255. int nBlock = (dwLenSound+nSamples-1)/nSamples;
  256. int i,j;
  258. double *pdReSignal = new double[nSamples];
  259. double *pdImSignal = new double[nSamples];
  260. double *pdReFFT    = new double[nSamples];
  261. double *pdImFFT    = new double[nSamples];
  263. float fMaxS, fMaxD;
  264. fMaxS = MaxData(pfSoundData, dwLenSound);
  266. for(i=0; i<nBlock; i++)
  267. {
  268. for(j=0; j<nSamples; j++)
  269. {
  270. if((DWORD)(i*nSamples+j)<dwLenSound)
  271. {
  272. pdReSignal[j] = pfSoundData[i*nSamples+j];
  273. }else
  274. {
  275. pdReSignal[j] = 0.0;
  276. }
  278. pdImSignal[j] = 0.0;
  279. }
  280. pFFT->FFTSignal(nPower, pdReSignal, pdImSignal, pdReFFT, pdImFFT);
  281. for(j=0; j<nSamples-nShift; j++)
  282. {
  283. pdReFFT[nSamples-1-j] = pdReFFT[nSamples-1-j-nShift];
  284. pdImFFT[nSamples-1-j] = pdImFFT[nSamples-1-j-nShift];
  285. }
  286. for(j=0; j<nShift; j++)
  287. {
  288. pdReFFT[j] = 0.0;
  289. pdImFFT[j] = 0.0;
  290. }
  291. pFFT->IFFTSignal(nPower, pdReSignal, pdImSignal, pdReFFT, pdImFFT);
  292. for(j=0; j<nSamples; j++)
  293. {
  294. if((DWORD)(i*nSamples+j)<dwLenSound)
  295. {
  296. pfSoundData[i*nSamples+j] = (float)pdReSignal[j];
  297. }
  298. }
  299. }
  300. fMaxD = MaxData(pfSoundData, dwLenSound);
  301. for(i=0; i<(int)dwLenSound; i++)
  302. {
  303. pfSoundData[i] = pfSoundData[i]*fMaxS/fMaxD;
  304. }
  305. delete[] pdReSignal;
  306. delete[] pdImSignal;
  307. delete[] pdReFFT;
  308. delete[] pdImFFT;
  309. delete pFFT;
  310. }
  312. float CWaveProcess::MaxData(float *pfData, DWORD dwLenData)
  313. {
  314. DWORD i;
  315. float fMax = (float)fabs(pfData[0]);
  316. for(i=0; i<dwLenData; i++)
  317. {
  318. if(fabs(pfData[i])>fMax)
  319. {
  320. fMax = (float)fabs(pfData[i]);
  321. }
  322. }
  323. return fMax;
  324. }
  326. void CWaveProcess::DCTLowFrequencyShift(float *pfSoundData, DWORD dwLenSound, int nShift, int nPower)
  327. {
  328. int nSamples = 1<<nPower;
  329. CDCT *pDCT = new CDCT;
  330. int nBlock = (dwLenSound+nSamples-1)/nSamples;
  331. int i,j;
  333. float *pfDCT = new float[nSamples];
  335. float fMaxS, fMaxD;
  336. fMaxS = MaxData(pfSoundData, dwLenSound);
  338. for(i=0; i<nBlock; i++)
  339. {
  340. for(j=0; j<nSamples; j++)
  341. {
  342. if((DWORD)(i*nSamples+j)<dwLenSound)
  343. {
  344. pfDCT[j] = pfSoundData[i*nSamples+j];
  345. }
  346. }
  347. pDCT->DCTIV(pfDCT, nPower);
  348. for(j=0; j<nSamples-nShift; j++)
  349. {
  350. pfDCT[j] = pfDCT[j+nShift];
  351. }
  352. for(j=nSamples-nShift; j<nSamples; j++)
  353. {
  354. pfDCT[j] = 0.0;
  355. }
  356. pDCT->IDCTIV(pfDCT, nPower);
  357. for(j=0; j<nSamples; j++)
  358. {
  359. if((DWORD)(i*nSamples+j)<dwLenSound)
  360. {
  361. pfSoundData[i*nSamples+j] = (float)pfDCT[j];
  362. }
  363. }
  364. }
  365. fMaxD = MaxData(pfSoundData, dwLenSound);
  366. for(i=0; i<(int)dwLenSound; i++)
  367. {
  368. pfSoundData[i] = pfSoundData[i]*fMaxS/fMaxD;
  369. }
  370. delete[] pfDCT;
  371. delete pDCT;
  372. }
  374. void CWaveProcess::DCTHighFrequencyShift(float *pfSoundData, DWORD dwLenSound, int nShift, int nPower)
  375. {
  376. int nSamples = 1<<nPower;
  377. CDCT *pDCT = new CDCT;
  378. int nBlock = (dwLenSound+nSamples-1)/nSamples;
  379. int i,j;
  381. float *pfDCT = new float[nSamples];
  383. float fMaxS, fMaxD;
  384. fMaxS = MaxData(pfSoundData, dwLenSound);
  386. for(i=0; i<nBlock; i++)
  387. {
  388. for(j=0; j<nSamples; j++)
  389. {
  390. if((DWORD)(i*nSamples+j)<dwLenSound)
  391. {
  392. pfDCT[j] = pfSoundData[i*nSamples+j];
  393. }
  394. }
  395. pDCT->DCTIV(pfDCT, nPower);
  396. for(j=0; j<nSamples-nShift; j++)
  397. {
  398. pfDCT[nSamples-1-j] = pfDCT[nSamples-1-j-nShift];
  399. }
  400. for(j=nSamples-nShift; j<nSamples; j++)
  401. {
  402. pfDCT[j] = 0.0;
  403. }
  404. pDCT->IDCTIV(pfDCT, nPower);
  405. for(j=0; j<nSamples; j++)
  406. {
  407. if((DWORD)(i*nSamples+j)<dwLenSound)
  408. {
  409. pfSoundData[i*nSamples+j] = (float)pfDCT[j];
  410. }
  411. }
  412. }
  413. fMaxD = MaxData(pfSoundData, dwLenSound);
  414. for(i=0; i<(int)dwLenSound; i++)
  415. {
  416. pfSoundData[i] = pfSoundData[i]*fMaxS/fMaxD;
  417. }
  418. delete[] pfDCT;
  419. delete pDCT;
  420. }
  422. void CWaveProcess::DCTMidFrequencyShift(float *pfSoundData, DWORD dwLenSound, int nShift, int nPower, float fRate)
  423. {
  424. int nSamples = 1<<nPower;
  425. CDCT *pDCT = new CDCT;
  426. int nBlock = (dwLenSound+nSamples-1)/nSamples;
  427. int i,j;
  429. int nStart = int(nSamples*fRate);
  431. float *pfDCT = new float[nSamples];
  433. float fMaxS, fMaxD;
  434. fMaxS = MaxData(pfSoundData, dwLenSound);
  436. for(i=0; i<nBlock; i++)
  437. {
  438. for(j=0; j<nSamples; j++)
  439. {
  440. if((DWORD)(i*nSamples+j)<dwLenSound)
  441. {
  442. pfDCT[j] = pfSoundData[i*nSamples+j];
  443. }
  444. }
  445. pDCT->DCTIV(pfDCT, nPower);
  446. for(j=0; j<nStart-nShift; j++)
  447. {
  448. pfDCT[nStart-j-1] = pfDCT[nStart-j-1-nShift];
  449. }
  450. for(j=0; j<nShift; j++)
  451. {
  452. pfDCT[j] = 0.0;
  453. }
  454. pDCT->IDCTIV(pfDCT, nPower);
  455. for(j=0; j<nSamples; j++)
  456. {
  457. if((DWORD)(i*nSamples+j)<dwLenSound)
  458. {
  459. pfSoundData[i*nSamples+j] = (float)pfDCT[j];
  460. }
  461. }
  462. }
  463. fMaxD = MaxData(pfSoundData, dwLenSound);
  464. for(i=0; i<(int)dwLenSound; i++)
  465. {
  466. pfSoundData[i] = pfSoundData[i]*fMaxS/fMaxD;
  467. }
  468. delete[] pfDCT;
  469. delete pDCT;
  470. }
  472. void CWaveProcess::Contraction(float *pfSoundData, DWORD dwLenSound, float fRate)
  473. {
  474. float *pfData = new float[dwLenSound];
  475. memcpy(pfData, pfSoundData, dwLenSound*sizeof(float));
  476. int nNum = int(1/fRate);
  477. int nSum = int(dwLenSound*fRate);
  478. float fSum;
  479. int i,k;
  481. memset(pfSoundData, 0, dwLenSound*sizeof(float));
  482. for(i=0; i<nSum; i++)
  483. {
  484. fSum = 0.0;
  485. for(k=0; k<nNum; k++)
  486. {
  487. fSum = fSum+pfData[i*nNum+k];
  488. }
  489. pfSoundData[i] = fSum/(float)nNum;
  490. }
  492. }