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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
Compression.cpp
资源名称：多功能聊天程序.rar　[点击查看]
上传用户：onsales
上传日期：2010-01-31
资源大小：224k
文件大小：15k
源码类别：

网络编程

开发平台：

Visual C++

Compression.cpp：源码内容
  1. // Compression.cpp: implementation of the CCompression class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Speak.h"
  7. #include "Compression.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  15. #pragma comment(lib,"msacm32")
  17. BOOL CALLBACK FindDriverEnum(HACMDRIVERID hadid, DWORD dwInstance,
  18.  DWORD fdwSupport);
  19. BOOL CALLBACK FindFormatEnum(HACMDRIVERID hadid, LPACMFORMATDETAILS pafd, 
  20.  DWORD dwInstance, DWORD fdwSupport);
  21. BOOL CALLBACK FindFormatEnumOld(HACMDRIVERID hadid, LPACMFORMATDETAILS pafd, 
  22.  DWORD dwInstance, DWORD fdwSupport);
  24. //////////////////////////////////////////////////////////////////////
  25. // Construction/Destruction
  26. //////////////////////////////////////////////////////////////////////
  28. CCompression::CCompression()
  29. {
  30. pDst1Data=NULL;
  31. pDst2Data=NULL;
  32. m_pSrcData=NULL;
  33. }
  35. CCompression::~CCompression()
  36. {
  37. if(pDst1Data!=NULL)
  38. free(pDst1Data);
  39. if(pDst2Data!=NULL)
  40. free(pDst2Data);
  41. if(m_pSrcData!=NULL)
  42. free(m_pSrcData);
  43. if(pwfDrv!=NULL)
  44. free(pwfDrv);
  45. if(pwfPCM!=NULL)
  46. free(pwfPCM);
  47. }
  49. void CCompression::SetWaveFormat(int channels, long samplerate, int bitspersample)
  50. {
  51. memset(&m_wfSrc, 0, sizeof(m_wfSrc));
  52. m_wfSrc.cbSize = 0;
  53. m_wfSrc.wFormatTag = WAVE_FORMAT_PCM; // pcm
  54. m_wfSrc.nChannels = channels; // mono
  55. m_wfSrc.nSamplesPerSec = samplerate; // 11.025 kHz
  56. m_wfSrc.wBitsPerSample = bitspersample; // 8 bit
  57. m_wfSrc.nBlockAlign = m_wfSrc.nChannels *m_wfSrc.wBitsPerSample / 8;
  58. m_wfSrc.nAvgBytesPerSec = m_wfSrc.nSamplesPerSec * m_wfSrc.nBlockAlign;
  59. }
  61. void CCompression::SetSrcSamples(long samples,unsigned char* pSrcData)
  62. {
  63. int n=(int)(m_wfSrc.wBitsPerSample/8);
  65. m_dwSrcSamples=samples;
  66. m_dwSrcBytes=(DWORD)(samples*n);
  67. m_pSrcData=(BYTE*)malloc(m_dwSrcBytes);
  68. memcpy(m_pSrcData,pSrcData,m_dwSrcBytes);
  69. }
  71. void CCompression::SelectMethod(int i)
  72. {
  73. if((i<0) || (i>5)){
  74. AfxMessageBox("No support for such compression method!");
  75. return;
  76. }
  77. switch(i){
  78. case 0:{
  79. wFormatTag = 0x32; // MSN
  80. break;
  81.    }
  82. case 1:{
  83. wFormatTag = WAVE_FORMAT_DSPGROUP_TRUESPEECH;
  84. break;}
  85. case 2:{
  86. wFormatTag = WAVE_FORMAT_ADPCM;
  87. break;}
  88. case 3:{
  89. wFormatTag = WAVE_FORMAT_GSM610;
  90. break;}
  91. case 4:{
  92. wFormatTag = WAVE_FORMAT_ALAW;
  93. break;}
  94. case 5:{
  95. wFormatTag = WAVE_FORMAT_MULAW;
  96. break;}
  97. }
  98. }
  100. HACMDRIVERID CCompression::FindDriver(WORD wFormatTag)
  101. {
  102. FIND_DRIVER_INFO fdi;
  103. fdi.hadid = NULL;
  104. fdi.wFormatTag = wFormatTag;
  105. MMRESULT mmr = acmDriverEnum(FindDriverEnum, (DWORD)(VOID*)&fdi,0); 
  106. if (mmr) 
  107. return NULL;
  108. return fdi.hadid;
  109. }
  111. BOOL CALLBACK FindDriverEnum(HACMDRIVERID hadid, DWORD dwInstance,
  112.  DWORD fdwSupport)
  113. {
  114. FIND_DRIVER_INFO* pdi = (FIND_DRIVER_INFO*) dwInstance;
  116. // open the driver
  117. HACMDRIVER had = NULL;
  118. MMRESULT mmr = acmDriverOpen(&had, hadid, 0);
  119. if (mmr) {
  120. // some error
  121. return FALSE; // stop enumerating
  122. }
  123. // enumerate the formats it supports
  124. DWORD dwSize = 0;
  125. mmr = acmMetrics((HACMOBJ)had, ACM_METRIC_MAX_SIZE_FORMAT, &dwSize);
  126. if (dwSize < sizeof(WAVEFORMATEX)) dwSize = sizeof(WAVEFORMATEX); // for MS-PCM
  127. WAVEFORMATEX* pwf = (WAVEFORMATEX*) malloc(dwSize);
  128. memset(pwf, 0, dwSize);
  129. pwf->cbSize = LOWORD(dwSize) - sizeof(WAVEFORMATEX);
  130. pwf->wFormatTag = pdi->wFormatTag;
  131. ACMFORMATDETAILS fd;
  132. memset(&fd, 0, sizeof(fd));
  133. fd.cbStruct = sizeof(fd);
  134. fd.pwfx = pwf;
  135. fd.cbwfx = dwSize;
  136. fd.dwFormatTag = pdi->wFormatTag;
  137. mmr = acmFormatEnum(had, &fd, FindFormatEnumOld, (DWORD)(VOID*)pdi, 0);  
  138. free(pwf);
  139. acmDriverClose(had, 0);
  140. if (pdi->hadid || mmr) {
  141. // found it or some error
  142. return FALSE; // stop enumerating
  143. }
  144. return TRUE; // continue enumeration
  145. }
  147. BOOL CALLBACK FindFormatEnum(HACMDRIVERID hadid, LPACMFORMATDETAILS pafd, DWORD dwInstance, DWORD fdwSupport)
  148. {
  149. FIND_DRIVER_INFO* pdi = (FIND_DRIVER_INFO*) dwInstance;
  150. if (pafd->dwFormatTag == (DWORD)pdi->wFormatTag) {
  151. // found it
  152. WAVEFORMATEX pwfPCM;
  153. pwfPCM=*(pafd->pwfx);
  154. pdi->hadid = hadid;
  155. TRACE("PCM format: %u bits, %lu samples per secondn", pwfPCM.wBitsPerSample, pwfPCM.nSamplesPerSec);
  156. if((pwfPCM.nSamplesPerSec==(unsigned long)pdi->lSampleRate) && (pwfPCM.wBitsPerSample==(unsigned short)pdi->nBits)){
  157. pdi->hadid = hadid;
  158. return FALSE; // stop enumerating
  159. }
  160. }
  162. return TRUE; // continue enumerating
  163. }
  165. BOOL CALLBACK FindFormatEnumOld(HACMDRIVERID hadid, LPACMFORMATDETAILS pafd, DWORD dwInstance, DWORD fdwSupport)
  166. {
  167. FIND_DRIVER_INFO* pdi = (FIND_DRIVER_INFO*) dwInstance;
  168. if (pafd->dwFormatTag == (DWORD)pdi->wFormatTag) {
  169. // found it
  170. pdi->hadid = hadid;
  171. return FALSE; // stop enumerating
  172. }
  174. return TRUE; // continue enumerating
  175. }
  177. WAVEFORMATEX* CCompression::GetDriverFormat(HACMDRIVERID hadid, WORD wFormatTag,BOOL bPCM)
  178. {
  179. // open the driver
  180. HACMDRIVER had = NULL;
  181. MMRESULT mmr = acmDriverOpen(&had, hadid, 0);
  182. if (mmr) {
  183. return NULL;
  184. }
  186. // allocate a structure for the info
  187. DWORD dwSize = 0;
  188. mmr =acmMetrics((HACMOBJ)had, ACM_METRIC_MAX_SIZE_FORMAT, &dwSize);
  189. if (dwSize < sizeof(WAVEFORMATEX)) dwSize = sizeof(WAVEFORMATEX); // for MS-PCM
  190. WAVEFORMATEX* pwf = (WAVEFORMATEX*) malloc(dwSize);
  191. memset(pwf, 0, dwSize);
  192. pwf->cbSize = LOWORD(dwSize) - sizeof(WAVEFORMATEX);
  193. pwf->wFormatTag = wFormatTag;
  195. ACMFORMATDETAILS fd;
  196. memset(&fd, 0, sizeof(fd));
  197. fd.cbStruct = sizeof(fd);
  198. fd.pwfx = pwf;
  199. fd.cbwfx = dwSize;
  200. fd.dwFormatTag = wFormatTag;
  202. // set up a struct to control the enumeration
  203. FIND_DRIVER_INFO fdi;
  204. fdi.hadid = NULL;
  205. fdi.wFormatTag = wFormatTag;
  206. fdi.nBits=(unsigned short)m_wfSrc.wBitsPerSample;
  207. fdi.lSampleRate=8000;//(unsigned long)m_wfSrc.nSamplesPerSec;
  209. if(!bPCM)
  210. mmr=acmFormatEnum(had, &fd, FindFormatEnumOld, (DWORD)(VOID*)&fdi,0);
  211. else
  212. mmr = acmFormatEnum(had, &fd, FindFormatEnum, (DWORD)(VOID*)&fdi,0);  
  214. acmDriverClose(had, 0);
  215. if ((fdi.hadid == NULL) || mmr) {
  216. free(pwf);
  217. return NULL;
  218. }
  220. return pwf;
  221. }
  223. BOOL CCompression::Initialize()
  224. {
  225. hadid = FindDriver(wFormatTag);
  226. if (hadid == NULL) {
  227. AfxMessageBox("No driver foundn");
  228. return FALSE;
  229. }
  230. TRACE("Driver found (hadid: %4.4lXH)n", hadid);
  231. // show some information about the driver
  232. ACMDRIVERDETAILS dd;
  233. dd.cbStruct = sizeof(dd);
  234. MMRESULT mmr = acmDriverDetails(hadid, &dd, 0);
  235. TRACE("   Short name: %sn", dd.szShortName);
  236. TRACE("   Long name:  %sn", dd.szLongName);
  237. TRACE("   Copyright:  %sn", dd.szCopyright);
  238. TRACE("   Licensing:  %sn", dd.szLicensing);
  239. TRACE("   Features:   %sn", dd.szFeatures);
  241. // get the details of the format
  242. // Note: this is just the first of one or more possible formats for the given tag
  243. pwfDrv = GetDriverFormat(hadid, wFormatTag,FALSE);
  244. if (pwfDrv == NULL) {
  245. AfxMessageBox("Error getting format infon");
  246. return FALSE;
  247. }
  248. TRACE("Driver format: %u bits, %lu samples per secondn", pwfDrv->wBitsPerSample, pwfDrv->nSamplesPerSec);
  250. // get a PCM format tag the driver supports
  251. // Note: we just pick the first supported PCM format which might not really
  252. // be the best choice.
  253. pwfPCM = GetDriverFormat(hadid, WAVE_FORMAT_PCM,TRUE);
  254. if (pwfPCM == NULL) {
  255. AfxMessageBox("Error getting PCM format infon");
  256. return FALSE;
  257. }
  258. TRACE("PCM format: %u bits, %lu samples per secondn", pwfPCM->wBitsPerSample, pwfPCM->nSamplesPerSec);
  259. return TRUE;
  260. }
  262. long CCompression::MyConvert(BOOL bQuery,unsigned char *pDetData, long detLength)
  263. {
  264. if(bQuery){
  265. MMRESULT mmr;
  266. HACMSTREAM hstr = NULL;
  267. mmr = acmStreamOpen(&hstr,
  268. NULL, // any driver
  269. &m_wfSrc, // source format
  270. pwfPCM, // destination format
  271. NULL, // no filter
  272. NULL, // no callback
  273. 0, // instance data (not used)
  274. ACM_STREAMOPENF_NONREALTIME); // flags
  275. if (mmr) {
  276. AfxMessageBox("Failed to open a stream to do PCM to PCM conversionn");
  277. return 0;
  278. }
  279. // fill in the conversion info
  280. ACMSTREAMHEADER strhdr;
  281. memset(&strhdr, 0, sizeof(strhdr));
  282. strhdr.cbStruct = sizeof(strhdr);
  283. strhdr.pbSrc = m_pSrcData; // the source data to convert
  284. strhdr.cbSrcLength = m_dwSrcBytes;
  285. strhdr.pbDst = pDst1Data;
  286. strhdr.cbDstLength = dwDst1Bytes;
  288. // prep the header
  289. mmr = acmStreamPrepareHeader(hstr, &strhdr, 0); 
  291. // convert the data
  292. TRACE("Converting to intermediate PCM format...n");
  293. mmr = acmStreamConvert(hstr, &strhdr, 0);
  294. if (mmr) {
  295. AfxMessageBox("Failed to do PCM to PCM conversionn");
  296. return 0;
  297. }
  298. TRACE("Converted OKn");
  300. // close the stream
  301. acmStreamClose(hstr, 0);
  303. ///////////////////////////////////////////////////////////////////////////////////
  304. // convert the intermediate PCM format to the final format
  305. // open the driver
  306. HACMDRIVER had = NULL;
  307. mmr = acmDriverOpen(&had, hadid, 0);
  308. if (mmr) {
  309. AfxMessageBox("Failed to open drivern");
  310. return 0;
  311. }
  313. // open the conversion stream
  314. // Note the use of the ACM_STREAMOPENF_NONREALTIME flag. Without this
  315. // some software compressors will report error 512 - not possible
  316. mmr = acmStreamOpen(&hstr,
  317. had, // driver handle
  318. pwfPCM, // source format
  319. pwfDrv, // destination format
  320. NULL, // no filter
  321. NULL, // no callback
  322. 0, // instance data (not used)
  323. ACM_STREAMOPENF_NONREALTIME ); // flags
  324. if (mmr) {
  325. AfxMessageBox("Failed to open a stream to do PCM to driver format conversionn");
  326. return 0;
  327. }
  329. // fill in the conversion info
  330. ACMSTREAMHEADER strhdr2;
  331. memset(&strhdr2, 0, sizeof(strhdr2));
  332. strhdr2.cbStruct = sizeof(strhdr2);
  333. strhdr2.pbSrc = pDst1Data; // the source data to convert
  334. strhdr2.cbSrcLength = dwDst1Bytes;
  335. strhdr2.pbDst = pDst2Data;
  336. strhdr2.cbDstLength = dwDst2Bytes;
  338. // prep the header
  339. mmr = acmStreamPrepareHeader(hstr, &strhdr2, 0); 
  341. // convert the data
  342. TRACE("Converting to final format...n");
  343. mmr = acmStreamConvert(hstr, &strhdr2, 0);
  344. if (mmr) {
  345. AfxMessageBox("Failed to do PCM to driver format conversionn");
  346. return 0;
  347. }
  348. TRACE("Converted OKn");
  350. // close the stream and driver
  351. mmr = acmStreamClose(hstr, 0);
  352. mmr = acmDriverClose(had, 0);
  354. // show the conversion stats
  355. TRACE("Source wave had %lu bytesn", m_dwSrcBytes);
  356. TRACE("Converted wave has %lu bytesn", strhdr2.cbDstLengthUsed);
  357. TRACE("Compression ratio is %fn", (double)m_dwSrcBytes / (double) strhdr2.cbDstLengthUsed); 
  358. length=strhdr2.cbDstLengthUsed;
  360. return length;
  361. }
  362. else{
  363. if(detLength<length){
  364. AfxMessageBox("Error using the function!");
  365. return 0;
  366. }
  367. memcpy(pDetData,pDst2Data,length);
  368. return length;
  369. }
  370. }
  373. BOOL CCompression::ConvertSend(SOCKET s, SOCKADDR_IN addr)
  374. {
  375. MyConvert(TRUE,NULL,0);
  376. int iError=sendto(s,(char *)pDst2Data,length,0,(LPSOCKADDR)&addr,sizeof(addr));
  377. if(iError==SOCKET_ERROR)
  378. return FALSE;
  379. return TRUE;
  380. }
  382. void CCompression::SetDstSamples(long bytes, unsigned char *pDstData)
  383. {
  384. dwDst2Bytes=bytes;
  385. pDst2Data=(BYTE*)malloc(dwDst2Bytes);
  386. memcpy(pDst2Data,pDstData,dwDst2Bytes);
  387. }
  389. BOOL CCompression::PrepareSpace(BOOL bCompression)
  390. {
  391. if(bCompression){
  392. dwDst1Samples = m_dwSrcSamples * pwfPCM->nSamplesPerSec / m_wfSrc.nSamplesPerSec;
  393. dwDst1Bytes = dwDst1Samples * pwfPCM->wBitsPerSample / 8;
  394.   pDst1Data =(BYTE*)malloc(dwDst1Bytes);
  396. #ifdef _DEBUG
  397. memset(pDst1Data, 0, dwDst1Bytes);
  398. #endif
  399. dwDst2Bytes = pwfDrv->nAvgBytesPerSec * dwDst1Samples / pwfPCM->nSamplesPerSec;
  400. dwDst2Bytes = dwDst2Bytes * 3 / 2; // add a little room
  401. pDst2Data =(BYTE*)malloc(dwDst2Bytes);
  402. #ifdef _DEBUG
  403. memset(pDst2Data, 0, dwDst2Bytes);
  404. #endif
  405. }
  406. else{
  407. dwDst1Samples=pwfPCM->nSamplesPerSec*dwDst2Bytes/pwfDrv->nAvgBytesPerSec;
  408. dwDst1Bytes = dwDst1Samples* 3 / 2; // add a little room
  409. pDst1Data = (BYTE*)malloc(dwDst1Bytes);
  410. #ifdef _DEBUG
  411. memset(pDst1Data, 0, dwDst1Bytes);
  412. #endif
  413. m_dwSrcSamples=dwDst1Samples*m_wfSrc.nSamplesPerSec/pwfPCM->nSamplesPerSec;
  414. m_dwSrcBytes=m_dwSrcSamples*m_wfSrc.wBitsPerSample / 8;
  415. m_pSrcData = (BYTE*)malloc(m_dwSrcBytes);
  417. #ifdef _DEBUG
  418. memset(m_pSrcData, 0, m_dwSrcBytes);
  419. #endif
  420. }
  421. return TRUE;
  422. }
  424. long CCompression::UnConvert(BOOL bQuery, unsigned char *pSrcData, long bytes)
  425. {
  426. if(bQuery){
  427. MMRESULT mmr;
  428. HACMSTREAM hstr = NULL;
  430. HACMDRIVER had = NULL;
  431. mmr = acmDriverOpen(&had, hadid, 0);
  432. if (mmr) {
  433. AfxMessageBox("Failed to open drivern");
  434. return 0;
  435. }
  436. // open the conversion stream
  437. // Note the use of the ACM_STREAMOPENF_NONREALTIME flag. Without this
  438. // some software compressors will report error 512 - not possible
  439. mmr = acmStreamOpen(&hstr,
  440. had, // driver handle
  441. pwfDrv, // source format
  442. pwfPCM, // destination format
  443. NULL, // no filter
  444. NULL, // no callback
  445. 0, // instance data (not used)
  446. ACM_STREAMOPENF_NONREALTIME ); // flags
  447. if (mmr) {
  448. AfxMessageBox("Failed to open a stream to do PCM to driver format conversionn");
  449. return 0;
  450. }
  451. // fill in the conversion info
  452. ACMSTREAMHEADER strhdr2;
  453. memset(&strhdr2, 0, sizeof(strhdr2));
  454. strhdr2.cbStruct = sizeof(strhdr2);
  455. strhdr2.pbSrc = pDst2Data; // the source data to convert
  456. strhdr2.cbSrcLength = dwDst2Bytes;
  457. strhdr2.pbDst = pDst1Data;
  458. strhdr2.cbDstLength = dwDst1Bytes;
  460. // prep the header
  461. mmr = acmStreamPrepareHeader(hstr, &strhdr2, 0); 
  463. // convert the data
  464. TRACE("Converting to final format...n");
  465. mmr = acmStreamConvert(hstr, &strhdr2, 0);
  466. if (mmr) {
  467. AfxMessageBox("Failed to do PCM to driver format conversionn");
  468. return 0;
  469. }
  470. TRACE("Converted OKn");
  471. // close the stream and driver
  472. mmr = acmStreamClose(hstr, 0);
  473. mmr = acmDriverClose(had, 0);
  475. DWORD tmpBytes=strhdr2.cbDstLengthUsed;
  476. // show the conversion stats
  477. TRACE("Source wave had %lu bytesn", m_dwSrcBytes);
  478. TRACE("Converted wave has %lu bytesn", strhdr2.cbDstLengthUsed);
  479. TRACE("Compression ratio is %fn", (double)m_dwSrcBytes / (double) strhdr2.cbDstLengthUsed); 
  481. mmr = acmStreamOpen(&hstr,
  482. NULL, // any driver
  483. pwfPCM, // source format
  484. &m_wfSrc, // destination format
  485. NULL, // no filter
  486. NULL, // no callback
  487. 0, // instance data (not used)
  488. ACM_STREAMOPENF_NONREALTIME ); // flags
  489. if (mmr) {
  490. AfxMessageBox("Failed to open a stream to do PCM to PCM conversionn");
  491. return 0;
  492. }
  493. // fill in the conversion info
  494. ACMSTREAMHEADER strhdr;
  495. memset(&strhdr, 0, sizeof(strhdr));
  496. strhdr.cbStruct = sizeof(strhdr);
  497. strhdr.pbSrc = pDst1Data; // the source data to convert
  498. strhdr.cbSrcLength = tmpBytes;
  499. strhdr.pbDst = m_pSrcData;
  500. strhdr.cbDstLength = m_dwSrcBytes;
  501. // prep the header
  502. mmr = acmStreamPrepareHeader(hstr, &strhdr, 0); 
  503. // convert the data
  504. TRACE("Converting to intermediate PCM format...n");
  505. mmr = acmStreamConvert(hstr, &strhdr, 0);
  506. if (mmr) {
  507. AfxMessageBox("Failed to do PCM to PCM conversionn");
  508. return 0;
  509. }
  510. TRACE("Converted OKn");
  511. // close the stream
  512. acmStreamClose(hstr, 0);
  514. ///////////////////////////////////////////////////////////////////////////////////
  515. // convert the intermediate PCM format to the final format
  516. // open the driver
  517. unlength=strhdr.cbDstLengthUsed;
  519. return unlength;
  520. }
  521. else{
  522. if(bytes<unlength){
  523. memcpy(pSrcData,m_pSrcData,bytes);
  524. return 0;
  525. }
  526. memcpy(pSrcData,m_pSrcData,unlength);
  527. return unlength;
  528. }
  529. }