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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
SBuffer.cpp
资源名称：Mir2ExCodev1.rar　[点击查看]
上传用户：cydong117
上传日期：2009-11-10
资源大小：638k
文件大小：16k
源码类别：

模拟服务器

开发平台：

Visual C++

SBuffer.cpp：源码内容
  1. // SBuffer.cpp: implementation of the CSBuffer class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "StdAfx.h"
  7. //////////////////////////////////////////////////////////////////////
  8. // Construction/Destruction
  9. //////////////////////////////////////////////////////////////////////
  11. CSBuffer::CSBuffer()
  12. {
  13. m_pDS = NULL;
  14. m_lpDSB = NULL;
  15. m_Filename = NULL;
  16. m_Current = 0;
  17. m_dwLastUseTime = 0;
  18. m_nBuffers = 1;
  19. m_3d = FALSE;
  20. m_lp3dBuffer = NULL;
  21. m_Streamed = FALSE;
  22. m_sFile=NULL;
  23. // m_pbUsingBuffer = NULL;
  24. m_ID=0;
  25. }
  27. CSBuffer::~CSBuffer()
  28. {
  29. Stop();
  30. Release();
  31. }
  33. VOID CSBuffer::Release(VOID)
  34. {
  35. DWORD Status=0;
  36. if(m_ID!=0)
  37. {
  38. if( m_lpDSB )
  39. {
  40. for(int i = m_nBuffers-1; i >-1 ; i--)
  41. {
  42. if(SUCCEEDED(m_lpDSB[i]->GetStatus(&Status)))
  43. {
  44. if(Status&DSBSTATUS_PLAYING)
  45. m_lpDSB[i]->Stop();
  46. HRESULT hResult = m_lpDSB[i]->Release();
  47. // delete *m_lpDSB[i];
  48. m_lpDSB[i] = NULL;
  49. }
  50. }
  51. DELETEARRAY(m_lpDSB);
  52. m_lpDSB = NULL;
  53. }
  55. if( m_lp3dBuffer )
  56. {
  57. for(int i = 0; i < m_nBuffers; i++) SAFE_RELEASE(m_lp3dBuffer[i]);
  58. DELETEARRAY(m_lp3dBuffer);
  59. }
  61. if( m_Streamed && m_sStop )
  62. {
  63. if( m_sFile )
  64. {
  65. fclose(m_sFile);
  66. m_sFile=NULL;
  67. }
  68. }
  69. m_pDS = NULL;
  70. m_ID=0;
  71. }
  72. }
  76. HRESULT CSBuffer::Load(CSound *pDS, const char *Filename, int Num)
  77. {
  78. CHAR szFname[MAX_PATH];
  79. // Check the Parameters
  80. if( Filename == NULL ) return DSERR_INVALIDPARAM;
  82. HRESULT rval=DSERR_GENERIC;
  83. FILE *fptr;
  85. strcpy(szFname,"Sound\");
  86. strcat(szFname,Filename);
  88. fptr = fopen( szFname, "rb" );
  89. if( fptr )
  90. {
  91. if(m_Streamed)
  92. {
  93. m_sStop=FALSE;
  94. m_sFile=fptr;
  95. }
  96. rval = Load( pDS, 0, fptr, Num );
  97. if(!m_Streamed) fclose( fptr );
  98. m_Filename = Filename;
  99. }
  100. return rval;
  101. }
  103. HRESULT CSBuffer::Load(CSound* pDS, LONG lSize, CHAR* lpCache, int Num)
  104. {
  105.     HRESULT rval;
  106.     
  107.     rval = Extract(pDS, lSize, lpCache, Num);
  109.     return rval;
  110. }
  112. HRESULT CSBuffer::Load(CSound *pDS, LONG lSize, FILE *fptr, int Num)
  113. {
  114.     HRESULT rval;
  115.     CHAR* lpCache;
  116.     int length, save;
  118. // Release all allocated Memory, befor continue
  119. // m_nBuffers = Num;
  120. Release( );
  122.     length = lSize;
  124.     // If lSize equals zero get the size of the file.
  125.     if(length == 0)
  126.     {
  127.         // Save the pointer location
  128.         save = ftell(fptr);
  129.         if(ferror(fptr))
  130.             return NULL;
  132.         // Seek to end of file
  133.         fseek(fptr, 0, SEEK_END);
  134.         if(ferror(fptr))
  135.             return NULL;
  137.         // Get the size of the file
  138.         length = ftell(fptr);
  139.         if(ferror(fptr))
  140.             return NULL;
  142.         // Seek back to save position
  143.         fseek(fptr, save, SEEK_SET);
  144.         if(ferror(fptr))
  145.             return NULL;
  147.     }
  149.     // Cache the whole file in memory
  150.     // Allocate memory to hold the data
  151.     lpCache = new CHAR[length];
  152.     if(lpCache == NULL)
  153.         return NULL;
  155.     // Read in the data
  156.     fread(lpCache, 1, length, fptr);
  157.     if(ferror(fptr))
  158.     {
  159.         delete [] lpCache;
  160.         return NULL;
  161.     }
  163.     // Load it from memory.
  164.     rval = Extract(pDS, length, lpCache, Num);
  166.     // Delete the cache
  167.     delete [] lpCache;
  169. return rval;
  170. }
  173. HRESULT CSBuffer::Extract(CSound *pDS, LONG lSize, char *ptr, int Num)
  174. {
  175. HRESULT rval;
  177. // Release all memory, befor continue
  178. Release();
  180. // Check the Parameters
  181. if( ptr == NULL ) return DSERR_INVALIDPARAM;
  182. if( pDS == NULL ) return DSERR_INVALIDPARAM;
  183. if( pDS->GetDS() == NULL ) return DSERR_UNINITIALIZED;
  184. if( m_Streamed ) return DSERR_INVALIDPARAM;
  186. if( Num<1 ) Num = 1;
  188. m_pDS      = pDS;
  189. m_nBuffers = Num;
  190. m_Filename = NULL;
  192. if( strncmp( ptr, "RIFF", 4 ) || strncmp( ptr+8, "WAVE", 4 ) )
  193. return DSERR_BADFORMAT;
  195. DWORD hSize = *(DWORD*)(ptr+16);
  196. LPWAVEFORMATEX lpWav = (LPWAVEFORMATEX)(ptr+20);
  198. // skip all "fact" and search for the data
  199. // the fact stores the uncompressed filesize
  200. DWORD dSize = 0;
  201. ptr += 20 + hSize;
  202. do
  203. {
  204. if( dSize ) ptr += dSize + 8;
  205.     dSize = *(DWORD*)(ptr+4);
  206. } while( !strncmp( ptr, "fact", 4 ) );
  207. ptr += 8;
  209. // Is it compressed or a normal PCM Wave File
  210. if( lpWav->wFormatTag == WAVE_FORMAT_PCM )
  211. {
  212. // Create the sound buffer for the wave file
  213. rval = CreateSoundBuffer( dSize, (PCMWAVEFORMAT*)lpWav, Num );
  214. if(FAILED(rval)) return rval;
  216. // Read the data for the wave file into the sound buffer
  217. rval = ReadDataFromMemory( ptr, dSize );
  218. if(FAILED(rval)) return rval;
  219. }
  222. // Duplicate Buffers
  223. for( int i = 1; i < m_nBuffers; i++ )
  224. {
  225. rval = m_pDS->GetDS()->DuplicateSoundBuffer(m_lpDSB[0], &m_lpDSB[i]);
  226. if(FAILED(rval)) return rval;
  228. if( m_3d )
  229. {
  230. rval = m_lpDSB[0]->QueryInterface(IID_IDirectSound3DBuffer, (LPVOID *)&m_lp3dBuffer[i]);
  231. if(FAILED(rval)) return rval;
  232. }
  233. }
  235. return DS_OK;
  236. //return DSERR_UNSUPPORTED;
  237. }
  241. HRESULT CSBuffer::CreateSoundBuffer(DWORD dwBufSize, PCMWAVEFORMAT *pcmwf, int Num)
  242. {
  243. HRESULT rval;
  244. // Create Space for Soundbuffer Pointers
  245. m_lpDSB = new LPDIRECTSOUNDBUFFER[Num];
  246. if( m_lpDSB == NULL ) return DSERR_OUTOFMEMORY;
  247. ZeroMemory( m_lpDSB, sizeof( LPDIRECTSOUNDBUFFER )*Num );
  249. if( m_3d )
  250. {
  251. m_lp3dBuffer = new LPDIRECTSOUND3DBUFFER[Num];
  252. if( m_lp3dBuffer == NULL ) return DSERR_OUTOFMEMORY;
  253. ZeroMemory( m_lp3dBuffer, sizeof( LPDIRECTSOUNDBUFFER )*Num );
  254. }
  256. DSBUFFERDESC dsbdesc;
  257. // Set up DSBUFFERDESC structure.
  258. ZeroMemory(&dsbdesc, sizeof(DSBUFFERDESC));
  259. dsbdesc.dwSize        = sizeof(DSBUFFERDESC);
  260. dsbdesc.dwBufferBytes = dwBufSize; 
  261. dsbdesc.lpwfxFormat   = (LPWAVEFORMATEX)pcmwf;
  262. if( m_Streamed ) dsbdesc.dwFlags=DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY|DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_CTRLPOSITIONNOTIFY;
  263. else if( m_3d )  dsbdesc.dwFlags=DSBCAPS_CTRL3D|DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_MUTE3DATMAXDISTANCE|DSBCAPS_CTRLFREQUENCY|DSBCAPS_CTRLVOLUME;
  264. else dsbdesc.dwFlags=DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY|DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_STATIC;
  266. rval=m_pDS->GetDS()->CreateSoundBuffer(&dsbdesc, &m_lpDSB[0], NULL);
  267. if( FAILED(rval) ) return rval;
  269. if( m_3d )
  270. {
  271. rval=m_lpDSB[0]->QueryInterface(IID_IDirectSound3DBuffer, (LPVOID *)&m_lp3dBuffer[0]);
  272. if(FAILED(rval)) return rval;
  273. }
  275. return DS_OK;
  276. }
  278. HRESULT CSBuffer::ReadDataFromMemory(char *ptr, DWORD dwSize)
  279. {
  280. // Lock data in buffer for writing
  281. LPVOID pData1, pData2;
  282. DWORD  dwData1Size, dwData2Size;
  283. HRESULT rval;
  285. rval = m_lpDSB[0]->Lock(0, 0, &pData1, &dwData1Size, &pData2, &dwData2Size, DSBLOCK_ENTIREBUFFER);
  287. if(FAILED(rval)) return rval;
  289. // Read in data(on dx3 read in first chunk)
  290. if(dwData1Size>0) 
  291. {
  292. memcpy(pData1, ptr, dwData1Size);
  293. ptr+=dwData1Size;
  294. }
  296. // Read in second chunk if necessary
  297. if(dwData2Size>0) memcpy(pData2, ptr, dwData2Size);
  299. // Unlock data in buffer
  300. rval = m_lpDSB[0]->Unlock(pData1, dwData1Size, pData2, dwData2Size);
  301. if(FAILED(rval)) return rval;
  303. return DS_OK;
  304. }
  306. HRESULT CSBuffer::Play( DWORD dwFlags )
  307. {
  308. HRESULT rval;
  309. LPDIRECTSOUNDBUFFER Buffer = NULL;
  311. if( m_pDS==NULL ) return DSERR_UNINITIALIZED;
  312. if( m_pDS->GetSoundOn( ) ) return DS_OK;
  314. Buffer = GetFreeBuffer();
  315. if( Buffer==NULL ) return DSERR_ALLOCATED;
  317. if(m_Streamed)
  318. {
  319. m_sLoop=dwFlags;
  320. dwFlags=DSBPLAY_LOOPING;
  321. }
  323. m_dwLastUseTime = timeGetTime();
  324. rval=Buffer->Play(0, 0, dwFlags);
  325. if(FAILED(rval)) return rval;
  327. return DS_OK;
  328. }
  330. LPDIRECTSOUNDBUFFER CSBuffer::GetFreeBuffer(VOID)
  331. {
  332. DWORD Status;
  333. HRESULT rval;
  334. LPDIRECTSOUNDBUFFER Buffer;
  335. Status = 0;
  336. nBufferIdx = MAX_DUPLE_COUNT;
  337. if(m_lpDSB==NULL) return NULL;
  338. if(m_ID!=0)
  339. {
  340. Buffer=m_lpDSB[m_Current];
  341. rval = Buffer->GetStatus(&Status);
  342. nBufferIdx = m_Current;
  343. if(FAILED(rval)) Status = 0;
  345. if((Status & DSBSTATUS_PLAYING) == DSBSTATUS_PLAYING)
  346. {
  347. if(m_nBuffers > 1)
  348. {
  349. if (++m_Current >= m_nBuffers) 
  350. {
  351. m_Current = 0;
  352. }
  354. Buffer = m_lpDSB[m_Current];
  355. rval = Buffer->GetStatus(&Status);
  356. nBufferIdx = m_Current;
  357. if(SUCCEEDED(rval) && (Status & DSBSTATUS_PLAYING) == DSBSTATUS_PLAYING)
  358. {
  359. // Play吝捞搁 家府甫 肛眠绊 贸澜栏肺 倒赴促.
  360. /* Buffer->Stop();
  361. Buffer->SetCurrentPosition(0);
  363. */
  364. // Play吝捞搁 家府甫 促澜 家府绰 Play 窍瘤 富巴
  365. m_Current = m_Current==0 ? m_nBuffers-1 : m_Current-1;
  366. Buffer = NULL;
  367. nBufferIdx = MAX_DUPLE_COUNT;
  368. }
  369. }
  370. else 
  371. {
  372. Buffer=NULL;
  373. nBufferIdx = MAX_DUPLE_COUNT;
  374. }
  375. }
  377. if(Buffer && (Status & DSBSTATUS_BUFFERLOST))
  378. if(FAILED(Buffer->Restore()))
  379. {
  380. Buffer = NULL;
  381. nBufferIdx = MAX_DUPLE_COUNT;
  382. }
  383. }
  385. return Buffer;
  386. }
  388. HRESULT CSBuffer::EnableStreaming( int size, int blocks )
  389. {
  390. if( m_3d ) return DSERR_ACCESSDENIED;
  391. m_Streamed=TRUE;
  392. m_sSize=size;
  393. m_sBlocks=blocks;
  394. return DS_OK;
  395. }
  397. HRESULT CSBuffer::Enable3d( void )
  398. {
  399. if( m_Streamed ) return DSERR_ACCESSDENIED;
  400. m_3d=TRUE;
  401. return DS_OK;
  402. }
  404. HRESULT CSBuffer::LoadFromRes( CSound* pDS, const char *Filename, int Num )
  405. {
  406. if( Filename == NULL ) return DSERR_INVALIDPARAM;
  408. HRSRC hResInfo;
  409. HGLOBAL hResData;
  411. void *pvRes;
  413. if((( hResInfo = FindResource(NULL, Filename, "WAV")) == NULL ) ) return DSERR_GENERIC;
  414. if(( hResData = LoadResource(NULL, hResInfo)) == NULL) return DSERR_GENERIC;
  415. if(( pvRes = LockResource(hResData)) == NULL) return DSERR_GENERIC;
  417. return CSBuffer::Extract( pDS, 0, (char*)pvRes, Num);
  418. }
  420. HRESULT CSBuffer::PlayExtended( DWORD dwFlags, int Pan, int Volume, DWORD freq )
  421. {
  422. HRESULT rval;
  423. LPDIRECTSOUNDBUFFER Buffer = NULL;
  425. if( m_pDS==NULL ) return DSERR_UNINITIALIZED;
  426. if( m_pDS->GetSoundOn( ) ) return DS_OK;
  428. Buffer=GetFreeBuffer();
  429. if(Buffer==NULL) return DSERR_ALLOCATED;
  431. rval=Buffer->SetPan(Pan);
  432. if(FAILED(rval)) return rval;
  434. rval=Buffer->SetVolume(Volume);
  435. if(FAILED(rval)) return rval;
  437. rval=Buffer->SetFrequency(freq);
  438. if(FAILED(rval)) return rval;
  440. if(m_Streamed)
  441. {
  442. m_sLoop=dwFlags;
  443. dwFlags=DSBPLAY_LOOPING;
  444. }
  445. m_dwLastUseTime = timeGetTime();
  446. rval=Buffer->Play(0, 0, dwFlags);
  447. if(FAILED(rval)) return rval;
  449. return DS_OK;
  450. }
  453. HRESULT CSBuffer::PlayExtended( float x, float y, float z, DWORD dwFlags )
  454. {
  455. HRESULT rval;
  456. LPDIRECTSOUNDBUFFER Buffer = NULL;
  458. if(m_pDS==NULL) return DSERR_UNINITIALIZED;
  459. if(m_pDS->GetSoundOn()) return DS_OK;
  460. if(m_lp3dBuffer==NULL) return DSERR_UNINITIALIZED;
  462. Buffer=GetFreeBuffer();
  463. if(Buffer==NULL) return DSERR_ALLOCATED;
  464. if(m_lp3dBuffer[m_Current]==NULL) return DSERR_UNINITIALIZED;
  466. rval=m_lp3dBuffer[m_Current]->SetPosition( x, y, z, DS3D_IMMEDIATE );
  467. if(FAILED(rval)) return rval;
  469. m_dwLastUseTime = timeGetTime();
  470. rval = Buffer->Play(0, 0, dwFlags);
  471. if(FAILED(rval)) return rval;
  473. return DS_OK;
  474. }
  476. HRESULT CSBuffer::Stop(VOID)
  477. {
  478. HRESULT rval;
  480. if( m_pDS==NULL || m_lpDSB==NULL ) return DSERR_UNINITIALIZED;
  482. for(int i=0; i<m_nBuffers; i++)
  483. {
  484. if( m_lpDSB[i] )
  485. {
  486. rval=m_lpDSB[i]->Stop();
  487. if( rval!=DS_OK ) return rval;
  489. rval=m_lpDSB[i]->SetCurrentPosition(0);
  490. if( rval!=DS_OK ) return rval;
  491. }
  492. }
  493. return DS_OK;
  494. }
  496. HRESULT CSBuffer::Stop(INT nBufferIdx)
  497. {
  498. HRESULT rval;
  500. if( m_pDS==NULL || m_lpDSB==NULL ) return DSERR_UNINITIALIZED;
  502. if( m_lpDSB[nBufferIdx] )
  503. {
  504. rval=m_lpDSB[nBufferIdx]->Stop();
  505. if( rval!=DS_OK ) return rval;
  507. rval=m_lpDSB[nBufferIdx]->SetCurrentPosition(0);
  508. if( rval!=DS_OK ) return rval;
  509. }
  510. return DS_OK;
  511. }
  513. void CSBuffer::SetVolume(LONG Volume)
  514. {
  515. if(m_lpDSB!=NULL)
  516. {
  517. for(int i=0; i<m_nBuffers; i++)
  518. if( m_lpDSB[i] )
  519. m_lpDSB[i]->SetVolume(Volume);
  520. }
  521. }
  523. void CSBuffer::SetVolume(INT nBufferIdx,LONG Volume)
  524. {
  525. if(m_lpDSB!=NULL)
  526. {
  527. if( m_lpDSB[nBufferIdx] )
  528. m_lpDSB[nBufferIdx]->SetVolume(Volume);
  529. }
  530. }
  533. void CSBuffer::SetPan(LONG Pan)
  534. {
  535. if(m_lpDSB!=NULL)
  536. {
  537. for(int i=0; i<m_nBuffers; i++)
  538. if(m_lpDSB[i])
  539. m_lpDSB[i]->SetPan(Pan);
  540. }
  541. }
  543. void CSBuffer::SetPan(INT nBufferIdx,LONG Pan)
  544. {
  545. if(m_lpDSB!=NULL)
  546. {
  547. if(m_lpDSB[nBufferIdx])
  548. m_lpDSB[nBufferIdx]->SetPan(Pan);
  549. }
  550. }
  552. // Play 登绊 乐绰 百荐甫 备茄促.
  553. DWORD CSBuffer::Playing(VOID)
  554. {
  555. DWORD ctr=0, Status;
  556. if(m_lpDSB)
  557. for( int i=0; i<m_nBuffers; i++ )
  558. if(m_lpDSB[i])
  559. if( SUCCEEDED( m_lpDSB[i]->GetStatus(&Status) ) )
  560. if( Status & DSBSTATUS_PLAYING )
  561. ctr++;
  563. return ctr;
  564. }
  566. HRESULT CSBuffer::SetCone( float x, float y, float z, DWORD InsideAngle, DWORD OutsideAngle, long OutsideVolume )
  567. {
  568. HRESULT rval;
  569. if(m_pDS==NULL) return DSERR_UNINITIALIZED;
  570. if(m_lp3dBuffer==NULL) return DSERR_UNINITIALIZED;
  571. if(m_pDS->Get3dListener()==NULL) return DSERR_UNINITIALIZED;
  573. for( int i=0; i<m_nBuffers; i++ )
  574. {
  575. if(m_lp3dBuffer[i])
  576. {
  577. rval=m_lp3dBuffer[i]->SetConeOrientation( x, y, z, DS3D_DEFERRED );
  578. if(FAILED(rval)) return rval;
  580. rval=m_lp3dBuffer[i]->SetConeAngles( InsideAngle, OutsideAngle, DS3D_DEFERRED );
  581. if(FAILED(rval)) return rval;
  583. rval=m_lp3dBuffer[i]->SetConeOutsideVolume( OutsideVolume, DS3D_DEFERRED );
  584. if(FAILED(rval)) return rval;
  585. }
  586. }
  588. rval=m_pDS->Get3dListener()->CommitDeferredSettings();
  589. return rval;
  590. }
  593. HRESULT CSBuffer::Set3dProperties( DWORD Mode, float MinDistance, float MaxDistance, float VelX, float VelY, float VelZ )
  594. {
  595. HRESULT rval;
  596. if(m_pDS==NULL) return DSERR_UNINITIALIZED;
  597. if(m_lp3dBuffer==NULL) return DSERR_UNINITIALIZED;
  598. if(m_pDS->Get3dListener()==NULL) return DSERR_UNINITIALIZED;
  600. for( int i=0; i<m_nBuffers; i++ )
  601. {
  602. if(m_lp3dBuffer[i])
  603. {
  604. rval=m_lp3dBuffer[i]->SetMode( Mode, DS3D_DEFERRED );
  605. if(FAILED(rval)) return rval;
  607. rval=m_lp3dBuffer[i]->SetMinDistance( MinDistance, DS3D_DEFERRED );
  608. if(FAILED(rval)) return rval;
  610. rval=m_lp3dBuffer[i]->SetMaxDistance( MaxDistance, DS3D_DEFERRED );
  611. if(FAILED(rval)) return rval;
  613. rval=m_lp3dBuffer[i]->SetVelocity( VelX, VelY, VelZ, DS3D_DEFERRED );
  614. if(FAILED(rval)) return rval;
  615. }
  616. }
  617. rval=m_pDS->Get3dListener()->CommitDeferredSettings();
  618. return rval;
  619. }
  622. HRESULT CSBuffer::FillStreamBuffer(int nr)
  623. {
  624. LPVOID pData;
  625. DWORD  dwDataSize;
  626. HRESULT rval;
  627. DWORD numread;
  629. if(!m_Streamed) return DSERR_UNINITIALIZED;
  630. if(m_lpDSB==NULL) return DSERR_UNINITIALIZED;
  631. if(m_sFile==NULL) return DSERR_UNINITIALIZED;
  633. rval = m_lpDSB[0]->Lock(nr*m_sSize, m_sSize, &pData, &dwDataSize, 0, 0, 0);
  634. if(FAILED(rval)) return rval;
  637. numread=fread( pData, 1, dwDataSize, m_sFile );
  639. if( numread<dwDataSize )
  640. {
  641. if(m_sLoop)
  642. {
  643. fseek( m_sFile, -(long)m_sWaveLength, SEEK_CUR );
  644. fread( (char*)pData+numread, 1, dwDataSize-numread, m_sFile );
  645. }
  646. else
  647. {
  648. BYTE fill=128;
  649. if( numread>0 ) fill=*((BYTE*)pData+numread-1);
  650. FillMemory( (BYTE*)pData+numread, dwDataSize-numread, fill );
  652. if( m_sDone==255 )
  653. {
  654. m_sDone=nr;
  655. m_sStop=FALSE;
  656. }
  657. }
  658. }
  659. m_lpDSB[0]->Unlock(pData,dwDataSize,0,0);
  660. return DS_OK;
  661. }
  663. HRESULT CSBuffer::UpdateStream( BOOL FillAll )
  664. {
  665. HRESULT rval;
  666. if(!m_Streamed) return DSERR_UNINITIALIZED;
  667. if(m_lpDSB==NULL) return DSERR_UNINITIALIZED;
  669. DWORD pos;
  670. rval=m_lpDSB[0]->GetCurrentPosition( NULL, &pos );
  671. if(FAILED(rval)) return rval;
  672. pos/=m_sSize;
  674. if( m_sDone<255 )
  675. {
  676. if( m_sDone!=pos )
  677. {
  678. if( m_sStop )
  679. {
  680. Stop();
  681. return 1;
  682. }
  683. }
  684. else m_sStop=TRUE;
  685. }
  687. do
  688. {
  689. if(pos!=m_sCurrent)
  690. {
  691. rval=FillStreamBuffer(m_sCurrent);
  692. if(FAILED(rval)) return rval;
  694. char str[255];
  695. sprintf( str, "PlayPos:%itFillPos:%itEndPos:%in", pos, m_sCurrent, m_sDone );
  696. OutputDebugString( str );
  698. m_sCurrent++;
  699. if( m_sCurrent>=m_sBlocks ) m_sCurrent=0;
  700. }
  701. }
  702. while( FillAll && pos!=m_sCurrent );
  704. return DS_OK;
  705. }
  707. DWORD CSBuffer::GetLastUsedTime(VOID)
  708. {
  709. return  m_dwLastUseTime;
  710. }
  712. VOID CSBuffer::Pause(INT nBufferIdx)
  713. {
  714. if(m_lpDSB[nBufferIdx])
  715. m_lpDSB[nBufferIdx]->Stop();
  716. }
  718. VOID CSBuffer::Continue(INT nBufferIdx)
  719. {
  720. if(m_lpDSB[nBufferIdx])
  721. m_lpDSB[nBufferIdx]->Play(0, 0, 0);
  722. }