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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
AudioCtrl.cpp
资源名称：RecordAudio.rar　[点击查看]
上传用户：shenwh911
上传日期：2013-07-04
资源大小：54k
文件大小：26k
源码类别：

Audio

开发平台：

Visual C++

AudioCtrl.cpp：源码内容
  1. // AudioCtrl.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "RecordAudio.h"
  6. #include "AudioCtrl.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #undef THIS_FILE
  11. static char THIS_FILE[] = __FILE__;
  12. #endif
  14. /////////////////////////////////////////////////////////////////////////////
  15. // CAudioCtrl
  17. CAudioCtrl::CAudioCtrl()
  18. : m_uiDeviceID(0)
  19. , m_eStatus(ENUM_STATUS_INVALID)
  20. , m_hRecord(NULL)
  21. , m_hPlay(NULL)
  22. , m_dwQueuBufferSize(1024)
  23. , m_nDataQueueNum(0)
  24. , m_bRecording(FALSE)
  25. , m_eRecChannel(ENUM_REC_CHANNEL_MONO)
  26. , m_szAryInData(NULL)
  27. , m_szLeftInData(NULL)
  28. , m_szRightInData(NULL)
  29. , m_pAryHdr (NULL)
  30. , m_uiMixerID(0)
  31. {
  32. memset(&m_Format, 0, sizeof(WAVEFORMATEX));
  33. m_nDataQueueNum = 0;
  35. ZeroMemory(&m_MMCKInfoParent,sizeof(m_MMCKInfoParent));
  36. ZeroMemory(&m_MMCKInfoChild,sizeof(m_MMCKInfoChild));
  37. memset ( m_hWaveFile, 0, sizeof(m_hWaveFile) );
  39. SetBkColor(RGB(0, 0, 0));
  41. m_bAlwaysDrawTowChannel = false;
  42. }
  44. CAudioCtrl::~CAudioCtrl()
  45. {
  46. StopAndFreeAll();
  47. }
  50. BEGIN_MESSAGE_MAP(CAudioCtrl, CWnd)
  51. //{{AFX_MSG_MAP(CAudioCtrl)
  52. ON_WM_TIMER()
  53. ON_WM_ERASEBKGND()
  54. //}}AFX_MSG_MAP
  55. END_MESSAGE_MAP()
  58. /////////////////////////////////////////////////////////////////////////////
  59. // CAudioCtrl message handlers
  61. //
  62. // 获得声卡的数量
  63. //
  64. UINT CAudioCtrl::GetWaveInDevs()
  65. {
  66. return waveInGetNumDevs();
  67. }
  69. char* CAudioCtrl::GetWaveInName(UINT uiDevID)
  70. {
  71. WAVEINCAPS tagCaps;
  72. if (waveInGetDevCaps(uiDevID, &tagCaps, sizeof(tagCaps)) == MMSYSERR_NOERROR)
  73. {
  74. return tagCaps.szPname;
  75. }
  76. return NULL;
  77. }
  79. UINT CAudioCtrl::GetWaveInAvailableDev()
  80. {
  81. for ( DWORD i=0; i<GetWaveInDevs(); i++ )
  82. {
  83. CVolumeCtrl VolumeIn( 0, i );
  84. if (VolumeIn.IsAvailable())
  85. {
  86. return i;
  87. }
  88. }
  90. return -1;
  91. }
  93. void CAudioCtrl::SetDeviceID(UINT uiIndex)
  94. {
  95. m_uiDeviceID = uiIndex;
  97. }
  99. UINT CAudioCtrl::InitCtrl(UINT uiDevIndex,
  100.   DWORD dwBufSize, 
  101.   HWND hwndParent, 
  102.   LPRECT lpRect, 
  103.   MsgNotifyProc msgNodityProc, 
  104.   WPARAM wParam)
  105. {
  106. StopAndFreeAll();
  107. SetDeviceID(uiDevIndex);
  108. m_dwQueuBufferSize = dwBufSize;
  109. m_pMsgNotifyProc = msgNodityProc;
  110. m_wParam = wParam;
  112. Create(hwndParent, lpRect);
  114. /********** 绘图**********/
  115. if ( hwndParent && lpRect )
  116. {
  117. m_PenG.CreatePen ( PS_SOLID, 0, RGB(0, 255, 0) );
  118. m_PenPartLine.CreatePen ( PS_SOLID, PARTLINE_HEIGHT, COLOR_FRAME );
  119. }
  120. /********** 绘图**********/
  122. m_eStatus = ENUM_STATUS_READY;
  124. return TRUE;
  125. }
  127. //
  128. // 获得播放声音的声卡数量
  129. //
  130. UINT CAudioCtrl::GetWaveOutCount()
  131. {
  132. return waveOutGetNumDevs();
  133. }
  135. BOOL CAudioCtrl::Create(HWND hwndParent, LPRECT lpRect)
  136. {
  137. LPCTSTR lpszClassName = AfxRegisterWndClass(
  138. 0,
  139. LoadCursor(AfxGetInstanceHandle(), IDC_ARROW),
  140. NULL, NULL );
  142. CRect rc ( 0,0,0,0 );
  143. if ( lpRect ) rc = *lpRect;
  145. if ( !CreateEx ( 0, lpszClassName, "",
  146. WS_CHILD | WS_TABSTOP,
  147. rc.left, rc.top, rc.Width(), rc.Height(),
  148. hwndParent, NULL, NULL) )
  149. {
  150. AfxMessageBox ( "Create window failed" );
  151. return FALSE;
  152. }
  154. if ( lpRect )
  155. ShowWindow ( SW_SHOW );
  156. else
  157. ShowWindow ( SW_HIDE );
  159. GetClientRect (&m_rcClient );
  162. /********** 绘图**********/
  163. CClientDC dc(this);
  164. m_fntChannelText.CreatePointFont ( 100, "Impact", &dc );
  165. // m_fntDeviceNameText.CreateFont ( 14, 0, 0, 0, 0, TRUE, TRUE, FALSE, 0, 0,
  166. // 0, 0, 0, "MS Sans Serif" );
  167. /********** 绘图**********/
  169. return TRUE;
  170. }
  172. BOOL CAudioCtrl::PreTranslateMessage(MSG* pMsg) 
  173. {
  174. if ((pMsg->message >= MM_WOM_OPEN) && (pMsg->message <= MM_MOM_DONE))
  175. {
  176. switch ( pMsg->message )
  177. {
  178. case MM_WIM_DATA:
  179. OnMM_WIM_DATA ( pMsg->wParam, pMsg->lParam );
  180. break;
  181. case MM_WIM_CLOSE:
  182. m_eStatus = ENUM_STATUS_READY;
  183. m_nDataQueueNum = 0;
  184. m_bRecording = FALSE;
  185. break;
  186. case MM_WOM_DONE:
  187. OnMM_WOM_DONE ( pMsg->wParam, pMsg->lParam );
  188. break;
  189. case MM_WOM_CLOSE:
  190. m_eStatus = ENUM_STATUS_READY;
  191. m_bRecording = FALSE;
  192. break;
  193. case MM_WIM_OPEN:
  194. break;
  195. case MM_WOM_OPEN:
  196. break;
  197. }
  199. if (m_pMsgNotifyProc)
  200. {
  201. m_pMsgNotifyProc(pMsg->message, m_wParam);
  202. }
  203. }
  204. return CWnd::PreTranslateMessage(pMsg);
  205. }
  207. //
  208. // 录音对应当数据缓冲写满后触发的消息
  209. //
  210. LRESULT CAudioCtrl::OnMM_WIM_DATA (WPARAM wParam, LPARAM lParam)
  211. {
  212. MMRESULT mmReturn = 0;
  214. LPWAVEHDR pHdr = (LPWAVEHDR) lParam;
  215. ASSERT ( pHdr );
  217. // 清除波形输入缓冲区
  218. mmReturn = ::waveInUnprepareHeader (m_hRecord, pHdr, sizeof(WAVEHDR));
  219. if (mmReturn)
  220. {
  221. return -1L;
  222. }
  224. if(m_eStatus == ENUM_STATUS_RECORDING)
  225. {
  226. // 提取单声道PCM数据
  227. int nBytesPickup = PickupMonoData(m_Format.wBitsPerSample, pHdr->lpData, pHdr->dwBytesRecorded);
  229. // 根据需要保存的通道文件类型选择PCM数据和数据长度
  230. char *pRecData[ENUM_FILE_CHANNEL_NUM] = { pHdr->lpData, pHdr->lpData };
  231. int nRecBytes[ENUM_FILE_CHANNEL_NUM] = { pHdr->dwBytesRecorded, pHdr->dwBytesRecorded };
  233. if ( m_eRecChannel == ENUM_REC_CHANNEL_ALONE )
  234. {
  235. pRecData[ENUM_FILE_CHANNEL_LEFT] = m_szLeftInData;
  236. nRecBytes[ENUM_FILE_CHANNEL_LEFT] = nBytesPickup;
  237. pRecData[ENUM_FILE_CHANNEL_RIGHT] = m_szRightInData;
  238. nRecBytes[ENUM_FILE_CHANNEL_RIGHT] = nBytesPickup;
  239. }
  241. // 保存到wave文件中
  242. for ( int eFileChannel=ENUM_FILE_CHANNEL_COMMON; eFileChannel<ENUM_FILE_CHANNEL_NUM; eFileChannel++ )
  243. {
  244. if ( m_hWaveFile[eFileChannel] )
  245. {
  246. int length = ::mmioWrite(m_hWaveFile[eFileChannel], pRecData[eFileChannel], nRecBytes[eFileChannel] );
  247. if ( length != nRecBytes[eFileChannel] )
  248. {
  249. Stop ();
  250. m_nDataQueueNum --;
  251. TRACE("write file failedrn");
  252. return -1L;
  253. }
  254. }
  255. }
  257. // 为波形输入准备一个输入缓冲区
  258. mmReturn = ::waveInPrepareHeader (m_hRecord, pHdr, sizeof(WAVEHDR));
  259. if (mmReturn)
  260. {
  261. TRACE("waveInPrepareHeader failedrn");
  262. }
  263. else
  264. {
  265. // 给输入设备增加一个缓存
  266. mmReturn = ::waveInAddBuffer(m_hRecord, pHdr, sizeof(WAVEHDR));
  267. if (mmReturn)
  268. {
  269. TRACE("waveInAddBuffer() failedrn");
  270. }
  271. else
  272. {
  273. DrawWave( (DWORD)nBytesPickup );
  274. return S_OK;
  275. }
  276. }
  278. }
  279. else
  280. {
  281. if (m_nDataQueueNum == 1)
  282. {
  283. StopRec();
  284. }
  285. else
  286. {
  287. m_nDataQueueNum --;
  288. }
  289. }
  291. return S_OK;
  292. }
  294. //
  295. // 播放对应当数据缓冲读完后触发的消息
  296. //
  297. LRESULT CAudioCtrl::OnMM_WOM_DONE (WPARAM wParam, LPARAM lParam)
  298. {
  299. //TRACE("OnMM_WOM_DONE!rn");
  301. MMRESULT mmReturn = 0;
  303. LPWAVEHDR pHdr = (LPWAVEHDR)lParam;
  304. mmReturn = ::waveOutUnprepareHeader(m_hPlay, pHdr, sizeof(WAVEHDR));
  305. if ( mmReturn )
  306. {
  307. TRACE("waveOutUnprepareHeader() failed!rn" );
  308. return -1L;
  309. }
  311. m_nDataQueueNum--;
  313. if ( m_eStatus == ENUM_STATUS_PLAYING )
  314. {
  316. int nSize = m_dwQueuBufferSize;
  317. if ( ReadSoundDataFromFile ( pHdr->lpData, nSize ) )
  318. {
  319. AddOutputBufferToQueue ( (int)pHdr->dwUser, nSize );
  320. return 0L;
  321. }
  322. else
  323. {
  324. Stop();
  325. }
  326. }
  328. if ( m_nDataQueueNum == 0 && m_eStatus != ENUM_STATUS_PLAYING )
  329. {
  330. StopPlay ();
  331. }
  333. return S_OK;
  334. }
  336. //
  337. // 从立体声PCM数据中提取单声道数据，结果保存到 m_szLeftInData 、 m_szRightInData 中
  338. // return : ------------------------------------------------------------------------------
  339. // 单声道数据长度（字节）
  340. //
  341. int CAudioCtrl::PickupMonoData(WORD wBitsPerSample, char *szOrgData, int nOrgSize)
  342. {
  343. if ( m_Format.nChannels == 1 )
  344. {
  345. ASSERT ( m_dwQueuBufferSize >= (DWORD)nOrgSize );
  346. memcpy ( m_szLeftInData, szOrgData, nOrgSize );
  347. memcpy ( m_szRightInData, szOrgData, nOrgSize );
  348. return nOrgSize;
  349. }
  351. DWORD dwBytesPerSample = wBitsPerSample/8;
  352. int nDestBytes_Left = 0, nDestBytes_Right = 0;
  353. for ( int i=0; i<nOrgSize; i+=2*dwBytesPerSample )
  354. {
  355. memcpy ( m_szLeftInData+nDestBytes_Left, szOrgData+i, dwBytesPerSample );
  356. nDestBytes_Left += dwBytesPerSample;
  357. memcpy ( m_szRightInData+nDestBytes_Right, szOrgData+i+dwBytesPerSample, dwBytesPerSample );
  358. nDestBytes_Right += dwBytesPerSample;
  359. }
  360. ASSERT ( nDestBytes_Left == nDestBytes_Right );
  361. return nDestBytes_Left;
  362. }
  364. void CAudioCtrl::Stop()
  365. {
  366. if ( m_eStatus != ENUM_STATUS_PLAYING && m_eStatus != ENUM_STATUS_RECORDING )
  367. return;
  369. MMRESULT mmReturn = 0;
  370. if ( m_eStatus == ENUM_STATUS_PLAYING )
  371. {
  372. if ( ::waveOutReset(m_hPlay) ) 
  373. {
  374. TRACE("waveOutReset failedrn");
  375. }
  376. SetTimer ( TIMER_EVENT_STOPPLAY, 1000, NULL );
  377. }
  378. else if ( m_eStatus == ENUM_STATUS_RECORDING )
  379. {
  380. SetTimer ( TIMER_EVENT_STOPREC, 1000, NULL );
  381. }
  383. Invalidate ( TRUE );
  384. m_eStatus = ENUM_STATUS_STOPING;
  385. }
  387. void CAudioCtrl::StopRec()
  388. {
  389. if ( !m_hRecord ) return;
  390. if ( m_eStatus != ENUM_STATUS_RECORDING && m_eStatus != ENUM_STATUS_STOPING )
  391. return;
  393. MMRESULT mmReturn = 0;
  394. mmReturn = ::waveInReset ( m_hRecord );
  395. if ( mmReturn ) 
  396. {
  397. TRACE("waveInReset failedrn");
  398. }
  400. ::Sleep ( 10 );
  401. for ( int eFileChannel=ENUM_FILE_CHANNEL_COMMON; eFileChannel<ENUM_FILE_CHANNEL_NUM; eFileChannel++ )
  402. {
  403. //StopRecordAudioFile ( (ENUM_FILE_CHANNEL)eFileChannel, "mp3" );
  404. StopRecordAudioFile ( (ENUM_FILE_CHANNEL)eFileChannel, "wav" );
  405. }
  407. mmReturn = ::waveInClose ( m_hRecord );
  408. m_hRecord = NULL;
  409. if ( mmReturn ) 
  410. {
  411. TRACE("waveInClose failedrn" );
  412. }
  413. //FreeMp3Encode ();
  414. }
  416. // 
  417. // 录制
  418. //
  419. BOOL CAudioCtrl::Record(UINT uiRecChannel,   /*录制信道*/
  420. DWORD dwSamplingRate,/*采样率*/ 
  421. WORD  wSamplingBit  /*采样位*/
  422. ) 
  423. {
  424. // 录音设备正在录音
  425. if ( m_eStatus == ENUM_STATUS_RECORDING )
  426. {
  427. TRACE("recording...rn");
  428. return FALSE;
  429. }
  431. if (m_eStatus != ENUM_STATUS_READY)
  432. {
  433. TRACE("AudioCtrl state failed...rn");
  434. return FALSE;
  435. }
  437. m_bRecording = TRUE;
  438. MMRESULT mmReturn = 0;
  440. ASSERT((wSamplingBit%8) == 0);
  441. if (wSamplingBit > 16)
  442. {
  443. wSamplingBit = 16;
  444. }
  446. SetWaveFormat(uiRecChannel, dwSamplingRate, wSamplingBit);
  447. if (!SetRelateParaAfterGetWaveFormat())
  448. {
  449. return TRUE;
  450. }
  452. mmReturn = ::waveInOpen(&m_hRecord, m_uiDeviceID, &m_Format, (DWORD)GetSafeHwnd(), NULL, CALLBACK_WINDOW);
  453. if (mmReturn)
  454. {
  455. TRACE("waveInOpen is failed!rn");
  456. goto failed;
  457. }
  458. else
  459. {
  460. // make several input buffers and add them to the input queue
  461. for(int i=0; i<m_wInQueu; i++)
  462. {
  463. AddInputBufferToQueue ( i );
  464. }
  466. // start recording
  467. mmReturn = ::waveInStart ( m_hRecord );
  468. if ( mmReturn )
  469. {
  470. TRACE("waveInStart is failed!rn");
  471. goto failed;
  472. }
  473. }
  475. m_eStatus = ENUM_STATUS_RECORDING;
  477. return TRUE;
  478. failed:
  479. FreeBuffer();
  480. return FALSE;
  481. }
  483. void CAudioCtrl::SetWaveFormat(UINT uiRecChannel, 
  484.    DWORD dwSamplingRate, 
  485.    WORD  wSamplingBit)
  486. {
  487. m_eRecChannel = (ENUM_REC_CHANNEL)uiRecChannel;
  488. memset(&m_Format, 0, sizeof(WAVEFORMATEX));
  489. m_Format.cbSize = 0;
  490. m_Format.wFormatTag = WAVE_FORMAT_PCM;
  491. m_Format.wBitsPerSample = wSamplingBit;
  492. m_Format.nChannels = ((uiRecChannel==ENUM_REC_CHANNEL_MONO) ? 1 : 2);
  493. m_Format.nSamplesPerSec = dwSamplingRate;
  494. m_Format.nAvgBytesPerSec = m_Format.nSamplesPerSec * (m_Format.wBitsPerSample/8);
  495. m_Format.nBlockAlign = m_Format.nChannels * (m_Format.wBitsPerSample/8);
  496. }
  498. void CAudioCtrl::FreeBuffer()
  499. {
  500. // 录音或者播放尚未停止，不能释放内存
  501. for ( int eFileChannel=ENUM_FILE_CHANNEL_COMMON; eFileChannel<ENUM_FILE_CHANNEL_NUM; eFileChannel++ )
  502. {
  503. //if ( m_hWaveFile[eFileChannel] || m_pFileMp3[eFileChannel] )
  504. if (m_hWaveFile[eFileChannel])
  505. return;
  506. }
  508. if (m_szAryInData)
  509. {
  510. for ( int i=0; i<m_wInQueu; i++ )
  511. {
  512. if ( m_szAryInData[i] )
  513. delete[] m_szAryInData[i];
  514. }
  515. memset ( m_szAryInData, 0, sizeof(char*)*m_wInQueu );
  516. delete[] m_szAryInData;
  517. m_szAryInData = NULL;
  518. }
  520. if ( m_szLeftInData )
  521. {
  522. delete[] m_szLeftInData;
  523. m_szLeftInData = NULL;
  524. }
  526. if ( m_szRightInData )
  527. {
  528. delete[] m_szRightInData;
  529. m_szRightInData = NULL;
  530. }
  532. if (m_pAryHdr)
  533. {
  534. for (int i=0; i<m_wInQueu; i++)
  535. {
  536. if (m_pAryHdr[i])
  537. {
  538. delete[] m_pAryHdr[i];
  539. }
  540. }
  541. memset(m_pAryHdr, 0, sizeof(WAVEHDR*)*m_wInQueu);
  542. delete[] m_pAryHdr;
  543. m_pAryHdr = NULL;
  544. }
  545. }
  547. BOOL CAudioCtrl::SetRelateParaAfterGetWaveFormat()
  548. {
  549. FreeBuffer ();
  550. m_wInQueu = (WORD) ( m_Format.nChannels + m_Format.wBitsPerSample/8 + m_Format.nSamplesPerSec/11025 );
  551. if ( !AllocateBuffer ( m_dwQueuBufferSize ) )
  552. return FALSE;
  553. return TRUE;
  554. }
  556. BOOL CAudioCtrl::AllocateBuffer(DWORD dwBufferSize)
  557. {
  558. m_dwQueuBufferSize = dwBufferSize;
  560. ASSERT ( m_wInQueu > 0 );
  561. m_szAryInData = new char*[m_wInQueu];
  562. m_szLeftInData = new char[m_dwQueuBufferSize];
  563. m_szRightInData = new char[m_dwQueuBufferSize];
  564. m_pAryHdr = new WAVEHDR*[m_wInQueu];
  565. if ( !m_szAryInData || !m_szLeftInData || !m_szRightInData || !m_pAryHdr )
  566. {
  567. ::AfxThrowMemoryException ();
  568. return FALSE;
  569. }
  570. memset ( m_szAryInData, 0, sizeof(char*)*m_wInQueu );
  571. memset ( m_szLeftInData, 0, sizeof(char)*m_dwQueuBufferSize );
  572. memset ( m_szRightInData, 0, sizeof(char)*m_dwQueuBufferSize );
  573. memset ( m_pAryHdr, 0, sizeof(WAVEHDR*)*m_wInQueu );
  575. for ( int i=0; i<m_wInQueu; i++ )
  576. {
  577. m_szAryInData[i] = new char[m_dwQueuBufferSize];
  578. m_pAryHdr[i] = new WAVEHDR;
  579. if ( !m_szAryInData[i] || !m_pAryHdr[i] )
  580. {
  581. ::AfxThrowMemoryException ();
  582. return FALSE;
  583. }
  584. memset ( m_szAryInData[i], 0, m_dwQueuBufferSize );
  585. memset ( m_pAryHdr[i], 0, sizeof(WAVEHDR) );
  586. }
  588. return TRUE;
  589. }
  591. BOOL CAudioCtrl::AddInputBufferToQueue(int nIndex)
  592. {
  593. ASSERT ( nIndex >= 0 && nIndex < m_wInQueu );
  594. ASSERT ( m_szAryInData[nIndex] );
  595. MMRESULT mmReturn = 0;
  597. LPWAVEHDR pHdr = m_pAryHdr[nIndex];
  598. ZeroMemory ( pHdr, sizeof(WAVEHDR) );
  599. pHdr->lpData = (char*)m_szAryInData[nIndex];
  600. pHdr->dwBufferLength = m_dwQueuBufferSize;
  602. // prepare it
  603. mmReturn = ::waveInPrepareHeader ( m_hRecord, pHdr, sizeof(WAVEHDR) );
  604. if ( mmReturn )
  605. {
  606. TRACE("waveInPrepareHeader Failedrn");
  607. return FALSE;
  608. }
  610. // add the input buffer to the queue
  611. mmReturn = ::waveInAddBuffer ( m_hRecord, pHdr, sizeof(WAVEHDR) );
  612. if ( mmReturn )
  613. {
  614. TRACE("waveInAddBuffer() failedrn");
  615. return FALSE;
  616. }
  618. m_nDataQueueNum ++;
  620. return TRUE;
  621. }
  623. BOOL CAudioCtrl::SetRecordAudioFile(UINT uiChancel, char *pszFileName)
  624. {
  625. if (uiChancel > ENUM_FILE_CHANNEL_NUM)
  626. {
  627. return FALSE;
  628. }
  630. if (m_hWaveFile[uiChancel])
  631. return TRUE;
  633. WAVEFORMATEX wfx = m_Format;
  634. if (uiChancel==ENUM_REC_CHANNEL_ALONE )
  635. wfx.nChannels = 1;
  637. m_hWaveFile[uiChancel] = ::mmioOpen((LPTSTR)pszFileName, NULL, MMIO_CREATE|MMIO_WRITE|MMIO_EXCLUSIVE|MMIO_ALLOCBUF);
  638. if ( m_hWaveFile[uiChancel] == NULL ) 
  639. {
  640. AfxMessageBox ( "Open wave file failed" );
  641. return FALSE;
  642. }
  644. ZeroMemory ( &m_MMCKInfoParent[uiChancel], sizeof(MMCKINFO) );
  645. m_MMCKInfoParent[uiChancel].fccType = mmioFOURCC('W','A','V','E');
  647.     MMRESULT mmResult = ::mmioCreateChunk( m_hWaveFile[uiChancel], &m_MMCKInfoParent[uiChancel], MMIO_CREATERIFF);
  649. ZeroMemory ( &m_MMCKInfoChild[uiChancel], sizeof(MMCKINFO) );
  650. m_MMCKInfoChild[uiChancel].ckid = mmioFOURCC('f','m','t',' ');
  651. m_MMCKInfoChild[uiChancel].cksize = sizeof(WAVEFORMATEX) + wfx.cbSize;
  653. mmResult = ::mmioCreateChunk(m_hWaveFile[uiChancel], &m_MMCKInfoChild[uiChancel], 0);
  654. mmResult = ::mmioWrite(m_hWaveFile[uiChancel], (char*)&wfx, sizeof(WAVEFORMATEX) + wfx.cbSize); 
  655. mmResult = ::mmioAscend(m_hWaveFile[uiChancel], &m_MMCKInfoChild[uiChancel], 0);
  656. m_MMCKInfoChild[uiChancel].ckid = mmioFOURCC('d', 'a', 't', 'a');
  657. mmResult = ::mmioCreateChunk ( m_hWaveFile[uiChancel], &m_MMCKInfoChild[uiChancel], 0 );
  660. return TRUE;
  661. }
  663. void CAudioCtrl::StopRecordAudioFile(ENUM_FILE_CHANNEL eFileChannel, CString csStopFileType)
  664. {
  665. if ( csStopFileType=="wav" && m_hWaveFile[eFileChannel] )
  666. {
  667. ::mmioAscend ( m_hWaveFile[eFileChannel], &m_MMCKInfoChild[eFileChannel], 0 );
  668. ::mmioAscend ( m_hWaveFile[eFileChannel], &m_MMCKInfoParent[eFileChannel], 0 );
  669. ::mmioClose ( m_hWaveFile[eFileChannel], 0 );
  670. m_hWaveFile[eFileChannel] = NULL;
  671. }
  672. }
  674. void CAudioCtrl::OnTimer(UINT nIDEvent) 
  675. {
  676. switch ( nIDEvent )
  677. {
  678. case TIMER_EVENT_STOPREC:
  679. KillTimer ( nIDEvent );
  680. StopRec ();
  681. break;
  682. case TIMER_EVENT_STOPPLAY:
  683. KillTimer ( nIDEvent );
  684. StopPlay ();
  685. break;
  686. }
  687. CWnd::OnTimer(nIDEvent);
  688. }
  690. DWORD CAudioCtrl::SetMixerDevs(UINT uiLine, DWORD* pdwMinVolume, DWORD* pdwMaxVolume)
  691. {
  692. m_uiMixerID = uiLine;
  693. CVolumeCtrl volumeCtrl(uiLine, m_uiDeviceID);
  694. if (pdwMinVolume)
  695. {
  696. *pdwMinVolume = volumeCtrl.GetMinimalVolume();
  697. }
  698. if (pdwMaxVolume)
  699. {
  700. *pdwMaxVolume = volumeCtrl.GetMaximalVolume();
  701. }
  702. volumeCtrl.Enable();
  703. return volumeCtrl.GetCurrentVolume();
  704. }
  706. void CAudioCtrl::SetCurVolume(DWORD dwValue)
  707. {
  708. CVolumeCtrl volumeCtrl(m_uiMixerID, m_uiDeviceID);
  709. volumeCtrl.SetCurrentVolume(dwValue);
  710. }
  712. BOOL CAudioCtrl::Play(char *pszPath)
  713. {
  714. if (pszPath == NULL || m_eStatus == ENUM_STATUS_PLAYING)
  715. {
  716. return FALSE;
  717. }
  719. m_bRecording = FALSE;
  720. if (m_eStatus != ENUM_STATUS_READY)
  721. {
  722. return FALSE;
  723. }
  725. if (!OpenWaveFile(pszPath))
  726. return FALSE;
  729. MMRESULT mmReturn = 0;
  731. // open wavein device
  732. mmReturn = ::waveOutOpen ( &m_hPlay, m_uiDeviceID, &m_Format, (DWORD)GetSafeHwnd(), NULL, CALLBACK_WINDOW );
  733. if ( mmReturn )
  734. {
  735. TRACE("waveOutOpen() failedrn");
  736. return FALSE;
  737. }
  738. else
  739. {
  740. // make several input buffers and add them to the input queue
  741. for(int i=0; i<m_wInQueu; i++)
  742. {
  743. int nSize = m_dwQueuBufferSize;
  744. if ( !ReadSoundDataFromFile ( m_szAryInData[i], nSize ) )
  745. {
  746. if ( i == 0 )
  747. {
  748. AfxMessageBox ( "Read sound data from file failed" );
  749. return FALSE;
  750. }
  751. }
  752. if ( !AddOutputBufferToQueue ( i, nSize ) )
  753. return FALSE;
  754. }
  755. }
  757. m_eStatus = ENUM_STATUS_PLAYING;
  759. return TRUE;
  760. }
  762. BOOL CAudioCtrl::OpenWaveFile(char *lpszWaveFileName)
  763. {
  764. if ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] ) return FALSE; 
  766. m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] = ::mmioOpen ( (LPTSTR)lpszWaveFileName,NULL,MMIO_READ );
  767. if ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] == NULL ) 
  768. {
  769. AfxMessageBox ( "Open wave file failed" );
  770. return FALSE;
  771. }
  773. m_MMCKInfoParent[ENUM_FILE_CHANNEL_COMMON].fccType = mmioFOURCC('W','A','V','E');
  774. MMRESULT mmResult = ::mmioDescend(m_hWaveFile[ENUM_FILE_CHANNEL_COMMON], &m_MMCKInfoParent[ENUM_FILE_CHANNEL_COMMON],NULL,MMIO_FINDRIFF);
  775. if(mmResult)
  776. {
  777. AfxMessageBox("Error descending into file");
  778. ::mmioClose(m_hWaveFile[ENUM_FILE_CHANNEL_COMMON],0);
  779. m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] = NULL;
  780. return FALSE;
  781. }
  782. m_MMCKInfoChild[ENUM_FILE_CHANNEL_COMMON].ckid = mmioFOURCC('f','m','t',' ');
  783. mmResult = mmioDescend(m_hWaveFile[ENUM_FILE_CHANNEL_COMMON],&m_MMCKInfoChild[ENUM_FILE_CHANNEL_COMMON],&m_MMCKInfoParent[ENUM_FILE_CHANNEL_COMMON],MMIO_FINDCHUNK);
  784. if(mmResult)
  785. {
  786. AfxMessageBox("Error descending in wave file");
  787. mmioClose(m_hWaveFile[ENUM_FILE_CHANNEL_COMMON],0);
  788. m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] = NULL;
  789. return FALSE;
  790. }
  792. DWORD bytesRead = mmioRead ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON],(LPSTR)&m_Format, m_MMCKInfoChild[ENUM_FILE_CHANNEL_COMMON].cksize );
  793. if ( bytesRead < 0 )
  794. {
  795. AfxMessageBox ( "Error reading PCM wave format record" );
  796. mmioClose ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON], 0 );
  797. return FALSE;
  798. }
  799. if ( !SetRelateParaAfterGetWaveFormat () )
  800. return FALSE;
  802. // open output sound file
  803. mmResult = mmioAscend ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON], &m_MMCKInfoChild[ENUM_FILE_CHANNEL_COMMON], 0 );
  804. if ( mmResult )
  805. {
  806. AfxMessageBox ( "Error ascending in File" );
  807. mmioClose ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON], 0 );
  808. m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] = NULL;
  809. return FALSE;
  810. }
  811. m_MMCKInfoChild[ENUM_FILE_CHANNEL_COMMON].ckid = mmioFOURCC('d','a','t','a');
  812. mmResult = mmioDescend ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON], &m_MMCKInfoChild[ENUM_FILE_CHANNEL_COMMON], &m_MMCKInfoParent[ENUM_FILE_CHANNEL_COMMON], MMIO_FINDCHUNK );
  813. if ( mmResult )
  814. {
  815. AfxMessageBox("error reading data chunk");
  816. mmioClose(m_hWaveFile[ENUM_FILE_CHANNEL_COMMON],0);
  817. m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] = NULL;
  818. return FALSE;
  819. }
  821. return TRUE;
  822. }
  824. BOOL CAudioCtrl::ReadSoundDataFromFile(LPVOID data, int &size)
  825. {
  826. ASSERT ( data && size > 0 );
  827. ASSERT ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] );
  828. return ( ( size = ::mmioRead ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON], (char*)data, size) ) > 0 );
  829. }
  831. BOOL CAudioCtrl::AddOutputBufferToQueue(int nIndex, int nSize)
  832. {
  833. ASSERT ( nIndex >= 0 && nIndex < m_wInQueu );
  834. ASSERT ( m_szAryInData[nIndex] );
  836. MMRESULT mmReturn = 0;
  838. // create the header
  839. LPWAVEHDR pHdr = m_pAryHdr[nIndex];
  840. memset ( pHdr, 0, sizeof(WAVEHDR) );
  842. // new a buffer
  843. pHdr->lpData = (char*)m_szAryInData[nIndex];
  844. pHdr->dwBufferLength = m_dwQueuBufferSize;
  845. pHdr->dwBytesRecorded = nSize;
  846. pHdr->dwFlags = 0;
  847. pHdr->dwUser = nIndex;
  849. // prepare it
  850. mmReturn = ::waveOutPrepareHeader ( m_hPlay, pHdr, sizeof(WAVEHDR) );
  851. if ( mmReturn )
  852. {
  853. TRACE("waveOutPrepareHeader() failed!rn");
  854. return FALSE;
  855. }
  856. // write the buffer to output queue
  857. mmReturn = ::waveOutWrite ( m_hPlay, pHdr, sizeof(WAVEHDR) );
  858. if (mmReturn) 
  859. {
  860. TRACE("waveOutWrite() failed!rn");
  861. }
  862. // increment the number of waiting buffers
  863. m_nDataQueueNum++;
  865. int nBytesPickup = PickupMonoData ( m_Format.wBitsPerSample, pHdr->lpData, pHdr->dwBytesRecorded );
  867. //绘制波形
  868. DrawWave((DWORD)nBytesPickup);
  870. return TRUE;
  871. }
  873. void CAudioCtrl::StopPlay()
  874. {
  875. MMRESULT mmReturn = 0;
  876. if ( !m_hPlay ) return;
  877. if ( m_eStatus != ENUM_STATUS_PLAYING && m_eStatus != ENUM_STATUS_STOPING )
  878. return;
  880. waveOutPause(m_hPlay);
  881. mmReturn = ::waveOutClose(m_hPlay);
  882. if (mmReturn)
  883. {
  884. TRACE("waveOutClose() failed!rn");
  885. }
  887. m_hPlay = NULL;
  888. if (m_hWaveFile[ENUM_FILE_CHANNEL_COMMON])
  889. {
  890. ::mmioClose ( m_hWaveFile[ENUM_FILE_CHANNEL_COMMON], 0 );
  891. m_hWaveFile[ENUM_FILE_CHANNEL_COMMON] = NULL;
  892. }
  893. m_eStatus = ENUM_STATUS_READY;
  895. StopAndFreeAll();
  896. }
  898. void CAudioCtrl::StopAndFreeAll()
  899. {
  900. if (m_hRecord)
  901. {
  902. StopRec();
  903. }
  905. if (m_hPlay)
  906. {
  907. StopPlay();
  908. }
  910. FreeBuffer();
  911. }
  914. //
  915. // 绘图
  916. //
  917. BOOL CAudioCtrl::OnEraseBkgnd(CDC* pDC) 
  918. {
  919. DrawBackground ( pDC );
  920. return CWnd::OnEraseBkgnd(pDC);
  921. }
  923. void CAudioCtrl::DrawBackground(CDC *pDC, BOOL bLeftChannel)
  924. {
  925. ASSERT ( pDC );
  926. if ( !m_brsBkGnd.GetSafeHandle() ) return;
  928. // 画背景
  929. CString csCaption;
  930. CRect rcBK = GetRectByChannel ( bLeftChannel );
  931. if ( bLeftChannel )
  932. {
  933. csCaption = "Left";
  934. }
  935. else
  936. {
  937. csCaption = "Right";
  938. }
  939. pDC->FillRect ( &rcBK, &m_brsBkGnd );
  941. // 画文字
  942. CFont *pOldFnt = NULL;
  943. if ( m_fntChannelText.GetSafeHandle() )
  944. {
  945. pOldFnt = pDC->SelectObject ( &m_fntChannelText );
  946. }
  947. CRect rcText = rcBK;
  948. rcText.DeflateRect ( 2, 2 );
  949. pDC->SetTextColor ( RGB(255,255,0) );
  950. pDC->DrawText ( csCaption, &rcText, DT_LEFT | DT_TOP | DT_SINGLELINE );
  951. if ( pOldFnt ) pDC->SelectObject ( pOldFnt );
  952. }
  954. void CAudioCtrl::DrawBackground(CDC *pDC)
  955. {
  956. pDC->SetBkMode ( TRANSPARENT );
  957. DrawBackground ( pDC, TRUE );
  958. DrawBackground ( pDC, FALSE );
  959. // 画分隔线
  960. CPen *pOldPen = NULL;
  961. if ( m_PenPartLine.GetSafeHandle() )
  962. pOldPen = pDC->SelectObject ( &m_PenPartLine );
  963. pDC->MoveTo ( 0, m_rcClient.Height()/2 );
  964. pDC->LineTo ( m_rcClient.right, m_rcClient.Height()/2 );
  965. if ( pOldPen ) pDC->SelectObject ( pOldPen );
  967. // 画声卡名文字
  968. /*
  969. CFont *pOldFnt = NULL;
  970. CRect rcText = m_rcClient;
  971. rcText.DeflateRect ( 4, 4 );
  972. if ( m_fntDeviceNameText.GetSafeHandle() )
  973. {
  974. pOldFnt = pDC->SelectObject ( &m_fntDeviceNameText );
  975. }
  976. pDC->SetTextColor ( RGB(128,255,255) );
  977. pDC->DrawText ( "haha!", &rcText, DT_RIGHT | DT_BOTTOM | DT_SINGLELINE );
  978. if ( pOldFnt ) pDC->SelectObject ( pOldFnt );
  979. */
  981. // 画外框
  982. pDC->Draw3dRect ( &m_rcClient, COLOR_FRAME, COLOR_FRAME );
  983. }
  985. CRect CAudioCtrl::GetRectByChannel(BOOL bLeftChannel)
  986. {
  987. CRect rcBK = m_rcClient;
  988. if ( bLeftChannel )
  989. {
  990. rcBK.bottom = (m_rcClient.Height() - PARTLINE_HEIGHT) / 2;
  991. }
  992. else
  993. {
  994. rcBK.top = (m_rcClient.Height() + PARTLINE_HEIGHT) / 2;
  995. }
  996. return rcBK;
  997. }
  999. void CAudioCtrl::SetBkColor(COLORREF clr)
  1000. {
  1001. m_clrBK = clr;
  1002. if ( m_brsBkGnd.GetSafeHandle() )
  1003. {
  1004. m_brsBkGnd.DeleteTempMap();
  1005. m_brsBkGnd.DeleteObject();
  1006. }
  1007. m_brsBkGnd.CreateSolidBrush ( clr );
  1008. if ( ::IsWindow ( m_hWnd ) )
  1009. Invalidate ();
  1011. if ( m_PenB.GetSafeHandle() )
  1012. m_PenB.DeleteObject ();
  1013. m_PenB.CreatePen ( PS_SOLID, 0, m_clrBK );
  1014. }
  1016. void CAudioCtrl::DrawWave(DWORD dwChannelBytes)
  1017. {
  1018. CClientDC dc(this);
  1020. BOOL bRecLeft = TRUE, bRecRight = TRUE;
  1021. if ( !m_bAlwaysDrawTowChannel && m_eStatus == ENUM_STATUS_RECORDING && m_eRecChannel == ENUM_REC_CHANNEL_ALONE )
  1022. {
  1023. if ( !m_hWaveFile[ENUM_FILE_CHANNEL_LEFT])
  1024. bRecLeft = FALSE;
  1025. if ( !m_hWaveFile[ENUM_FILE_CHANNEL_RIGHT])
  1026. bRecRight = FALSE;
  1027. }
  1029. // 先将上次画的擦掉
  1030. DrawBackground ( &dc );
  1031. // 画波形图
  1032. CPen *pOndPen = dc.SelectObject ( &m_PenG );
  1034. if (m_Format.wBitsPerSample == 8)
  1035. {
  1036. if (bRecLeft) 
  1037. {
  1038. DrwaWaveChar(dc, dwChannelBytes/2, (BYTE*)m_szLeftInData, TRUE);
  1039. }
  1041. if (bRecRight) 
  1042. {
  1043. DrwaWaveChar(dc, dwChannelBytes/2, (BYTE*)m_szRightInData, FALSE);
  1044. }
  1045. }
  1046. else
  1047. {
  1048. if (bRecLeft)
  1049. {
  1050. DrwaWaveShort(dc, dwChannelBytes/2, (SHORT*)m_szLeftInData, TRUE);
  1051. }
  1053. if (bRecRight) 
  1054. {
  1055. DrwaWaveShort(dc, dwChannelBytes/2, (SHORT*)m_szRightInData, FALSE);
  1056. }
  1057. }
  1059. if (pOndPen)
  1060. dc.SelectObject ( pOndPen );
  1061. }
  1063. void CAudioCtrl::DrwaWaveChar(CClientDC &dc, 
  1064.   DWORD dwDrawBytes, 
  1065.   BYTE *pCharData, 
  1066.   BOOL bLeftChannel)
  1067. {
  1068. CRect rcBK = GetRectByChannel ( bLeftChannel );
  1069. int y = (int) ( pCharData[0] * rcBK.Height() / 0xff );
  1070. dc.MoveTo ( 0, y );
  1071. float fStep = (float)rcBK.Width() / (float)(dwDrawBytes);
  1072. float fLineX = 0;
  1073. for ( DWORD i=1; i<dwDrawBytes; i++ )
  1074. {
  1075. fLineX += fStep;
  1076. y = (int) ( pCharData[i] * rcBK.Height() / 0xff );
  1077. dc.LineTo ( (int)fLineX, y );
  1079. //TRACE2("DrawWave X=%f Y=%drn", fLineX, y);
  1080. }
  1081. }
  1083. void CAudioCtrl::DrwaWaveShort(CClientDC &dc, DWORD dwDrawBytes, SHORT *pShortData, BOOL bLeftChannel)
  1084. {
  1085. CRect rcBK = GetRectByChannel ( bLeftChannel );
  1086. int nCenterY = rcBK.CenterPoint().y;
  1087. int y = nCenterY + (int) ( pShortData[0] * rcBK.Height() / 0xffff );
  1088. dc.MoveTo ( 0, y );
  1089. float fStep = (float)rcBK.Width() / (float)(dwDrawBytes);
  1090. float fLineX = 0;
  1091. for ( DWORD i=1; i<dwDrawBytes; i++ )
  1092. {
  1093. fLineX += fStep;
  1094. y = nCenterY + (int) ( pShortData[i] * rcBK.Height() / 0xffff );
  1095. dc.LineTo ( (int)fLineX, y );
  1097. //TRACE2("DrwaWaveShort X=%f Y=%drn", fLineX, y);
  1098. }
  1099. }
  1101. BOOL CAudioCtrl::IsPlay()
  1102. {
  1103. if (m_eStatus == ENUM_STATUS_PLAYING)
  1104. {
  1105. return TRUE;
  1106. }
  1107. return FALSE;
  1108. }
  1110. BOOL CAudioCtrl::IsRecord()
  1111. {
  1112. if (m_eStatus == ENUM_STATUS_RECORDING)
  1113. {
  1114. return TRUE;
  1115. }
  1116. return FALSE;
  1117. }