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

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

控制台编程

开发平台：

C/C++

Speech.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include ".speech.h"
  4. CSpeech::CSpeech(void)
  5. {
  6. }
  8. CSpeech::~CSpeech(void)
  9. {
  10. }
  12. //////////////////////////////////////////////////////////////////////////
  13. // 对输入数据加窗
  14. void CSpeech::AddWindow( 
  15. unsigned int nWinSize, // 处理窗宽度
  16. double* pData, // 输入数据
  17. unsigned int nInLen // 输入数据长度
  18. )
  19. {
  20. // 计算处理次数
  21. unsigned int nCount = nInLen / nWinSize;
  22. unsigned int nOffSet = 0;
  24. for (unsigned int i = 0; i < nCount; i++)
  25. {
  26. nOffSet = i * nWinSize;
  28. for (unsigned int j = 0; j < nWinSize; j++)
  29. {
  30. pData[nOffSet + j] = 
  31. pData[nOffSet + j] * CSpeech::HammingWinFunc(j, nWinSize);
  32. }
  33. }
  34. }
  36. //////////////////////////////////////////////////////////////////////////
  37. // 对输入数据加窗
  38. void CSpeech::AddWindow(
  39. unsigned int nWinSize, // 处理窗宽度
  40. const double* pDataIn, // 输入数据
  41. unsigned int nInLen, // 输入数据长度
  42. double* pDataOut // 输出数据
  43. )
  44. {
  45. // 拷贝输入数据到输出数据
  46. memcpy(pDataOut, pDataIn, sizeof(double) * nInLen);
  48. // 对输入数据加窗
  49. CSpeech::AddWindow(nWinSize, pDataOut, nInLen);
  50. }
  52. //////////////////////////////////////////////////////////////////////////
  53. // 输入信号序列的短时平均过零率，输入数据为加窗后的数据
  54. void CSpeech::GetZero( 
  55.   unsigned int nWinSize, /*处理窗口大小*/
  56.   const double* pDataIn, /*输入信号序列*/
  57.   unsigned int nInLen, /*输入信号序列长度*/
  58.   double* pDataOut /*输出过零率序列*/
  59.   )
  60. {
  61. // 保存窗口函数值
  62. // double nWinValue = 0;
  63. unsigned int nOutLen = nInLen / nWinSize;
  64. unsigned int nOffSet = 0;
  66. // 清空输出序列
  67. memset(pDataOut, 0, sizeof(double)* nOutLen);
  69. // 利用海明窗作为窗口函数计算短时平均过零率
  70. for (unsigned int i = 0; i < nOutLen; i ++)
  71. {
  72. nOffSet = i * nWinSize;
  74. // 计算当前窗口的过零率
  75. for (unsigned int j = 0; j < (nWinSize - 1); j ++)
  76. {
  77. // 计算窗口函数值
  78. //nWinValue = HammingWinFunc(j, nWinSize);
  80. pDataOut[i] += 
  81. abs(Sgn(pDataIn[nOffSet + j]) - Sgn(pDataIn[nOffSet + j + 1]));
  82. // abs(Sgn(pDataIn[nOffSet + j]) - Sgn(pDataIn[nOffSet + j + 1])) * nWinValue;
  83. }
  84. }
  85. }
  87. //////////////////////////////////////////////////////////////////////////
  88. // 计算输入信号序列的短时能量，输入数据为加窗后的数据
  89. void CSpeech::GetEnergy( 
  90. unsigned int nWinSize, /*处理窗口大小*/
  91. const double* pDataIn, /*输入信号序列*/
  92. unsigned int nInLen, /*输入信号序列长度*/
  93. double* pDataOut /*输出短时能量序列*/
  94. )
  95. {
  96. // 保存窗口函数值
  97. // double nWinValue = 0;
  98. unsigned int nOutLen = nInLen / nWinSize;
  99. unsigned int nOffSet = 0;
  101. // 清空输出序列
  102. memset(pDataOut, 0, sizeof(double)* nOutLen);
  104. // 若输出序列和输出序列可用
  105. if (pDataIn != NULL && pDataOut != NULL)
  106. {
  107. // 利用海明窗作为窗口函数计算短时能量
  108. for (unsigned int i = 0; i < nOutLen; i ++)
  109. {
  110. nOffSet = i * nWinSize;
  112. // 计算当前窗口的过零率
  113. for (unsigned int j = 0; j < nWinSize; j ++)
  114. {
  115. // 计算窗口函数值
  116. // nWinValue = HammingWinFunc(j, nWinSize);
  118. // pDataOut[i] += pow(pDataIn[nOffSet + j], 2) * nWinValue;
  119. pDataOut[i] += pow(pDataIn[nOffSet + j], 2);
  120. }
  121. }
  122. }
  123. }
  125. //////////////////////////////////////////////////////////////////////////
  126. // 计算输入信号序列的平均振幅，输入数据为加窗后的数据
  127. void CSpeech::GetAvgVibration(
  128.   unsigned int nWinSize, /*处理窗口大小*/
  129.   const double* pDataIn, /*输入信号序列*/
  130.   unsigned int nInLen, /*输入信号序列长度*/
  131.   double* pDataOut /*输出平均振幅序列*/
  132.   )
  133. {
  134. // 保存窗口函数值
  135. // double nWinValue = 0;
  136. unsigned int nOutLen = nInLen / nWinSize;
  137. unsigned int nOffSet = 0;
  139. // 清空输出序列
  140. memset(pDataOut, 0, sizeof(double)* nOutLen);
  142. // 若输出序列和输出序列可用
  143. if (pDataIn != NULL && pDataOut != NULL)
  144. {
  145. // 利用海明窗作为窗口函数计算平均振幅
  146. for (unsigned int i = 0; i < nOutLen; i ++)
  147. {
  148. nOffSet = i * nWinSize;
  150. // 计算当前窗口的过零率
  151. for (unsigned int j = 0; j < nWinSize; j ++)
  152. {
  153. // 计算窗口函数值
  154. // nWinValue = HammingWinFunc(j, nWinSize);
  156. // pDataOut[i] += abs(pDataIn[nOffSet + j]) * nWinValue;
  157. pDataOut[i] += abs(pDataIn[nOffSet + j]);
  158. }
  159. }
  160. }
  161. }
  163. //////////////////////////////////////////////////////////////////////////
  164. // 对输入采样序列进行端点检测，端点检测时的K1,k2和具体环境有关
  165. // 不具备普遍意义。PEnergy指的是平均振幅
  166. unsigned int CSpeech::SubSection(
  167. const double* pDataIn, // 输入采样序列
  168. unsigned int nInLen, // 输入采样数
  169. const double* pEnergy, // 输入样本序列分帧的短时能量
  170. const double* pZero, // 输入样本序列分帧的短时过零率
  171. unsigned int nFrameSize,// 每帧包含采样数
  172. double* pDataOut, // 去掉寂静帧后的采样序列
  173. unsigned int nWinSize // 滑动窗包含帧数（统计窗长度）
  174. )
  175. {
  176. // 起始能量门限值
  177. double fBeginEnergyDoor = 0;
  178. // 结束能量门限值
  179. double fEndEnergyDoor = 0;
  180. // 过零率门限值
  181. double fZeroDoor = 0;
  182. // 滑动窗内符合能量门限值的帧数
  183. unsigned int nEnergyCount = 0;
  184. // 滑动窗内符合过零率门限值的帧数
  185. unsigned int nZeroCount = 0;
  186. // 连续滑动帧法中的IF
  187. double fIF = 20;
  188. // 计算前10帧过零率均值
  189. double fAvgZero = 0;
  190. // 计算前10帧的样本方差
  191. double fVar = 0;
  192. // 最小能量
  193. double fMinEnergy = 0;
  194. // 最大能量
  195. double fMaxEnergy = 0;
  196. // 连续滑动帧算法中的I1
  197. double fEnergyI1 = 0;
  198. // 连续滑动帧算法中的I2
  199. double fEnergyI2 = 0;
  200. // 循环变量
  201. unsigned int i = 0; 
  202. unsigned int j = 0;
  203. // 输入样本序列分帧数
  204. unsigned int nFrameNums = nInLen / nFrameSize;
  205. // 进行帧统计时的，若条件判断失败，进行偏移时的偏移窗大小(窗间叠接)
  206. unsigned int nStep = 10;
  207. // 语音起始点，按帧
  208. unsigned int nBegin = 0;
  209. unsigned int nEnd = nFrameNums - 1;
  210. // 端点前测后的字节数
  211. unsigned int nRetLen = 0;
  213. if (pDataIn != NULL)
  214. {
  215. // 计算前10帧的过零率均值
  216. for (i = 0; i < 10; i++)
  217. {
  218. fAvgZero += pZero[i];
  219. }
  221. fAvgZero /= 10;
  223. // 计算前10帧的样本方差
  224. for (i = 0; i < 10; i++)
  225. {
  226. fVar += pow((pZero[i] - fAvgZero), 2);
  227. }
  229. fVar = sqrt(fVar / 10);
  231. // 计算过零率门限值
  232. fZeroDoor = fAvgZero + 2 * fVar;
  233. fZeroDoor = (fIF < fZeroDoor ? fIF : fZeroDoor);
  235. // 求最小能量和最大能量
  236. fMinEnergy = pEnergy[i];
  237. fMaxEnergy = pEnergy[i];
  238. for (i = 0; i < nFrameNums; i++)
  239. {
  240. fMinEnergy = (pEnergy[i] < fMinEnergy ? pEnergy[i] : fMinEnergy);
  241. fMaxEnergy = (fMaxEnergy < pEnergy[i] ? pEnergy[i] : fMaxEnergy);
  242. }
  244. // 计算能量门限值
  245. fEnergyI1 = 0.03 * (fMaxEnergy - fMinEnergy) + fMinEnergy;
  246. fEnergyI2 = 4 * fMinEnergy;
  247. fBeginEnergyDoor = 5 * (fEnergyI1 < fEnergyI2 ? fEnergyI1 : fEnergyI2);
  249. // 计算结束能量门限值，一般来说结束能量门限都比起始能量小，
  250. // 这里的处理方法是令 结束能量门限 ＝ K * 开始能量门限，k按环境取值，不具有普遍意义
  251. fEndEnergyDoor = 0.7 * fBeginEnergyDoor;
  253. // 进行端点检测
  254. // 判断语音起点
  255. // 判断条件为nEnergyCount<20 and nZeroCount>10
  256. // 或nEnergyCount<15
  257. for (i = 0; i < nFrameNums; i+= nStep)
  258. {
  259. // 统计符合能量和过零率条件的帧数
  260. nZeroCount = 0; 
  261. nEnergyCount = 0;
  263. for (j = 0; j < nWinSize; j++)
  264. {
  265. nZeroCount = 
  266. (fZeroDoor < pZero[i + j] ? nZeroCount + 1 : nZeroCount);
  267. nEnergyCount = 
  268. (pEnergy[i + j] < fBeginEnergyDoor ? nEnergyCount + 1 : nEnergyCount);
  269. }
  271. // 判断是否找到起点
  272. if ((nEnergyCount < 20 && nZeroCount > 10) || 
  273. nEnergyCount < 15)
  274. {
  275. nBegin = i;
  277. break;
  278. }
  279. }
  281. // 判断语音终点
  282. // 统计窗向前推移3000点
  283. for (i = (nBegin + 3000 / nFrameSize); i < nFrameNums; i+= nStep)
  284. {
  285. // 统计符合能量和过零率条件的帧数
  286. nZeroCount = 0; 
  287. nEnergyCount = 0;
  289. for (j = 0; j < nWinSize; j++)
  290. {
  291. nZeroCount = 
  292. (pZero[i + j] < fZeroDoor ? nZeroCount + 1 : nZeroCount);
  293. nEnergyCount = 
  294. (pEnergy[i + j] < fEndEnergyDoor ? nEnergyCount + 1 : nEnergyCount);
  295. }
  297. // 判断是否找到起点
  298. if ((nEnergyCount > 20 && nZeroCount < 10) || 
  299. nEnergyCount > 40)
  300. {
  301. nEnd = i;
  303. break;
  304. }
  305. }
  307. // 拷贝端点检测后数据
  308. nRetLen = (nEnd - nBegin) * nFrameSize;
  309. memcpy(pDataOut, &pDataIn[nBegin * nFrameSize], sizeof(double) * nRetLen);
  310. }
  312. return nRetLen;
  313. }
  315. //////////////////////////////////////////////////////////////////////////
  316. // 对输入采样序列进行端点检测
  317. unsigned int CSpeech::SubSection(
  318.  const double* pDataIn, // 输入采样序列，已加窗
  319.  unsigned int nInLen, // 输入采样数
  320.  unsigned int nFrameSize, // 每帧包含采样数
  321.  double* pDataOut, // 去掉寂静帧后的采样序列
  322.  unsigned int nWinSize // 统计窗窗包含帧数
  323.  )
  324. {
  325. // 平均振幅
  326. double* pVibration = NULL;
  327. // 短时平均过零率
  328. double* pZero = NULL;
  329. // 计算输入数据包含帧数
  330. unsigned int nFrameNums = nInLen / nFrameSize;
  331. // 端点检测后剩下的采样点数
  332. unsigned int nRetLen = 0;
  334. if (pDataIn != NULL)
  335. {
  336. // 计算平均振幅
  337. pVibration = new double[nFrameNums];
  338. CSpeech::GetAvgVibration(nFrameSize, pDataIn, nInLen, pVibration);
  339. // 计算短时平均过零率
  340. pZero = new double[nFrameNums];
  341. CSpeech::GetZero(nFrameSize, pDataIn, nInLen, pZero);
  343. // 进行端点检测 
  344. nRetLen = CSpeech::SubSection(
  345. pDataIn, nInLen, pVibration, pZero, nFrameSize, pDataOut, nWinSize);
  347. // 释放所占用资源
  348. delete[] pZero;
  349. delete[] pVibration;
  350. }
  352. return nRetLen;
  353. }