static int LoopBlank(void)
{
void *mema=NULL,*memb=NULL;
DWORD sizea=0,sizeb=0;
LoopBuffer->Lock(0, LoopLen, &mema,&sizea, &memb,&sizeb, 0);
if (mema) memset(mema,0,sizea);
LoopBuffer->Unlock(mema,sizea, memb,sizeb);
return 0;
}
HRESULT CMpcAudioRenderer::CreateDSBuffer()
{
if (! m_pWaveFileFormat) {
return E_POINTER;
}
HRESULT hr = S_OK;
LPDIRECTSOUNDBUFFER pDSBPrimary = NULL;
DSBUFFERDESC dsbd;
DSBUFFERDESC cDSBufferDesc;
DSBCAPS bufferCaps;
DWORD dwDSBufSize = m_pWaveFileFormat->nAvgBytesPerSec * 4;
ZeroMemory(&bufferCaps, sizeof(bufferCaps));
ZeroMemory(&dsbd, sizeof(DSBUFFERDESC));
dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
dsbd.dwBufferBytes = 0;
dsbd.lpwfxFormat = NULL;
if (SUCCEEDED(hr = m_pDS->CreateSoundBuffer(&dsbd, &pDSBPrimary, NULL))) {
hr = pDSBPrimary->SetFormat(m_pWaveFileFormat);
_ASSERTE(SUCCEEDED(hr));
SAFE_RELEASE(pDSBPrimary);
}
SAFE_RELEASE(m_pDSBuffer);
cDSBufferDesc.dwSize = sizeof(DSBUFFERDESC);
cDSBufferDesc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2 |
DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
cDSBufferDesc.dwBufferBytes = dwDSBufSize;
cDSBufferDesc.dwReserved = 0;
cDSBufferDesc.lpwfxFormat = m_pWaveFileFormat;
cDSBufferDesc.guid3DAlgorithm = GUID_NULL;
hr = m_pDS->CreateSoundBuffer(&cDSBufferDesc, &m_pDSBuffer, NULL);
m_nDSBufSize = 0;
if (SUCCEEDED(hr)) {
bufferCaps.dwSize = sizeof(bufferCaps);
hr = m_pDSBuffer->GetCaps(&bufferCaps);
}
if (SUCCEEDED(hr)) {
m_nDSBufSize = bufferCaps.dwBufferBytes;
hr = ClearBuffer();
m_pDSBuffer->SetFrequency((long)(m_pWaveFileFormat->nSamplesPerSec * m_dRate));
}
return hr;
}
/*------------------------------------------------------------------------
*
* PROTOTYPE : int StreamPoll(void)
*
* DESCRIPTION : Poller to the stream. If return -1, StreamLoad must be called.
*
*/
int StreamPoll(V3XA_STREAM handle)
{
DS_stream *pHandle = g_pDSStreams + handle;
DWORD lPlay=0;
DWORD lWrite=0;
int ret=-1;
LPDIRECTSOUNDBUFFER pDS = g_pDSHandles[pHandle->channel].pbuffer;
if (!pDS)
return ret;
if ((pHandle->nState&1)==0)
return -1;
if (pHandle->m_nStreamState)
{
ret = 1;
}
else
{
// Polled streaming
int32_t elapsed;
ULONG lpStatus;
if (pDS->GetStatus(&lpStatus)==DS_OK)
{
if ((lpStatus & DSBSTATUS_PLAYING)==0)
{
SYS_DXTRACE(pDS->Play(0, 0, DSBPLAY_LOOPING));
}
}
SYS_DXTRACE(pDS->GetCurrentPosition(&lWrite, &lPlay));
elapsed = (pHandle->m_nPreviousPosition<=(int32_t)lPlay)
? lPlay - pHandle->m_nPreviousPosition
: (lPlay + (int32_t)pHandle->sample.length) - pHandle->m_nPreviousPosition;
pHandle->m_nWriteBytes+=elapsed;
pHandle->m_nTotalBytes+=elapsed;
pHandle->m_nPreviousPosition = lPlay;
if ((pHandle->m_nWriteBytes+elapsed>=pHandle->m_nUploadedBytes)
&&(pHandle->m_nUploadedBytes))
{
pHandle->m_nWriteBytes-=pHandle->m_nUploadedBytes;
pHandle->m_nUploadedBytes = 0;
ret = 1;
}
}
return ret;
}
static void pcmdestroy(void) {
UINT i;
LPDIRECTSOUNDBUFFER dsbuf;
for (i=0; i<SOUND_MAXPCM; i++) {
dsbuf = pDSwave3[i];
pDSwave3[i] = NULL;
if (dsbuf) {
dsbuf->Stop();
dsbuf->Release();
}
}
}
//获得3D收听对象
HRESULT get3DListener(LPDIRECTSOUND8 lpds, LPDIRECTSOUND3DBUFFER8* ppListener){
DSBUFFERDESC dsbd;
LPDIRECTSOUNDBUFFER lpdsbPrimary;
LPDIRECTSOUND3DLISTENER lp3DListener = NULL;
HRESULT hr;
ZeroMemory(&dsbd, sizeof(DSBUFFERDESC));
dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = DSBCAPS_CTRL3D | DSBCAPS_PRIMARYBUFFER;
if (SUCCEEDED(hr = lpds->CreateSoundBuffer(&dsbd, &lpdsbPrimary, NULL))){
hr = lpdsbPrimary->QueryInterface(IID_IDirectSound3DListener8, (LPVOID*)ppListener);
lpdsbPrimary->Release();
}
return hr;
}
BRESULT soundmng_pcmplay(UINT num, BOOL loop) {
LPDIRECTSOUNDBUFFER dsbuf;
if ((!mute) && (num < SOUND_MAXPCM)) {
dsbuf = pDSwave3[num];
if (dsbuf) {
// dsbuf->SetCurrentPosition(0);
dsbuf->Play(0, 0, (loop)?DSBPLAY_LOOPING:0);
return(SUCCESS);
}
}
return(FAILURE);
}
// ////////////////////////////////////////////////////////////////////
//
// ////////////////////////////////////////////////////////////////////
F32 DirectSound8AudioBuffer::VGetProgress()
{
LPDIRECTSOUNDBUFFER pDSB = static_cast<LPDIRECTSOUNDBUFFER>(VGet());
if(!pDSB) {
GF_LOG_TRACE_ERR("DirectSound8AudioBuffer::VGetProgress()", "Failed to cast the buffer to a DirectSound buffer");
return (false);
}
DWORD progress = 0;
pDSB->GetCurrentPosition(&progress, NULL);
F32 length = static_cast<F32>(m_Resource->GetPCMBufferSize());
return (static_cast<F32>(progress) / length);
}
void soundmng_destroy(void) {
if (pDSData3) {
#if defined(VERMOUTH_LIB)
midimod_destroy(vermouth_module);
vermouth_module = NULL;
#endif
#if defined(MT32SOUND_DLL)
mt32sound_setrate(0);
#endif
pDSData3->Stop();
pDSData3->Release();
pDSData3 = NULL;
}
}
void SNDDXClearAudioBuffer()
{
// we shouldn't need to provide 2 buffers since it's 1 contiguous range
// but maybe newer directsound implementations have issues
LPVOID buffer1;
LPVOID buffer2;
DWORD buffer1_size, buffer2_size;
HRESULT hr = lpDSB2->Lock(0, 0, &buffer1, &buffer1_size, &buffer2, &buffer2_size, DSBLOCK_ENTIREBUFFER);
if(FAILED(hr))
return;
memset(buffer1, 0, buffer1_size);
if(buffer2)
memset(buffer2, 0, buffer2_size);
lpDSB2->Unlock(buffer1, buffer1_size, buffer2, buffer2_size);
}
/*-----------------------------------------------------------------------------
[Play]
-----------------------------------------------------------------------------*/
void
AOUT_Play(
BOOL bPlay)
{
if (!_bAudioInit)
return;
_bPlay = bPlay;
if (_bPlay)
{
_pDSB1->Play(0, 0, DSBPLAY_LOOPING);
_pDSB2->Play(0, 0, DSBPLAY_LOOPING);
_pDSB3->Play(0, 0, DSBPLAY_LOOPING);
}
}
/*
===============
idAudioBufferWIN32::RestoreBuffer
Desc: Restores the lost buffer. *pbWasRestored returns true if the buffer was
restored. It can also NULL if the information is not needed.
===============
*/
int idAudioBufferWIN32::RestoreBuffer( LPDIRECTSOUNDBUFFER pDSB, bool* pbWasRestored )
{
int hr;
if( pDSB == NULL )
{
return -1;
}
if( pbWasRestored )
{
*pbWasRestored = false;
}
ulong dwStatus;
if( FAILED( hr = pDSB->GetStatus( &dwStatus ) ) )
{
return DXTRACE_ERR( TEXT("GetStatus"), hr );
}
if( dwStatus & DSBSTATUS_BUFFERLOST )
{
// Since the app could have just been activated, then
// DirectSound may not be giving us control yet, so
// the restoring the buffer may fail.
// If it does, sleep until DirectSound gives us control.
do
{
hr = pDSB->Restore();
if( hr == DSERR_BUFFERLOST )
{
Sleep( 10 );
}
hr = pDSB->Restore();
}
while( hr );
if( pbWasRestored != NULL )
{
*pbWasRestored = true;
}
return S_OK;
}
else
{
return S_FALSE;
}
}
// WriteSilence
//
// Writes silence to sound buffer. This is a helper method used by
// ServiceBuffer; it's not exposed to users of the AudioStream class.
BOOL AudioStream::WriteSilence(UINT size)
{
HRESULT hr;
LPBYTE lpbuf1 = NULL;
LPBYTE lpbuf2 = NULL;
DWORD dwsize1 = 0;
DWORD dwsize2 = 0;
DWORD dwbyteswritten1 = 0;
DWORD dwbyteswritten2 = 0;
BOOL fRtn = SUCCESS;
// Lock the sound buffer
hr = m_pdsb->Lock(m_cbBufOffset, size, (void**)(&lpbuf1), &dwsize1, (void**)(&lpbuf2), &dwsize2, 0);
if (hr == DS_OK)
{
// Get silence data for this file format. Although word sizes vary for different
// wave file formats, ::Lock will always return pointers on word boundaries.
// Because silence data for 16-bit PCM formats is 0x0000 or 0x00000000, we can
// get away with writing bytes and ignoring word size here.
BYTE bSilence = m_pwavefile->GetSilenceData();
// Write silence to sound buffer. Because the sound buffer is circular, we may have to
// do two write operations if locked portion of buffer wraps around to start of buffer.
memset(lpbuf1, bSilence, dwsize1);
dwbyteswritten1 = dwsize1;
// Second write required?
if (lpbuf2)
{
memset(lpbuf2, bSilence, dwsize2);
dwbyteswritten2 = dwsize2;
}
// Update our buffer offset and unlock sound buffer
m_cbBufOffset = (m_cbBufOffset + dwbyteswritten1 + dwbyteswritten2) % m_cbBufSize;
// m_pdsb->Unlock (lpbuf1, dwbyteswritten1, lpbuf2, dwbyteswritten2);
m_pdsb->Unlock(lpbuf1, dwsize1, lpbuf2, dwsize2);
}
else
{
// Error locking sound buffer
nprintf(("SOUND", "SOUND ==> Error, unable to lock sound buffer in AudioStr\n"));
fRtn = FAILURE;
}
return (fRtn);
}
/*
==============
SNDDMA_GetDMAPos
return the current sample position (in mono samples read)
inside the recirculating dma buffer, so the mixing code will know
how many sample are required to fill it up.
===============
*/
int SNDDMA_GetDMAPos(void)
{
MMTIME mmtime;
int s = 0;
DWORD dwWrite;
if (dsound_init)
{
mmtime.wType = TIME_SAMPLES;
//if (!s_primary->value)
#ifdef QDSNDCOMPILERHACK
pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &mmtime.u.sample, &dwWrite);
#else
pDSBuf->GetCurrentPosition(&mmtime.u.sample, &dwWrite);
#endif
//else
// pDSPBuf->lpVtbl->GetCurrentPosition(pDSPBuf, &mmtime.u.sample, &dwWrite);
s = mmtime.u.sample - mmstarttime.u.sample;
}
else if (wav_init)
{
s = snd_sent * WAV_BUFFER_SIZE;
}
s >>= sample16;
s &= (dma.samples-1);
return s;
}
// Cue
void AudioStream::Cue (void)
{
UINT num_bytes_written;
if (!m_fCued) {
m_bFade = FALSE;
m_fade_timer_id = 0;
m_finished_id = 0;
m_bPastLimit = FALSE;
m_lVolume = 0;
m_lCutoffVolume = -10000;
m_bDestroy_when_faded = FALSE;
// Reset buffer ptr
m_cbBufOffset = 0;
// Reset file ptr, etc
m_pwavefile->Cue ();
// Reset DirectSound buffer
m_pdsb->SetCurrentPosition (0);
// Fill buffer with wave data
WriteWaveData (m_cbBufSize, &num_bytes_written,0);
m_fCued = TRUE;
}
}
//--------------------------------------------------------------------
//Function: Initialize
//Parameters: lpDSB - DirectSoundBuffer
// bLoadDefaultParamValues - Load default parameters or not
//Description: Associates a DirectSoundBuffer with the manager
// Any effects enabled in the old DirectSoundBuffer will
// Be disabled and the effect objects released
//--------------------------------------------------------------------
HRESULT CSoundFXManager::Initialize(LPDIRECTSOUNDBUFFER lpDSB, BOOL bLoadDefaultParamValues)
{
HRESULT hr;
if(m_lpDSB8)
{
// Release the effect for the previously associated sound buffers
DisableAllFX();
SAFE_RELEASE(m_lpDSB8);
}
if(NULL == lpDSB)
{
return S_OK;
}
// Get the interface
if(FAILED(hr = lpDSB->QueryInterface(IID_IDirectSoundBuffer8, (LPVOID*) &m_lpDSB8)))
{
return hr;
}
if(bLoadDefaultParamValues)
{
LoadDefaultParamValues();
}
return S_OK;
}
// Destroy
BOOL AudioStream::Destroy (void)
{
BOOL fRtn = SUCCESS;
EnterCriticalSection(&write_lock);
// Stop playback
Stop ();
// Release DirectSound buffer
if (m_pdsb) {
m_pdsb->Release ();
m_pdsb = NULL;
Snd_sram -= m_cbBufSize;
}
// Delete WaveFile object
if (m_pwavefile) {
m_pwavefile->Close();
free(m_pwavefile);
m_pwavefile = NULL;
}
status = ASF_FREE;
LeaveCriticalSection(&write_lock);
return fRtn;
}
// Destroy
BOOL AudioStream::Destroy(void)
{
BOOL fRtn = SUCCESS;
ENTER_CRITICAL_SECTION(write_lock);
// Stop playback
Stop();
// Release DirectSound buffer
if (m_pdsb)
{
m_pdsb->Release();
m_pdsb = NULL;
Snd_sram -= m_cbBufSize;
}
// Delete WaveFile object
if (m_pwavefile)
{
m_pwavefile->Close();
vm_free(m_pwavefile);
m_pwavefile = NULL;
}
status = ASF_FREE;
LEAVE_CRITICAL_SECTION(write_lock);
return fRtn;
}
/*
===============
idAudioBufferWIN32::SetVolume
===============
*/
void idAudioBufferWIN32::SetVolume( float x)
{
if (m_apDSBuffer)
{
m_apDSBuffer->SetVolume(x);
}
}
// *******************************************************************************************************************
bool cDirectSoundAudioBuffer::VPlay()
{
VStop();
LPDIRECTSOUNDBUFFER pDSBuffer = GetSoundBuffer();
if (pDSBuffer == NULL)
{
return false;
}
if (S_OK == pDSBuffer->Play(0, 0, 0))
{
m_Paused = false;
}
return m_Paused;
}
// GetMaxWriteSize
//
// Helper function to calculate max size of sound buffer write operation, i.e. how much
// free space there is in buffer.
DWORD AudioStream::GetMaxWriteSize (void)
{
DWORD dwWriteCursor, dwPlayCursor, dwMaxSize;
// Get current play position
if (m_pdsb->GetCurrentPosition (&dwPlayCursor, &dwWriteCursor) == DS_OK) {
if (m_cbBufOffset <= dwPlayCursor) {
// Our write position trails play cursor
dwMaxSize = dwPlayCursor - m_cbBufOffset;
}
else {// (m_cbBufOffset > dw7Cursor)
// Play cursor has wrapped
dwMaxSize = m_cbBufSize - m_cbBufOffset + dwPlayCursor;
}
}
else {
// GetCurrentPosition call failed
Int3();
dwMaxSize = 0;
}
// nprintf(("Alan","Max write size: %d\n", dwMaxSize));
return (dwMaxSize);
}
/*
===============
idAudioBufferWIN32::Play
Desc: Plays the sound using voice management flags. Pass in DSBPLAY_LOOPING
in the dwFlags to loop the sound
===============
*/
int idAudioBufferWIN32::Play(dword dwPriority, dword dwFlags)
{
int hr;
bool bRestored;
if (m_apDSBuffer == NULL) {
return -1;
}
// Restore the buffer if it was lost
if (FAILED(hr = RestoreBuffer(m_apDSBuffer, &bRestored))) {
common->Error(TEXT("RestoreBuffer"), hr);
}
if (bRestored) {
// The buffer was restored, so we need to fill it with new data
if (FAILED(hr = FillBufferWithSound(m_apDSBuffer, false))) {
common->Error(TEXT("FillBufferWithSound"), hr);
}
// Make DirectSound do pre-processing on sound effects
Reset();
}
m_apDSBuffer->Play(0, dwPriority, dwFlags);
return 0;
}
/**
* @brief Helper routine, gets the device capabilities.
* @param[in] lpdsb pointer to the direct sound buffer, either primary or secondary.
* @return returns 1 if succeeded, any other value indicates an error.
* @sa http://bit.ly/zP10oa
*/
int get_buffer_caps(const char * prefix, LPDIRECTSOUNDBUFFER lpdsb)
{
DSBCAPS caps;
HRESULT hr;
ZeroMemory(&caps, sizeof(DSBCAPS));
caps.dwSize = sizeof(DSBCAPS);
hr = lpdsb->GetCaps(&caps);
if (SUCCEEDED(hr))
{
size_t index;
debug_outputln("%4.4u %20s : 0x%8.8x %8u %8u %8u"
,__LINE__
,prefix
,caps.dwFlags
,caps.dwBufferBytes
,caps.dwUnlockTransferRate
,caps.dwPlayCpuOverhead
);
for (index = 0; index <sizeof(flags_to_descs)/sizeof(flags_to_descs[0]); ++index)
{
if (caps.dwFlags & flags_to_descs[index].flag_)
debug_outputln("%s %4.4u : %s"
,__FILE__, __LINE__
,flags_to_descs[index].desc_);
}
}
else
{
debug_outputln("%s %4.4u : %8.8x", __FILE__, __LINE__, hr);
}
return SUCCEEDED(hr);
}
BOOL ClSoundDS::CreateDummyBuffer()
{
WAVEFORMATEX dstWF;
LPBYTE lpBlockAdd1, lpBlockAdd2;
DWORD blockSize1, blockSize2;
dstWF.wFormatTag = WAVE_FORMAT_PCM;
dstWF.nChannels = 1;
dstWF.nSamplesPerSec = 44100;
dstWF.nBlockAlign = 2;
dstWF.nAvgBytesPerSec = 88200;
dstWF.wBitsPerSample = 16;
dstWF.cbSize = 0;
DSBUFFERDESC dsbdesc;
ZeroMemory(&dsbdesc, sizeof(DSBUFFERDESC));
dsbdesc.dwSize = sizeof(DSBUFFERDESC);
dsbdesc.dwFlags = DSBCAPS_STATIC | DSBCAPS_CTRLVOLUME | DSBCAPS_LOCSOFTWARE | DSBCAPS_GLOBALFOCUS;
dsbdesc.dwBufferBytes = dstWF.nAvgBytesPerSec /2;
dsbdesc.lpwfxFormat = &dstWF;
HRESULT hr = lpDSound->CreateSoundBuffer(&dsbdesc, &lpTmpBuffer, NULL);
if(hr==DS_OK){
lpTmpBuffer->QueryInterface(IID_IDirectSoundBuffer8,(LPVOID *)&lpDummyBuffer);
RELEASE(lpTmpBuffer);
lpDummyBuffer->SetVolume(DSBVOLUME_MIN);
lpDummyBuffer->Lock(0,dsbdesc.dwBufferBytes, (LPVOID*)&lpBlockAdd1, &blockSize1,(LPVOID*)&lpBlockAdd2, &blockSize2, 0);
ZeroMemory(lpBlockAdd1,blockSize1);
if(blockSize2) ZeroMemory(lpBlockAdd2,blockSize2);
lpDummyBuffer->Unlock(lpBlockAdd1, blockSize1, lpBlockAdd2, blockSize2);
lpDummyBuffer->Play(0,0,DSBPLAY_LOOPING);
}
return TRUE;
} // ClSoundDS::CreateDummyBuffer
/*
==================
SNDDMA_Shutdown
==================
*/
void SNDDMA_Shutdown( void ) {
Com_DPrintf( "Shutting down sound system\n" );
if ( pDS ) {
Com_DPrintf( "Destroying DS buffers\n" );
if ( pDS )
{
Com_DPrintf( "...setting NORMAL coop level\n" );
// FIXME JA was DSSCL_NORMAL and Q3 says DSSCL_PRIORITY but the printf says setting normal
pDS->SetCooperativeLevel( g_wv.hWnd, DSSCL_PRIORITY );
}
if ( pDSBuf )
{
Com_DPrintf( "...stopping and releasing sound buffer\n" );
pDSBuf->Stop( );
pDSBuf->Release( );
}
// only release primary buffer if it's not also the mixing buffer we just released
if ( pDSPBuf && ( pDSBuf != pDSPBuf ) )
{
Com_DPrintf( "...releasing primary buffer\n" );
pDSPBuf->Release( );
}
pDSBuf = NULL;
pDSPBuf = NULL;
dma.buffer = NULL;
Com_DPrintf( "...releasing DS object\n" );
pDS->Release( );
}
if ( hInstDS ) {
Com_DPrintf( "...freeing DSOUND.DLL\n" );
FreeLibrary( hInstDS );
hInstDS = NULL;
}
pDS = NULL;
pDSBuf = NULL;
pDSPBuf = NULL;
dsound_init = qfalse;
memset ((void *)&dma, 0, sizeof (dma));
CoUninitialize( );
}
// ////////////////////////////////////////////////////////////////////
//
// ////////////////////////////////////////////////////////////////////
HRESULT DirectSound8Audio::SetPrimaryBufferFormat(
DWORD dwPrimaryChannels,
DWORD dwPrimaryFreq,
DWORD dwPrimaryBitRate)
{
// !WARNING! - Setting the primary buffer format and then using this
// it for DirectMusic messes up DirectMusic!
//
// If you want your primary buffer format to be 22kHz stereo, 16-bit
// call with these parameters: SetPrimaryBufferFormat(2, 22050, 16);
HRESULT hr;
LPDIRECTSOUNDBUFFER pDSBPrimary = NULL;
if(m_pDS == NULL) {
return (CO_E_NOTINITIALIZED);
}
// Get the primary buffer
DSBUFFERDESC dsbd;
ZeroMemory(&dsbd, sizeof(DSBUFFERDESC));
dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
dsbd.dwBufferBytes = 0;
dsbd.lpwfxFormat = NULL;
if(FAILED(hr = m_pDS->CreateSoundBuffer(&dsbd, &pDSBPrimary, NULL))) {
return (DXUT_ERR(L"CreateSoundBuffer", hr));
}
WAVEFORMATEX wfx;
ZeroMemory(&wfx, sizeof(WAVEFORMATEX));
wfx.wFormatTag = (WORD) WAVE_FORMAT_PCM;
wfx.nChannels = (WORD) dwPrimaryChannels;
wfx.nSamplesPerSec = (DWORD) dwPrimaryFreq;
wfx.wBitsPerSample = (WORD) dwPrimaryBitRate;
wfx.nBlockAlign = (WORD)(wfx.wBitsPerSample / 8 * wfx.nChannels);
wfx.nAvgBytesPerSec = (DWORD)(wfx.nSamplesPerSec * wfx.nBlockAlign);
if(FAILED(hr = pDSBPrimary->SetFormat(&wfx))) {
return (DXUT_ERR(L"SetFormat", hr));
}
Release(pDSBPrimary);
return (S_OK);
}
//-----------------------------------------------------------------------------
// Name: DSUtil_PlaySound()
// Desc:
//-----------------------------------------------------------------------------
HRESULT DSUtil_PlaySound( SoundObject* pSound, DWORD dwPlayFlags )
{
if( NULL == pSound )
return E_FAIL;
if( !(dwPlayFlags & DSBPLAY_LOOPING) || (pSound->dwNumBuffers == 1) )
{
LPDIRECTSOUNDBUFFER pDSB = DSUtil_GetFreeSoundBuffer( pSound );
if( pDSB )
{
if( SUCCEEDED( pDSB->Play( 0, 0, dwPlayFlags ) ) )
return S_OK;
}
}
return E_FAIL;
}
void CloseSound()
{
if (lpds)
{
if (lpdsbPrimary)
{
lpdsbPrimary->Stop();
lpdsbPrimary->Release();
lpdsbPrimary = NULL;
}
lpds->Release();
lpds = NULL;
}
return;
}
HRESULT STDMETHODCALLTYPE DirectSound::CreateSoundBuffer(LPCDSBUFFERDESC pcDSBufferDesc, LPDIRECTSOUNDBUFFER *ppDSBuffer, LPUNKNOWN pUnkOuter)
{
LPDIRECTSOUNDBUFFER localBuffer;
HRESULT hr = m_ds->CreateSoundBuffer(pcDSBufferDesc, &localBuffer, pUnkOuter);
if (FAILED(hr))
{
return hr;
}
(*ppDSBuffer) = createWrapper(localBuffer);
if (!*ppDSBuffer)
{
localBuffer->Release();
return DSERR_OUTOFMEMORY;
}
return hr;
}
//===========================================================================
// DS_Refresh
//===========================================================================
void DS_Refresh(sfxbuffer_t *buf)
{
LPDIRECTSOUNDBUFFER sound = DSBuf(buf);
DWORD status;
if(sound)
{
// Has the buffer finished playing?
sound->GetStatus(&status);
if(!(status & DSBSTATUS_PLAYING)
&& buf->flags & SFXBF_PLAYING)
{
// It has stopped playing.
buf->flags &= ~SFXBF_PLAYING;
}
}
}
/*
==============
SNDDMA_BeginPainting
Makes sure dma.buffer is valid
===============
*/
void SNDDMA_BeginPainting( void ) {
int reps;
DWORD dwSize2;
DWORD *pbuf, *pbuf2;
HRESULT hresult;
DWORD dwStatus;
if ( !pDSBuf ) {
return;
}
// if the buffer was lost or stopped, restore it and/or restart it
if ( pDSBuf->GetStatus (&dwStatus) != DS_OK ) {
Com_Printf ("Couldn't get sound buffer status\n");
}
if (dwStatus & DSBSTATUS_BUFFERLOST)
pDSBuf->Restore ();
if (!(dwStatus & DSBSTATUS_PLAYING))
pDSBuf->Play(0, 0, DSBPLAY_LOOPING);
// lock the dsound buffer
reps = 0;
dma.buffer = NULL;
while ((hresult = pDSBuf->Lock(0, gSndBufSize, (void **)&pbuf, &locksize,
(void **)&pbuf2, &dwSize2, 0)) != DS_OK)
{
if (hresult != DSERR_BUFFERLOST)
{
Com_Printf( "SNDDMA_BeginPainting: Lock failed with error '%s'\n", DSoundError( hresult ) );
S_Shutdown ();
return;
}
else
{
pDSBuf->Restore( );
}
if (++reps > 2)
return;
}
dma.buffer = (unsigned char *)pbuf;
}
