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; }