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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 控制台编程 > 查看源码
WaveConvertor.cpp
资源名称：hmmPlatform.rar　[点击查看]
上传用户：goak128
上传日期：2013-07-17
资源大小：155k
文件大小：15k
源码类别：

控制台编程

开发平台：

C/C++

WaveConvertor.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include ".waveconvertor.h"
  4. //////////////////////////////////////////////////////////////////////////
  5. // class CWaveConvertor
  6. //
  7. // 功能： 实现裸音频数据的FFT变换
  8. // 创建人： 陈文凯 (chwkai@gmail.com)
  9. // 创建日期:2005年5月19日
  10. // 修改人：
  11. // 修改日期：
  12. // 版本
  14. /* Pjotr '87.  */
  15. // As best as I can determine this is in the public domain. No license was found
  16. // withit what so ever. The author is listed as:
  17. // Peter Valkenburg (valke@cs.vu.nl).
  18. //
  19. // If there is some disagreement then contact Bruce Forsberg (forsberg@tns.net)
  20. #include <math.h>
  22. #define pi   3.1415926535897932384626434
  24. #define c_re(c) ((c).re)
  25. #define c_im(c) ((c).im)
  27. /* C_add_mul adds product of c1 and c2 to c.  */
  28. #define c_add_mul(c, c1, c2) { COMPLEX C1, C2; C1 = (c1); C2 = (c2); 
  29. c_re (c) += C1.re * C2.re - C1.im * C2.im; 
  30. c_im (c) += C1.re * C2.im + C1.im * C2.re; }
  32. /* C_conj substitutes c by its complex conjugate. */
  33. #define c_conj(c) { c_im (c) = -c_im (c); }
  35. /* C_realdiv divides complex c by real.  */
  36. #define c_realdiv(c, real) { c_re (c) /= (real); c_im (c) /= (real); }
  38. /*
  39. * W gives the (already computed) Wn ^ k (= e ^ (2pi * i * k / n)).
  40. * Notice that the powerseries of Wn has period Nfactors.
  41. */
  42. #define W(n, k) (W_factors [((k) * (Nfactors / (n))) % Nfactors])
  46. /*! brief Constructor.
  47. */
  48. aflibFFT::aflibFFT()
  49. {
  50. Nfactors = 0;
  51. W_factors = NULL;
  52. }
  55. /*! brief Destructor.
  56. */
  57. aflibFFT::~aflibFFT()
  58. {
  59. if (W_factors != NULL)
  60. delete W_factors;
  61. }
  64. /*! brief Performs a forward or reverse FFT.
  66. This is the main API is this class. It will perform either a forward or
  67. inverse FFT depending how InverseTransform is set. If set to FALSE then
  68. forward FFT will be performed, TRUE and a inverse FFT will be performed.
  69. The number of samlpes (NumSamples) must be a power of 2. The ImagIn
  70. pointer can be NULL if there are no imaginary values. The user is
  71. responsable for passing in pointers for RealOut and ImagOut containing
  72. arrays of the proper size.
  73. */
  74. void
  75. aflibFFT::fft_double (
  76.   unsigned  NumSamples,
  77.   int       InverseTransform,
  78.   const double   *RealIn,
  79.   const double   *ImagIn,
  80.   double   *RealOut,
  81.   double   *ImagOut )
  82. {
  84. COMPLEX  in[1024];
  85. COMPLEX  out[1024];
  86. COMPLEX  * in_local = NULL;
  87. COMPLEX  * out_local = NULL;
  88. register COMPLEX  * in_ptr;
  89. register COMPLEX  * out_ptr;
  90. register unsigned int      i;
  93. // IF 1024 samples or less use local buffer else allocate memory
  94. if (NumSamples > 1024)
  95. {
  96. in_local = new COMPLEX[NumSamples];
  97. out_local = new COMPLEX[NumSamples];
  98. in_ptr = in_local;
  99. out_ptr = out_local;
  100. }
  101. else
  102. {
  103. in_ptr = in;
  104. out_ptr = out;
  105. }
  107. // Fill real and imaginary array
  108. for (i = 0; i < NumSamples; i++)
  109. {
  110. c_re(in_ptr[i]) = RealIn[i];
  111. if (ImagIn == NULL)
  112. c_im(in_ptr[i]) = 0.0;
  113. else
  114. c_im(in_ptr[i]) = ImagIn[i];
  115. }
  117. // Perform transform
  118. if (InverseTransform == TRUE)
  119. {
  120. rft(in_ptr, NumSamples, out_ptr);
  121. }
  122. else
  123. {
  124. fft(in_ptr, NumSamples, out_ptr);
  125. }
  127. // Fill real and imaginary array
  128. for (i = 0; i < NumSamples; i++)
  129. {
  130. RealOut[i] = c_re(out_ptr[i]);
  131. ImagOut[i] = c_im(out_ptr[i]);
  132. }
  134. // Free memory if local arrays were not used
  135. if (in_local != NULL)
  136. delete [] in_local;
  137. if (out_local != NULL)
  138. delete [] out_local;
  139. }
  142. /*
  143. * Forward Fast Fourier Transform on the n samples of complex array in.
  144. * The result is placed in out.  The number of samples, n, is arbitrary.
  145. * The W-factors are calculated in advance.
  146. */
  147. int
  148. aflibFFT::fft (
  149.    COMPLEX *in,
  150.    unsigned  n,
  151.    COMPLEX *out)
  152. {
  153. unsigned i;
  155. for (i = 0; i < n; i++)
  156. c_conj (in [i]);
  158. if (W_init (n) == -1)
  159. return -1;
  161. Fourier (in, n, out);
  163. for (i = 0; i < n; i++) {
  164. c_conj (out [i]);
  165. c_realdiv (out [i], n);
  166. }
  168. return 0;
  169. }
  172. /*
  173. * Reverse Fast Fourier Transform on the n complex samples of array in.
  174. * The result is placed in out.  The number of samples, n, is arbitrary.
  175. * The W-factors are calculated in advance.
  176. */
  177. int
  178. aflibFFT::rft (
  179.    COMPLEX *in,
  180.    unsigned  n,
  181.    COMPLEX *out)
  182. {
  183. if (W_init (n) == -1)
  184. return -1;
  186. Fourier (in, n, out);
  188. return 0;
  189. }
  192. /*
  193. * Recursive (reverse) complex fast Fourier transform on the n
  194. * complex samples of array in, with the Cooley-Tukey method.
  195. * The result is placed in out.  The number of samples, n, is arbitrary.
  196. * The algorithm costs O (n * (r1 + .. + rk)), where k is the number
  197. * of factors in the prime-decomposition of n (also the maximum
  198. * depth of the recursion), and ri is the i-th primefactor.
  199. */
  200. void
  201. aflibFFT::Fourier (
  202.    COMPLEX *in,
  203.    unsigned  n,
  204.    COMPLEX *out)
  205. {
  206. unsigned r;
  208. if ((r = radix (n)) < n)
  209. split (in, r, n / r, out);
  210. join (in, n / r, n, out);
  211. }
  214. /*
  215. * Give smallest possible radix for n samples.
  216. * Determines (in a rude way) the smallest primefactor of n.
  217. */
  218. unsigned
  219. aflibFFT::radix (unsigned n)
  220. {
  221. unsigned r;
  223. if (n < 2)
  224. return 1;
  226. for (r = 2; r < n; r++)
  227. if (n % r == 0)
  228. break;
  229. return r;
  230. }
  233. /*
  234. * Split array in of r * m samples in r parts of each m samples,
  235. * such that in [i] goes to out [(i % r) * m + (i / r)].
  236. * Then call for each part of out Fourier, so the r recursively
  237. * transformed parts will go back to in.
  238. */
  239. void
  240. aflibFFT::split (
  241.  register COMPLEX *in,
  242.  register unsigned r,
  243.  register unsigned m,
  244.  register COMPLEX *out)
  245. {
  246. register unsigned k, s, i, j;
  248. for (k = 0, j = 0; k < r; k++)
  249. for (s = 0, i = k; s < m; s++, i += r, j++)
  250. out [j] = in [i];
  252. for (k = 0; k < r; k++, out += m, in += m)
  253. Fourier (out, m, in);
  254. }
  257. /*
  258. * Sum the n / m parts of each m samples of in to n samples in out.
  259. *     r - 1
  260. * Out [j] becomes  sum  in [j % m] * W (j * k).  Here in is the k-th
  261. *     k = 0   k        n  k
  262. * part of in (indices k * m ... (k + 1) * m - 1), and r is the radix.
  263. * For k = 0, a complex multiplication with W (0) is avoided.
  264. */
  265. void
  266. aflibFFT::join (
  267. register COMPLEX *in,
  268. register unsigned m,
  269. register unsigned n,
  270. register COMPLEX *out)
  271. {
  272. register unsigned i, j, jk, s;
  274. for (s = 0; s < m; s++)
  275. for (j = s; j < n; j += m) {
  276. out [j] = in [s];
  277. for (i = s + m, jk = j; i < n; i += m, jk += j)
  278. c_add_mul (out [j], in [i], W (n, jk));
  279. }
  280. }
  283. int
  284. aflibFFT::W_init(unsigned n)
  285. {
  286. unsigned k;
  288. if (n == Nfactors)
  289. return 0;
  290. if (Nfactors != 0 && W_factors != 0)
  291. delete [] W_factors;
  292. if ((Nfactors = n) == 0)
  293. return 0;
  294. if ((W_factors = new COMPLEX[n]) == NULL)
  295. return -1;
  297. for (k = 0; k < n; k++) {
  298. c_re (W_factors [k]) = cos (2 * pi * k / n);
  299. c_im (W_factors [k]) = sin (2 * pi * k / n);
  300. }
  302. return 0;
  303. }
  305. //////////////////////////////////////////////////////////////////////////
  306. // 构造函数
  307. CWaveConvertor::CWaveConvertor(void)
  308. {
  309. }
  311. //////////////////////////////////////////////////////////////////////////
  312. // 析构函数
  313. CWaveConvertor::~CWaveConvertor(void)
  314. {
  315. }
  317. //////////////////////////////////////////////////////////////////////////
  318. // 对输入数据进行短时快速FFT变换，输入数据为已经加窗的数据
  319. void CWaveConvertor::ConverToFFT( 
  320.  unsigned int nSamples, // 样本数量
  321.  unsigned int nShorts, // 短时点数
  322.  const double* pRealIn, // 输入的实部，不可为空
  323.  double* pRealOut, // 输出的实部
  324.  double* pImageOut // 输出的虚部
  325.  )
  326. {
  327. aflibFFT libFFT;
  328. // 计算所需变换次数
  329. unsigned int nCount = nSamples / nShorts;
  330. // 数组偏移
  331. unsigned int nOffSet = 0;
  333. // 初始化输出数据
  334. memset(pRealOut, 0, sizeof(double) * nSamples);
  335. memset(pImageOut, 0, sizeof(double) * nSamples);
  337. for (unsigned int i = 0; i < nCount; i++)
  338. {
  339. nOffSet = i * nShorts;
  341. // 进行快速FFT
  342. libFFT.fft_double(
  343. nShorts, 
  344. FALSE, 
  345. &pRealIn[nOffSet], 
  346. NULL, 
  347. &pRealOut[nOffSet], 
  348. &pImageOut[nOffSet]
  349. );
  350. }
  351. }
  353. //////////////////////////////////////////////////////////////////////////
  354. // 对输入数据进行Reverse Fourier转化，输入数据为已经加窗的数据
  355. void CWaveConvertor::ConvertToRFT( 
  356.   unsigned int nSamples, // 样本数量
  357.   unsigned int nShorts, // 短时点数
  358.   const double* pRealIn, // 输入的实部，不可为空
  359.   double* pRealOut, // 输出的实部
  360.   double* pImageOut // 输出的虚部
  361.   )
  362. {
  363. aflibFFT libFFT;
  364. // 计算所需变换次数
  365. unsigned int nCount = nSamples / nShorts;
  366. // 数组偏移
  367. unsigned int nOffSet = 0;
  369. // 初始化输出数据
  370. memset(pRealOut, 0, sizeof(double) * nSamples);
  371. memset(pImageOut, 0, sizeof(double) * nSamples);
  373. for (unsigned int i = 0; i < nCount; i++)
  374. {
  375. nOffSet = i * nShorts;
  377. // 进行快速FFT
  378. libFFT.fft_double(
  379. nShorts, 
  380. TRUE, 
  381. &pRealIn[nOffSet], 
  382. NULL, 
  383. &pRealOut[nOffSet], 
  384. &pImageOut[nOffSet]
  385. );
  386. }
  387. }
  389. //////////////////////////////////////////////////////////////////////////
  390. // 获取输入信号的功率谱
  391. void CWaveConvertor::ConvertToPowerSpectral( 
  392. unsigned int nSamples, // 样本数量
  393. unsigned int nShorts, // 短时点数
  394. const double* pRealIn, // 输入信号
  395. double* pDataOut // 输出的功率谱
  396. )
  397. {
  398. double* pRealOut = NULL;
  399. double* pImageOut = NULL;
  401. // 输入数据是否有效
  402. if (nSamples > 0 && pRealIn != NULL)
  403. {
  404. // 为FFT输出数据分配空间
  405. pRealOut = new double[nSamples];
  406. pImageOut = new double[nSamples];
  408. // 进行FFT变换
  409. CWaveConvertor::ConverToFFT(nSamples, nShorts, pRealIn, pRealOut, pImageOut);
  411. // 对获得的FFT变换结果进行自乘，计算功率谱
  412. for (unsigned int i = 0; i < nSamples; i++)
  413. {
  414. pDataOut[i] = sqrt(pRealOut[i] * pRealOut[i] + pImageOut[i] * pImageOut[i]);
  415. }
  417. delete[] pRealOut;
  418. delete[] pImageOut;
  419. }
  420. }
  422. //////////////////////////////////////////////////////////////////////////
  423. // 获取输入信号的对数功率谱
  424. void CWaveConvertor::ConvertToLogPowerSpectral( 
  425. unsigned int nSamples, // 样本数量
  426. unsigned int nShorts, // 短时点数
  427. const double* pRealIn, // 输入信号
  428. double* pDataOut // 输出的对数功率谱
  429. )
  430. {
  431. // 先转换为功率谱
  432. CWaveConvertor::ConvertToPowerSpectral(nSamples, nShorts, pRealIn, pDataOut);
  434. // 转化为对数功率谱
  435. for (unsigned int i = 0; i < nSamples; i++)
  436. {
  437. pDataOut[i] = log(pDataOut[i]);
  438. }
  439. }
  441. //////////////////////////////////////////////////////////////////////////
  442. // 获取输入信号的倒谱
  443. void CWaveConvertor::ConvertToCepStrum( 
  444.    unsigned int nSamples, // 样本数量
  445.    unsigned int nShorts, // 短时点数
  446.    const double* pRealIn, // 输入信号
  447.    double* pDataOut // 输出的倒谱
  448.    )
  449. {
  450. // 保存对数功率谱
  451. double* pTemp = new double[nSamples];
  452. // 保存虚部数据
  453. double* pImageOut = new double[nSamples];
  455. // 获取对数功率谱
  456. CWaveConvertor::ConvertToLogPowerSpectral(nSamples, nShorts, pRealIn, pTemp);
  458. // 再次进行傅立叶逆变换，得到倒谱
  459. CWaveConvertor::ConvertToRFT(nSamples, nShorts, pTemp, pDataOut, pImageOut);
  461. delete[] pTemp;
  462. delete[] pImageOut;
  463. }
  465. //////////////////////////////////////////////////////////////////////////
  466. // 对输入的8位信号，转化为double类型序列
  467. void CWaveConvertor::ConvertToDoubleMono( 
  468. const byte* pDataIn, // 输入样本序列
  469. unsigned int nCount, // 样本数量
  470. double* pDataOut // 输出double类型序列
  471. )
  472. {
  473. int nAdjust = 127;
  475. if (pDataIn != NULL)
  476. {
  477. // 填零
  478. memset(pDataOut, 0, sizeof(double) * nCount);
  480. // 8位信号减127
  481. for (unsigned int i = 0; i < nCount; i++)
  482. {
  483. pDataOut[i] = pDataIn[i] - nAdjust;
  484. }
  485. }
  486. }
  488. //////////////////////////////////////////////////////////////////////////
  489. // 对输入的16位信号，转化为double类型序列
  490. void CWaveConvertor::ConvertToDoubleMono( 
  491. const int* pDataIn, // 输入样本序列
  492. unsigned int nCount, // 样本数量
  493. double* pDataOut // 输出double类型序列
  494. )
  495. {
  496. char* pDataTemp = NULL;
  497. unsigned int nOffset = 0;
  499. if (pDataIn != NULL)
  500. {
  501. pDataTemp = (char*) pDataIn;
  502. // 填零
  503. nCount /= 2;
  504. memset(pDataOut, 0, sizeof(double) * nCount);
  506. for (unsigned int i = 0; i < nCount; i++)
  507. {
  508. nOffset = i * 2;
  510. // 对高低位倒置的16位信号进行计算
  511. pDataOut[i] = pDataTemp[nOffset] + pDataTemp[nOffset + 1] * 0x100;
  512. }
  513. }
  514. }
  516. //////////////////////////////////////////////////////////////////////////
  517. // 对输入的8位信号，转化为双声道double序列
  518. void CWaveConvertor::ConvertToDoubleStereo(
  519. const byte* pDataIn, // 输入样本序列
  520. unsigned int nCount, // 样本数量
  521. double* pDataOutLeft, // 输出左声道double类型序列
  522. double* pDataOutRight // 输出右声道double类型序列
  523. )
  524. {
  525. double* pDataTemp = NULL;
  527. if (pDataIn != NULL)
  528. {
  529. pDataTemp = new double[nCount];
  531. // 信号类型先转化为double类型
  532. CWaveConvertor::ConvertToDoubleMono(pDataIn, nCount, pDataTemp);
  534. //提取左右声道
  535. for (unsigned int i = 0; i < nCount; i += 2)
  536. {
  537. pDataOutLeft[i / 2] = pDataTemp[i];
  538. pDataOutRight[i / 2] = pDataTemp[i + 1];
  539. }
  541. delete[] pDataTemp;
  542. }
  543. }
  545. // 对输入的16位信号，转化为双声道double序列
  546. void CWaveConvertor::ConvertToDoubleStereo(
  547. const int* pDataIn, // 输入样本序列
  548. unsigned int nCount, // 样本数量
  549. double* pDataOutLeft, // 输出左声道double类型序列
  550. double* pDataOutRight // 输出右声道double类型序列
  551. )
  552. {
  553. double* pDataTemp = NULL;
  555. if (pDataIn != NULL)
  556. {
  557. pDataTemp = new double[nCount];
  559. // 信号类型先转化为double类型
  560. CWaveConvertor::ConvertToDoubleMono(pDataIn, nCount, pDataTemp);
  562. //提取左右声道
  563. for (unsigned int i = 0; i < nCount; i += 2)
  564. {
  565. pDataOutLeft[i / 2] = pDataTemp[i];
  566. pDataOutRight[i / 2] = pDataTemp[i + 1];
  567. }
  569. delete[] pDataTemp;
  570. }
  571. }
  573. //////////////////////////////////////////////////////////////////////////
  574. // 对输入信号进行抽样
  575. void CWaveConvertor::ConvertToSample(
  576. const double* pDataIn, // 输入样本序列
  577. unsigned int nCount, // 样本数量
  578. double* pDataOut, // 输出右声道double类型序列
  579. unsigned int nWinSize // 抽样窗口宽度
  580. )
  581. {
  582. double* pDataTemp = NULL;
  583. unsigned int nOffSet = 0;
  585. if (pDataIn != NULL)
  586. {
  587. pDataTemp = new double[nCount / nWinSize];
  589. // 进行抽样
  590. for (unsigned int i = 0; i < nCount; i += nWinSize)
  591. {
  592. pDataOut[nOffSet] = pDataIn[i];
  594. nOffSet ++;
  595. }
  597. delete[] pDataTemp;
  598. }
  599. }
  601. //////////////////////////////////////////////////////////////////////////
  602. // 对输入信号进行截取
  603. void CWaveConvertor::GetData(
  604.  const double* pDataIn, // 输入样本序列
  605.  unsigned int nCount, // 输入样本数量
  606.  unsigned int nStart, // 起始下标
  607.  unsigned int nLen, // 截取长度
  608.  double* pDataOut // 截取后的序列
  609.  )
  610. {
  611. if (pDataIn != NULL && nCount >= (nStart + nLen))
  612. {
  613. memcpy(pDataOut, pDataIn + nStart, sizeof(double) * nLen);
  614. }
  615. }