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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
DirectSound.cpp
资源名称：Dsound.rar　[点击查看]
上传用户：hygd004
上传日期：2022-02-04
资源大小：1841k
文件大小：15k
源码类别：

DirextX编程

开发平台：

Visual C++

DirectSound.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Copyright (C) 1998 by J鰎g K鰊ig
  3. // All rights reserved
  4. //
  5. // This file is part of the completely free tetris clone "CGTetris".
  6. //
  7. // This is free software.
  8. // You may redistribute it by any means providing it is not sold for profit
  9. // without the authors written consent.
  10. //
  11. // No warrantee of any kind, expressed or implied, is included with this
  12. // software; use at your own risk, responsibility for damages (if any) to
  13. // anyone resulting from the use of this software rests entirely with the
  14. // user.
  15. //
  16. // Send bug reports, bug fixes, enhancements, requests, flames, etc., and
  17. // I'll try to keep a version up to date.  I can be reached as follows:
  18. //    J.Koenig@adg.de                 (company site)
  19. //    Joerg.Koenig@rhein-neckar.de    (private site)
  20. /////////////////////////////////////////////////////////////////////////////
  23. // DirectSound.cpp: implementation of the CDirectSound class.
  24. //
  25. //////////////////////////////////////////////////////////////////////
  27. #include "stdafx.h"
  28. #include "DirectSound.h"
  29. #include "INITGUID.h"
  30. #include "TKCore.h"
  31. #include "process.h"
  33. // The following macro is defined since DirectX 5, but will work with
  34. // older versions too.
  35. #ifndef DSBLOCK_ENTIREBUFFER
  36. #define DSBLOCK_ENTIREBUFFER        0x00000002
  37. #endif
  39. #ifdef _DEBUG
  40. #undef THIS_FILE
  41. static char THIS_FILE[]=__FILE__;
  42. #define new DEBUG_NEW
  43. #endif
  45. static void DSError( HRESULT hRes ) {
  46. switch(hRes) {
  47. case DS_OK: TKL_Trace("NO ERRORn"); break;
  48. case DSERR_ALLOCATED: TKL_Trace("ALLOCATEDn"); break;
  49. case DSERR_INVALIDPARAM: TKL_Trace("INVALIDPARAMn"); break;
  50. case DSERR_OUTOFMEMORY: TKL_Trace("OUTOFMEMORYn"); break;
  51. case DSERR_UNSUPPORTED: TKL_Trace("UNSUPPORTEDn"); break;
  52. case DSERR_NOAGGREGATION: TKL_Trace("NOAGGREGATIONn"); break;
  53. case DSERR_UNINITIALIZED: TKL_Trace("UNINITIALIZEDn"); break;
  54. case DSERR_BADFORMAT: TKL_Trace("BADFORMATn"); break;
  55. case DSERR_ALREADYINITIALIZED: TKL_Trace("ALREADYINITIALIZEDn"); break;
  56. case DSERR_BUFFERLOST: TKL_Trace("BUFFERLOSTn"); break;
  57. case DSERR_CONTROLUNAVAIL: TKL_Trace("CONTROLUNAVAILn"); break;
  58. case DSERR_GENERIC: TKL_Trace("GENERICn"); break;
  59. case DSERR_INVALIDCALL: TKL_Trace("INVALIDCALLn"); break;
  60. case DSERR_OTHERAPPHASPRIO: TKL_Trace("OTHERAPPHASPRIOn"); break;
  61. case DSERR_PRIOLEVELNEEDED: TKL_Trace("PRIOLEVELNEEDEDn"); break;
  62. default: TKL_Trace("%lun",hRes);break;
  63. }
  64. }
  66. //////////////////////////////////////////////////////////////////////
  67. // Construction/Destruction
  68. //////////////////////////////////////////////////////////////////////
  70. LPDIRECTSOUND CDirectSound::m_lpDirectSound;
  71. LPDIRECTSOUNDBUFFER  CDirectSound::m_pDsb;
  72. LPDIRECTSOUNDNOTIFY  CDirectSound::m_pDsNotify; 
  74. DWORD CDirectSound::m_dwInstances;
  77. CDirectSound::CDirectSound()
  78. {
  80. ::ZeroMemory(&m_config,sizeof(AUDIO_CONFIG));
  81. m_pDsNotify = 0;
  82. m_bFir = 1; 
  83. m_lpDirectSound = 0;
  84. m_pDsb = 0;
  85. m_pTheSound = 0;
  86. m_dwTheSound = 0;
  87. m_bEnabled = TRUE;
  89. m_bPlay = 0;
  90. ++m_dwInstances;
  91. m_hPlayThread = 0;
  92. m_dwBufNum = 4;
  93. m_dwBufLen = 8192;
  94. m_dwOffset = 0;
  96. m_dwBufSize = 0;
  97. m_bStop = 0;
  98. m_pTheSound = (BYTE*)malloc(BUFSIZE);
  100. // m_pTheSound = new BYTE[BUFSIZE];
  102. m_sysncObj = CreateMutex(0,0,0);
  103. }
  105. CDirectSound::~CDirectSound()
  106. {
  107. if(m_hPlayThread)
  108. {
  109. WaitForSingleObject(m_hPlayThread,2000);
  110. CloseHandle(m_hPlayThread);
  111. m_hPlayThread = NULL;
  112. }
  114. free(m_pTheSound);
  116. if(m_pDsNotify)
  117. {
  118. m_pDsNotify->Release();
  119. m_pDsNotify = NULL;
  120. }
  121. if(m_pDsb)
  122. {
  123. m_pDsb->Release();
  124. m_pDsb = NULL;
  125. }
  128. if( !--m_dwInstances && m_lpDirectSound ) {
  129. m_lpDirectSound->Release();
  130. m_lpDirectSound = 0;
  131. }
  133. if(m_sysncObj)
  134. {
  135. CloseHandle(m_sysncObj);
  136. m_sysncObj = NULL;
  137. }
  138. // free(m_pTheSound);
  139. // ::delete[] m_pTheSound;
  140. }
  142. unsigned int WINAPI PlaySoundProc(LPVOID pOwner)
  143. {
  144. CDirectSound* pThis = (CDirectSound*) pOwner;
  145. pThis->WriteToBuf();
  146. return 1;
  147. }
  149. int CDirectSound::WriteDataToBuf(BYTE* pBuf,DWORD dwLen)
  150. {
  152. if(m_dwBufSize + dwLen > BUFSIZE)
  153. return -1;
  155. // GENRS_AutoLock lock(m_sysncObj);
  156. WaitForSingleObject(m_sysncObj,2000);
  157. {
  158. memcpy(m_pTheSound+m_dwBufSize,pBuf,dwLen); 
  159. m_dwBufSize += dwLen;
  160. ReleaseMutex(m_sysncObj);
  161. }
  163. return 1;
  165. }
  168. BOOL CDirectSound::SetPlaySpeed(float fSpeed)
  169. {
  170. // AUDIO_CONFIG lc_config;
  171. m_fRate = fSpeed;
  172. m_config.nSamplesPerSec = m_nSamplesPerSec*fSpeed;
  173. m_config.nAvgBytesPerSec = m_nAvgBytesPerSec*fSpeed;
  174. Stop();
  175. if(!CreateDSound(&m_config,m_dwBufLen))
  176. return FALSE;
  177. Play();
  178. return TRUE;
  180. }
  182. /*
  183. void CDirectSound::SetHWnd(HWND hWnd)
  184. {
  185. m_hWnd = hWnd;
  186. }*/
  188. BOOL CDirectSound :: CreateDSound(AUDIO_CONFIG* WaveHead,DWORD dwHeadLen)
  189. {
  191. if(m_config.nSamplesPerSec == NULL)
  192. {
  193. m_fRate = 1.0;
  194. m_config = *WaveHead;
  195. m_nAvgBytesPerSec = m_config.nAvgBytesPerSec;
  196. m_nSamplesPerSec  = m_config.nSamplesPerSec;
  197. }
  199. m_dwBufLen = dwHeadLen ;
  200. if(m_lpDirectSound)
  201. {
  202. return TRUE;
  203. }
  204. HRESULT hRes = DS_OK;
  205. short nRes = 0;
  206. do {
  207. if( nRes )
  208. ::Sleep(500);
  209. hRes = ::DirectSoundCreate(0, &m_lpDirectSound, 0);
  210. ++nRes;
  211. } 
  212. while( nRes < 10 && (hRes == DSERR_ALLOCATED || hRes == DSERR_NODRIVER) );
  214. if( hRes != DS_OK )
  215. return FALSE;
  217. m_lpDirectSound->SetCooperativeLevel(/*m_hWnd*/::GetDesktopWindow(), DSSCL_NORMAL);
  219. // WAVEFORMATEX * pcmwf;
  220. // DWORD dwHeadLen = 1000;
  222. // if(!GetWaveData(pHeader, pcmwf, m_dwTheSound) )
  223. // return FALSE;
  224. m_rate = WaveHead->nAvgBytesPerSec;
  226. if(!CreateSoundBuffer((WAVEFORMATEX*)(&m_config)))
  227. return FALSE;
  231. // SetSoundData(0,m_pTheSound, m_dwTheSound);
  232. // m_bPlay = TRUE;
  234. // dwHeadLen = m_dwTheSound;
  235. m_bStop = 0;
  236. m_dwBufSize = 0;
  238. unsigned int dwID;
  239. // m_hPlayThread = CreateThread(0,0,PlaySoundProc,this,0,&dwID);
  240. m_hPlayThread = (HANDLE)_beginthreadex(0,0,PlaySoundProc,this,0,&dwID);
  241. return TRUE;
  243. }
  246. BOOL CDirectSound :: GetWaveData(void * pRes, WAVEFORMATEX * & pWaveHeader, 
  247.  void * & pbWaveData, DWORD & cbWaveSize
  248.  )
  249. {
  250. pWaveHeader = 0;
  251. pbWaveData = 0;
  252. cbWaveSize = 0;
  254. DWORD * pdw = (DWORD *)pRes;
  255. DWORD dwRiff = *pdw++;
  256. DWORD dwLength = *pdw++;
  257. DWORD dwType = *pdw++;
  259. if( dwRiff != mmioFOURCC('R', 'I', 'F', 'F') )
  260. return FALSE;      // not even RIFF
  262. if( dwType != mmioFOURCC('W', 'A', 'V', 'E') )
  263. return FALSE;      // not a WAV
  265. DWORD * pdwEnd = (DWORD *)((BYTE *)pdw + 1000-4);
  267. while( pdw < pdwEnd ) {
  268. dwType = *pdw++;
  269. dwLength = *pdw++;
  271. switch( dwType ) {
  272. case mmioFOURCC('f', 'm', 't', ' '):
  273. if( !pWaveHeader ) {
  274. if( dwLength < sizeof(WAVEFORMAT) )
  275. return FALSE;      // not a WAV
  277. pWaveHeader = (WAVEFORMATEX *)pdw;
  279. if( pbWaveData && cbWaveSize )
  280. return TRUE;
  281. }
  282. break;
  284. case mmioFOURCC('d', 'a', 't', 'a'):
  285. pbWaveData = LPVOID(pdw);
  286. cbWaveSize = dwLength;
  288. if( pWaveHeader )
  289. return TRUE;
  290. break;
  291. }
  292. pdw = (DWORD *)((BYTE *)pdw + ((dwLength+1)&~1));
  293. }
  295. return FALSE;
  296. }
  301. BOOL CDirectSound :: GetWaveData(void * pHeader, WAVEFORMATEX * & pWaveHeader,
  302.   DWORD & dwHeadSize)
  303. {
  304. dwHeadSize  = 0;
  305. pWaveHeader = 0;
  307. DWORD * pdw = (DWORD *)pHeader;
  308. DWORD dwRiff = *pdw++;
  309. DWORD dwLength = *pdw++;
  310. DWORD dwType = *pdw++;
  312. m_dwTotalSize = dwLength;
  314. if( dwRiff != mmioFOURCC('R', 'I', 'F', 'F') )
  315. return FALSE;      // not even RIFF
  317. if( dwType != mmioFOURCC('W', 'A', 'V', 'E') )
  318. return FALSE;      // not a WAV
  321. dwType = *pdw++;
  322. dwLength = *pdw++;
  324. if(dwType!= mmioFOURCC('f', 'm', 't', ' '))
  325. return FALSE;
  327. if( !pWaveHeader )
  328. {
  329. if( dwLength < sizeof(WAVEFORMAT) )
  330. return FALSE;      // not a WAV
  332. pWaveHeader = (WAVEFORMATEX *)pdw;
  333. }
  335. dwHeadSize += 5*sizeof(DWORD);
  336. return TRUE;
  338. }
  341. BOOL CDirectSound::WriteToBuf()
  342. {
  344. // m_bPlay = TRUE;
  346. if( !SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_ABOVE_NORMAL ))
  347. {
  348. return FALSE;
  349. };
  351. while (!m_bStop)
  352. {
  354. if(m_bFir)
  355. {
  356. //ParseBuffer();
  358. //GENRS_AutoLock lock(m_sysncObj);
  359. while (m_dwBufSize < 3*m_dwBufLen)
  360. {
  361. if(m_bStop)
  362. break;
  363. Sleep(10);
  364. }
  365. WaitForSingleObject(m_sysncObj,20000);
  366. {
  370. SetSoundData( m_pTheSound, 3*m_dwBufLen);
  372. if(m_dwBufSize > 3*m_dwBufLen)
  373. memcpy(m_pTheSound,m_pTheSound+3*m_dwBufLen,m_dwBufSize - 3*m_dwBufLen);
  374. m_dwBufSize -= 3*m_dwBufLen;
  376. ReleaseMutex(m_sysncObj);
  377. }
  378. // m_pDsb->Play(0,0,1);
  379. m_bFir = 0;
  380. }
  381. else
  382. {
  385. int id = WaitForMultipleObjects(m_dwBufNum,notify_events,0,INFINITE);
  387. //ParseBuffer();
  389. //GENRS_AutoLock lock(m_sysncObj);
  390. while (m_dwBufSize < m_dwBufLen)
  391. {
  392. if(m_bStop)
  393. break;
  394. Sleep(10);
  395. }
  397. WaitForSingleObject(m_sysncObj,2000);
  398. {
  400. TKL_Trace("ID = %d",id);
  401. if(id == 0)
  402. m_dwOffset = 3*m_dwBufLen;
  403. else
  404. m_dwOffset = (id-1)*m_dwBufLen;
  406. SetSoundData( m_dwOffset,m_pTheSound, m_dwBufLen);
  407. if(m_dwBufSize > m_dwBufLen)
  408. memcpy(m_pTheSound,m_pTheSound+m_dwBufLen,m_dwBufSize - m_dwBufLen);
  410. m_dwBufSize -= m_dwBufLen;
  411. ReleaseMutex(m_sysncObj);
  412. }
  414. }
  415. }
  416. return TRUE;
  417. // SetSoundData(m_pSoundBuf,dwSoundSize);
  420. }
  422. BOOL CDirectSound::CreateSoundBuffer(WAVEFORMATEX * pcmwf)
  423. {
  425. DSBUFFERDESC dsbdesc;
  426. // Set up DSBUFFERDESC structure.
  427. memset(&dsbdesc, 0, sizeof(DSBUFFERDESC)); // Zero it out.
  428. dsbdesc.dwSize = sizeof(DSBUFFERDESC);
  429. // Need no controls (pan, volume, frequency).
  430. dsbdesc.dwFlags =  dsbdesc.dwFlags = 
  431.    DSBCAPS_GETCURRENTPOSITION2/* Better position accuracy */
  432.    | DSBCAPS_CTRLPOSITIONNOTIFY     /* We need notification */
  433.    | DSBCAPS_GLOBALFOCUS;      /* Allows background playing *///DSBCAPS_STATIC; // assumes that the sound is played often
  434. dsbdesc.dwBufferBytes =m_dwBufNum*m_dwBufLen;// m_dwTheSound;
  435. dsbdesc.lpwfxFormat = pcmwf;    // Create buffer.
  436. HRESULT hRes;
  437. if( DS_OK != (hRes = m_lpDirectSound->CreateSoundBuffer(&dsbdesc, &m_pDsb, 0)) ) {
  438. // Failed.
  439. DSError(hRes);
  440. m_pDsb = 0;
  441. return FALSE;
  442. }
  444. for (int i=0;i<m_dwBufNum;i++)
  445. {
  446. //create dsound buffer notify points
  447. //Auto reset event
  448. m_hEvent=CreateEvent( NULL, FALSE, FALSE, NULL );
  449. DSNotify[i].hEventNotify=m_hEvent; 
  451. DSNotify[i].dwOffset=i*(m_dwBufLen);//NOTIFYNUM);
  452. }
  454. hRes = m_pDsb->QueryInterface(IID_IDirectSoundNotify,(void **)&m_pDsNotify); 
  455.     if (FAILED(hRes)) //SUCCEEDED
  456. {
  457.           return FALSE;
  458. }
  460. //NOTIFYNUM notify point
  461. hRes=m_pDsNotify->SetNotificationPositions(m_dwBufNum,DSNotify); 
  462. if (FAILED(hRes)) //SUCCEEDED
  463. {
  464.      
  465.  return FALSE;
  466. }
  468. for (int n=0;n< m_dwBufNum;n++)
  469. {
  470. notify_events[n]=DSNotify[n].hEventNotify;
  471. ResetEvent(notify_events[n]); 
  472. }
  473. return TRUE;
  474. }
  476. BOOL CDirectSound::SetSoundData(void * pSoundData,DWORD SoundSize)
  477. {
  478. LPVOID lpvPtr1;
  479. DWORD dwBytes1;
  481. if (!pSoundData) return FALSE;
  482. // ASSERT(SoundSize<=DDSOUNDBUFLEN);
  483. // Obtain write pointer.
  484. HRESULT hr = m_pDsb->Lock(0, SoundSize, &lpvPtr1, &dwBytes1, 0, 0, DSBLOCK_ENTIREBUFFER);    
  485.     // If DSERR_BUFFERLOST is returned, restore and retry lock.
  486. if(DSERR_BUFFERLOST == hr) {
  487. m_pDsb->Restore();
  488. hr = m_pDsb->Lock(0, SoundSize, &lpvPtr1, &dwBytes1, 0, 0, DSBLOCK_ENTIREBUFFER);
  489. }
  490. if(DS_OK == hr) {
  491. // Write to pointers.
  492. ::CopyMemory(lpvPtr1, pSoundData, SoundSize);
  493. // Release the data back to DirectSound.
  494. hr = m_pDsb->Unlock(lpvPtr1, dwBytes1, 0, 0);
  495. if(DS_OK == hr)
  496.             return TRUE;
  497. }
  498. // Lock, Unlock, or Restore failed.
  499. return FALSE;
  501. }
  509. BOOL CDirectSound::SetSoundData(DWORD Offset,void * pSoundData, DWORD dwSoundSize)
  510. {
  511. LPVOID lpPart1;
  512.     LPVOID lpPart2;
  513.     DWORD  Part1Len,Part2Len;
  516. DWORD off_read,off_write;
  517.     //char buf[128];
  518.     m_pDsb->GetCurrentPosition(&off_read,&off_write);
  519. TKL_Trace("offset = %d,off_read=%d off_write=%dn",Offset,off_read,off_write);
  521. // Obtain write pointer.
  522. HRESULT hr = m_pDsb->Lock(Offset, dwSoundSize, &lpPart1, &Part1Len, &lpPart2, &Part2Len, 0);    
  524.     // If DSERR_BUFFERLOST is returned, restore and retry lock.
  525. if(DSERR_BUFFERLOST == hr) {
  526. m_pDsb->Restore();
  527. hr = m_pDsb->Lock(Offset, dwSoundSize, &lpPart1, &Part1Len, &lpPart2, &Part2Len, 0);
  528. }
  529. if(DS_OK == hr) {
  530. // Write to pointers.
  531. ::CopyMemory(lpPart1, pSoundData, Part1Len);
  532. if (lpPart2)
  533. {
  534. ::CopyMemory(lpPart2, (BYTE*)pSoundData+Part1Len, Part2Len);
  535. }
  538. // Release the data back to DirectSound.
  539. hr = m_pDsb->Unlock(lpPart1, Part1Len, lpPart2, Part2Len);
  541. }
  542. // Lock, Unlock, or Restore failed.
  544. return FALSE;
  545. }
  549. void CDirectSound::Play(INT nTime, BOOL bLoop)
  550. {
  551. if( ! IsValid() /*|| ! IsEnabled()*/ )
  552. return; // no chance to play the sound ...
  555. DWORD dwPlayCursor;
  556. DWORD dwWriteCursor;
  557. m_pDsb->GetCurrentPosition(&dwPlayCursor, &dwWriteCursor);
  559. int offByte = nTime*m_rate/1000;
  561. if(dwPlayCursor >0)
  562. {
  563. if( dwPlayCursor > m_dwBufLen* m_dwBufNum )
  564. dwPlayCursor = m_dwBufLen* m_dwBufNum;
  566. }
  567. if(dwPlayCursor > offByte)
  568. {
  569. if(dwPlayCursor  < -offByte)
  570. {
  571. dwPlayCursor = 0;
  572. }
  573. else
  574. {
  575. dwPlayCursor += offByte;
  576. }
  578. }
  580. else
  581. dwPlayCursor = m_dwBufLen* m_dwBufNum;
  583. m_pDsb->SetCurrentPosition(dwPlayCursor);
  585. if( DSERR_BUFFERLOST == m_pDsb->Play(0, 0, 1) ) 
  586. {
  587. // another application had stolen our buffer
  588. // Note that a "Restore()" is not enough, because
  589. // the sound data is invalid after Restore().
  590. SetSoundData(m_pTheSound, m_dwBufLen);
  593. // Try playing again
  594. m_pDsb->Play(0, 0, 1);
  595. }
  597. }
  599. void CDirectSound::Stop()
  600. {
  601. m_bStop = 1;
  602. if(m_hPlayThread)
  603. {
  605. WaitForSingleObject(m_hPlayThread,2000);
  606. CloseHandle(m_hPlayThread);
  607. m_hPlayThread = NULL;
  608. }
  609. if( IsValid() )
  610. m_pDsb->Stop();
  612. for (int i=0;i<m_dwBufNum;i++)
  613. {
  614. //create dsound buffer notify points
  615. //Auto reset event
  616. ResetEvent(notify_events[i]);
  617. CloseHandle(notify_events[i]);//=m_hEvent; 
  619. }
  620. if(m_pDsNotify)
  621. {
  622. m_pDsNotify->Release();
  623. m_pDsNotify = NULL;
  624. }
  625. if(m_pDsb)
  626. {
  627. m_pDsb->Release();
  628. m_pDsb = NULL;
  629. }
  630. if(m_lpDirectSound)
  631. {
  632. m_lpDirectSound->Release();
  633. m_lpDirectSound = NULL;
  634. }
  635. m_bFir = 1;
  636. m_dwBufSize = 0;
  637. }
  639. void CDirectSound::Pause()
  640. {
  641. if( IsValid() )
  642. m_pDsb->Stop();
  643. }
  645. void CDirectSound::Continue()
  646. {
  647. if( IsValid() ) {
  648. DWORD dwPlayCursor, dwWriteCursor;
  649. m_pDsb->GetCurrentPosition(&dwPlayCursor, &dwWriteCursor);
  650. Play(dwPlayCursor);
  651. }
  652. }
  654. BOOL CDirectSound::IsValid() const
  655. {
  656. return (m_lpDirectSound && m_pDsb ) ? TRUE : FALSE;
  657. }