diff options
Diffstat (limited to 'engine/audio/private/snd_dev_direct.cpp')
| -rw-r--r-- | engine/audio/private/snd_dev_direct.cpp | 2094 |
1 files changed, 2094 insertions, 0 deletions
diff --git a/engine/audio/private/snd_dev_direct.cpp b/engine/audio/private/snd_dev_direct.cpp new file mode 100644 index 0000000..9149964 --- /dev/null +++ b/engine/audio/private/snd_dev_direct.cpp @@ -0,0 +1,2094 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=====================================================================================// + +#include "audio_pch.h" +#include <dsound.h> +#pragma warning(disable : 4201) // nameless struct/union +#include <ks.h> +// Fix for VS 2010 build errors copied from Dota +#if !defined( NEW_DXSDK ) && ( _MSC_VER >= 1600 ) +#undef KSDATAFORMAT_SUBTYPE_WAVEFORMATEX +#undef KSDATAFORMAT_SUBTYPE_PCM +#undef KSDATAFORMAT_SUBTYPE_IEEE_FLOAT +#endif +#include <ksmedia.h> +#include "iprediction.h" +#include "eax.h" +#include "tier0/icommandline.h" +#include "video//ivideoservices.h" +#include "../../sys_dll.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +extern bool snd_firsttime; + +extern void DEBUG_StartSoundMeasure(int type, int samplecount ); +extern void DEBUG_StopSoundMeasure(int type, int samplecount ); + +// legacy support +extern ConVar sxroom_off; +extern ConVar sxroom_type; +extern ConVar sxroomwater_type; +extern float sxroom_typeprev; + +extern HWND* pmainwindow; + +typedef enum {SIS_SUCCESS, SIS_FAILURE, SIS_NOTAVAIL} sndinitstat; + +#define SECONDARY_BUFFER_SIZE 0x10000 // output buffer size in bytes +#define SECONDARY_BUFFER_SIZE_SURROUND 0x04000 // output buffer size in bytes, one per channel + +#if !defined( NEW_DXSDK ) +// hack - need to include latest dsound.h +#undef DSSPEAKER_5POINT1 +#undef DSSPEAKER_7POINT1 +#define DSSPEAKER_5POINT1 6 +#define DSSPEAKER_7POINT1 7 +#define DSSPEAKER_7POINT1_SURROUND 8 +#define DSSPEAKER_5POINT1_SURROUND 9 +#endif + +HRESULT (WINAPI *pDirectSoundCreate)(GUID FAR *lpGUID, LPDIRECTSOUND FAR *lplpDS, IUnknown FAR *pUnkOuter); + +extern void ReleaseSurround(void); +extern bool MIX_ScaleChannelVolume( paintbuffer_t *ppaint, channel_t *pChannel, int volume[CCHANVOLUMES], int mixchans ); +void OnSndSurroundCvarChanged( IConVar *var, const char *pOldString, float flOldValue ); +void OnSndSurroundLegacyChanged( IConVar *var, const char *pOldString, float flOldValue ); +void OnSndVarChanged( IConVar *var, const char *pOldString, float flOldValue ); + +static LPDIRECTSOUND pDS = NULL; +static LPDIRECTSOUNDBUFFER pDSBuf = NULL, pDSPBuf = NULL; + +static GUID IID_IDirectSound3DBufferDef = {0x279AFA86, 0x4981, 0x11CE, {0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60}}; +static ConVar windows_speaker_config("windows_speaker_config", "-1", FCVAR_ARCHIVE); +static DWORD g_ForcedSpeakerConfig = 0; + +extern ConVar snd_mute_losefocus; + +//----------------------------------------------------------------------------- +// Purpose: Implementation of direct sound +//----------------------------------------------------------------------------- +class CAudioDirectSound : public CAudioDeviceBase +{ +public: + ~CAudioDirectSound( void ); + bool IsActive( void ) { return true; } + bool Init( void ); + void Shutdown( void ); + void Pause( void ); + void UnPause( void ); + float MixDryVolume( void ); + bool Should3DMix( void ); + void StopAllSounds( void ); + + int PaintBegin( float mixAheadTime, int soundtime, int paintedtime ); + void PaintEnd( void ); + + int GetOutputPosition( void ); + void ClearBuffer( void ); + void UpdateListener( const Vector& position, const Vector& forward, const Vector& right, const Vector& up ); + + void ChannelReset( int entnum, int channelIndex, float distanceMod ); + void TransferSamples( int end ); + + const char *DeviceName( void ); + int DeviceChannels( void ) { return m_deviceChannels; } + int DeviceSampleBits( void ) { return m_deviceSampleBits; } + int DeviceSampleBytes( void ) { return m_deviceSampleBits/8; } + int DeviceDmaSpeed( void ) { return m_deviceDmaSpeed; } + int DeviceSampleCount( void ) { return m_deviceSampleCount; } + + bool IsInterleaved() { return m_isInterleaved; } + + // Singleton object + static CAudioDirectSound *m_pSingleton; + +private: + void DetectWindowsSpeakerSetup(); + bool LockDSBuffer( LPDIRECTSOUNDBUFFER pBuffer, DWORD **pdwWriteBuffer, DWORD *pdwSizeBuffer, const char *pBufferName, int lockFlags = 0 ); + bool IsUsingBufferPerSpeaker(); + + sndinitstat SNDDMA_InitDirect( void ); + bool SNDDMA_InitInterleaved( LPDIRECTSOUND lpDS, WAVEFORMATEX* lpFormat, int channelCount ); + bool SNDDMA_InitSurround(LPDIRECTSOUND lpDS, WAVEFORMATEX* lpFormat, DSBCAPS* lpdsbc, int cchan); + void S_TransferSurround16( portable_samplepair_t *pfront, portable_samplepair_t *prear, portable_samplepair_t *pcenter, int lpaintedtime, int endtime, int cchan); + void S_TransferSurround16Interleaved( const portable_samplepair_t *pfront, const portable_samplepair_t *prear, const portable_samplepair_t *pcenter, int lpaintedtime, int endtime); + void S_TransferSurround16Interleaved_FullLock( const portable_samplepair_t *pfront, const portable_samplepair_t *prear, const portable_samplepair_t *pcenter, int lpaintedtime, int endtime); + + int m_deviceChannels; // channels per hardware output buffer (1 for quad/5.1, 2 for stereo) + int m_deviceSampleBits; // bits per sample (16) + int m_deviceSampleCount; // count of mono samples in output buffer + int m_deviceDmaSpeed; // samples per second per output buffer + int m_bufferSizeBytes; // size of a single hardware output buffer, in bytes + + DWORD m_outputBufferStartOffset; // output buffer playback starting byte offset + HINSTANCE m_hInstDS; + bool m_isInterleaved; +}; + +CAudioDirectSound *CAudioDirectSound::m_pSingleton = NULL; + +LPDIRECTSOUNDBUFFER pDSBufFL = NULL; +LPDIRECTSOUNDBUFFER pDSBufFR = NULL; +LPDIRECTSOUNDBUFFER pDSBufRL = NULL; +LPDIRECTSOUNDBUFFER pDSBufRR = NULL; +LPDIRECTSOUNDBUFFER pDSBufFC = NULL; +LPDIRECTSOUND3DBUFFER pDSBuf3DFL = NULL; +LPDIRECTSOUND3DBUFFER pDSBuf3DFR = NULL; +LPDIRECTSOUND3DBUFFER pDSBuf3DRL = NULL; +LPDIRECTSOUND3DBUFFER pDSBuf3DRR = NULL; +LPDIRECTSOUND3DBUFFER pDSBuf3DFC = NULL; + +// ----------------------------------------------------------------------------- // +// Helpers. +// ----------------------------------------------------------------------------- // + + +CAudioDirectSound::~CAudioDirectSound( void ) +{ + m_pSingleton = NULL; +} + +bool CAudioDirectSound::Init( void ) +{ + m_hInstDS = NULL; + + static bool first = true; + if ( first ) + { + snd_surround.InstallChangeCallback( &OnSndSurroundCvarChanged ); + snd_legacy_surround.InstallChangeCallback( &OnSndSurroundLegacyChanged ); + snd_mute_losefocus.InstallChangeCallback( &OnSndVarChanged ); + first = false; + } + + if ( SNDDMA_InitDirect() == SIS_SUCCESS) + { + if ( g_pVideo != NULL ) + { + g_pVideo->SoundDeviceCommand( VideoSoundDeviceOperation::SET_DIRECT_SOUND_DEVICE, pDS ); + } + + return true; + } + + return false; +} + +void CAudioDirectSound::Shutdown( void ) +{ + ReleaseSurround(); + + if (pDSBuf) + { + pDSBuf->Stop(); + pDSBuf->Release(); + } + + // only release primary buffer if it's not also the mixing buffer we just released + if (pDSPBuf && (pDSBuf != pDSPBuf)) + { + pDSPBuf->Release(); + } + + if (pDS) + { + pDS->SetCooperativeLevel(*pmainwindow, DSSCL_NORMAL); + pDS->Release(); + } + + pDS = NULL; + pDSBuf = NULL; + pDSPBuf = NULL; + + if ( m_hInstDS ) + { + FreeLibrary( m_hInstDS ); + m_hInstDS = NULL; + } + + if ( this == CAudioDirectSound::m_pSingleton ) + { + CAudioDirectSound::m_pSingleton = NULL; + } +} + +// Total number of samples that have played out to hardware +// for current output buffer (ie: from buffer offset start). +// return playback position within output playback buffer: +// the output units are dependant on the device channels +// so the ouput units for a 2 channel device are as 16 bit LR pairs +// and the output unit for a 1 channel device are as 16 bit mono samples. +// take into account the original start position within the buffer, and +// calculate difference between current position (with buffer wrap) and +// start position. +int CAudioDirectSound::GetOutputPosition( void ) +{ + int samp16; + int start, current; + DWORD dwCurrent; + + // get size in bytes of output buffer + const int size_bytes = m_bufferSizeBytes; + if ( IsUsingBufferPerSpeaker() ) + { + // mono output buffers + // get byte offset of playback cursor in Front Left output buffer + pDSBufFL->GetCurrentPosition(&dwCurrent, NULL); + + start = (int) m_outputBufferStartOffset; + current = (int) dwCurrent; + } + else + { + // multi-channel interleavd output buffer + // get byte offset of playback cursor in output buffer + pDSBuf->GetCurrentPosition(&dwCurrent, NULL); + + start = (int) m_outputBufferStartOffset; + current = (int) dwCurrent; + } + + // get 16 bit samples played, relative to buffer starting offset + if (current > start) + { + // get difference & convert to 16 bit mono samples + samp16 = (current - start) >> SAMPLE_16BIT_SHIFT; + } + else + { + // get difference (with buffer wrap) convert to 16 bit mono samples + samp16 = ((size_bytes - start) + current) >> SAMPLE_16BIT_SHIFT; + } + + int outputPosition = samp16 / DeviceChannels(); + + return outputPosition; +} + +void CAudioDirectSound::Pause( void ) +{ + if (pDSBuf) + { + pDSBuf->Stop(); + } + + if ( pDSBufFL ) pDSBufFL->Stop(); + if ( pDSBufFR ) pDSBufFR->Stop(); + if ( pDSBufRL ) pDSBufRL->Stop(); + if ( pDSBufRR ) pDSBufRR->Stop(); + if ( pDSBufFC ) pDSBufFC->Stop(); +} + + +void CAudioDirectSound::UnPause( void ) +{ + if (pDSBuf) + pDSBuf->Play(0, 0, DSBPLAY_LOOPING); + + if (pDSBufFL) pDSBufFL->Play(0, 0, DSBPLAY_LOOPING); + if (pDSBufFR) pDSBufFR->Play(0, 0, DSBPLAY_LOOPING); + if (pDSBufRL) pDSBufRL->Play(0, 0, DSBPLAY_LOOPING); + if (pDSBufRR) pDSBufRR->Play( 0, 0, DSBPLAY_LOOPING); + if (pDSBufFC) pDSBufFC->Play( 0, 0, DSBPLAY_LOOPING); +} + + +float CAudioDirectSound::MixDryVolume( void ) +{ + return 0; +} + + +bool CAudioDirectSound::Should3DMix( void ) +{ + if ( m_bSurround ) + return true; + return false; +} + + +IAudioDevice *Audio_CreateDirectSoundDevice( void ) +{ + if ( !CAudioDirectSound::m_pSingleton ) + CAudioDirectSound::m_pSingleton = new CAudioDirectSound; + + if ( CAudioDirectSound::m_pSingleton->Init() ) + { + if (snd_firsttime) + DevMsg ("DirectSound initialized\n"); + + return CAudioDirectSound::m_pSingleton; + } + + DevMsg ("DirectSound failed to init\n"); + + delete CAudioDirectSound::m_pSingleton; + CAudioDirectSound::m_pSingleton = NULL; + + return NULL; +} + +int CAudioDirectSound::PaintBegin( float mixAheadTime, int soundtime, int lpaintedtime ) +{ + // soundtime - total full samples that have been played out to hardware at dmaspeed + // paintedtime - total full samples that have been mixed at speed + // endtime - target for full samples in mixahead buffer at speed + // samps - size of output buffer in full samples + + int mixaheadtime = mixAheadTime * DeviceDmaSpeed(); + int endtime = soundtime + mixaheadtime; + + if ( endtime <= lpaintedtime ) + return endtime; + + uint nSamples = endtime - lpaintedtime; + if ( nSamples & 0x3 ) + { + // The difference between endtime and painted time should align on + // boundaries of 4 samples. This is important when upsampling from 11khz -> 44khz. + nSamples += (4 - (nSamples & 3)); + } + // clamp to min 512 samples per mix + if ( nSamples > 0 && nSamples < 512 ) + { + nSamples = 512; + } + endtime = lpaintedtime + nSamples; + + int fullsamps = DeviceSampleCount() / DeviceChannels(); + if ( (endtime - soundtime) > fullsamps) + { + endtime = soundtime + fullsamps; + endtime += (4 - (endtime & 3)); + } + + DWORD dwStatus; + + // If using surround, there are 4 or 5 different buffers being used and the pDSBuf is NULL. + if ( IsUsingBufferPerSpeaker() ) + { + if (pDSBufFL->GetStatus(&dwStatus) != DS_OK) + Msg ("Couldn't get SURROUND FL sound buffer status\n"); + + if (dwStatus & DSBSTATUS_BUFFERLOST) + pDSBufFL->Restore(); + + if (!(dwStatus & DSBSTATUS_PLAYING)) + pDSBufFL->Play(0, 0, DSBPLAY_LOOPING); + + if (pDSBufFR->GetStatus(&dwStatus) != DS_OK) + Msg ("Couldn't get SURROUND FR sound buffer status\n"); + + if (dwStatus & DSBSTATUS_BUFFERLOST) + pDSBufFR->Restore(); + + if (!(dwStatus & DSBSTATUS_PLAYING)) + pDSBufFR->Play(0, 0, DSBPLAY_LOOPING); + + if (pDSBufRL->GetStatus(&dwStatus) != DS_OK) + Msg ("Couldn't get SURROUND RL sound buffer status\n"); + + if (dwStatus & DSBSTATUS_BUFFERLOST) + pDSBufRL->Restore(); + + if (!(dwStatus & DSBSTATUS_PLAYING)) + pDSBufRL->Play(0, 0, DSBPLAY_LOOPING); + + if (pDSBufRR->GetStatus(&dwStatus) != DS_OK) + Msg ("Couldn't get SURROUND RR sound buffer status\n"); + + if (dwStatus & DSBSTATUS_BUFFERLOST) + pDSBufRR->Restore(); + + if (!(dwStatus & DSBSTATUS_PLAYING)) + pDSBufRR->Play(0, 0, DSBPLAY_LOOPING); + + if ( m_bSurroundCenter ) + { + if (pDSBufFC->GetStatus(&dwStatus) != DS_OK) + Msg ("Couldn't get SURROUND FC sound buffer status\n"); + + if (dwStatus & DSBSTATUS_BUFFERLOST) + pDSBufFC->Restore(); + + if (!(dwStatus & DSBSTATUS_PLAYING)) + pDSBufFC->Play(0, 0, DSBPLAY_LOOPING); + } + } + else if (pDSBuf) + { + if ( pDSBuf->GetStatus (&dwStatus) != DS_OK ) + Msg("Couldn't get sound buffer status\n"); + + if ( dwStatus & DSBSTATUS_BUFFERLOST ) + pDSBuf->Restore(); + + if ( !(dwStatus & DSBSTATUS_PLAYING) ) + pDSBuf->Play(0, 0, DSBPLAY_LOOPING); + } + + return endtime; +} + + +void CAudioDirectSound::PaintEnd( void ) +{ +} + + +void CAudioDirectSound::ClearBuffer( void ) +{ + int clear; + + DWORD dwSizeFL, dwSizeFR, dwSizeRL, dwSizeRR, dwSizeFC; + char *pDataFL, *pDataFR, *pDataRL, *pDataRR, *pDataFC; + + dwSizeFC = 0; // compiler warning + pDataFC = NULL; + + if ( IsUsingBufferPerSpeaker() ) + { + int SURROUNDreps; + HRESULT SURROUNDhresult; + SURROUNDreps = 0; + + if ( !pDSBufFL && !pDSBufFR && !pDSBufRL && !pDSBufRR && !pDSBufFC ) + return; + + while ((SURROUNDhresult = pDSBufFL->Lock(0, m_bufferSizeBytes, (void**)&pDataFL, &dwSizeFL, NULL, NULL, 0)) != DS_OK) + { + if (SURROUNDhresult != DSERR_BUFFERLOST) + { + Msg ("S_ClearBuffer: DS::Lock FL Sound Buffer Failed\n"); + S_Shutdown (); + return; + } + + if (++SURROUNDreps > 10000) + { + Msg ("S_ClearBuffer: DS: couldn't restore FL buffer\n"); + S_Shutdown (); + return; + } + } + + SURROUNDreps = 0; + while ((SURROUNDhresult = pDSBufFR->Lock(0, m_bufferSizeBytes, (void**)&pDataFR, &dwSizeFR, NULL, NULL, 0)) != DS_OK) + { + if (SURROUNDhresult != DSERR_BUFFERLOST) + { + Msg ("S_ClearBuffer: DS::Lock FR Sound Buffer Failed\n"); + S_Shutdown (); + return; + } + + if (++SURROUNDreps > 10000) + { + Msg ("S_ClearBuffer: DS: couldn't restore FR buffer\n"); + S_Shutdown (); + return; + } + } + + SURROUNDreps = 0; + while ((SURROUNDhresult = pDSBufRL->Lock(0, m_bufferSizeBytes, (void**)&pDataRL, &dwSizeRL, NULL, NULL, 0)) != DS_OK) + { + if (SURROUNDhresult != DSERR_BUFFERLOST) + { + Msg ("S_ClearBuffer: DS::Lock RL Sound Buffer Failed\n"); + S_Shutdown (); + return; + } + + if (++SURROUNDreps > 10000) + { + Msg ("S_ClearBuffer: DS: couldn't restore RL buffer\n"); + S_Shutdown (); + return; + } + } + + SURROUNDreps = 0; + while ((SURROUNDhresult = pDSBufRR->Lock(0, m_bufferSizeBytes, (void**)&pDataRR, &dwSizeRR, NULL, NULL, 0)) != DS_OK) + { + if (SURROUNDhresult != DSERR_BUFFERLOST) + { + Msg ("S_ClearBuffer: DS::Lock RR Sound Buffer Failed\n"); + S_Shutdown (); + return; + } + + if (++SURROUNDreps > 10000) + { + Msg ("S_ClearBuffer: DS: couldn't restore RR buffer\n"); + S_Shutdown (); + return; + } + } + + if (m_bSurroundCenter) + { + SURROUNDreps = 0; + while ((SURROUNDhresult = pDSBufFC->Lock(0, m_bufferSizeBytes, (void**)&pDataFC, &dwSizeFC, NULL, NULL, 0)) != DS_OK) + { + if (SURROUNDhresult != DSERR_BUFFERLOST) + { + Msg ("S_ClearBuffer: DS::Lock FC Sound Buffer Failed\n"); + S_Shutdown (); + return; + } + + if (++SURROUNDreps > 10000) + { + Msg ("S_ClearBuffer: DS: couldn't restore FC buffer\n"); + S_Shutdown (); + return; + } + } + } + + Q_memset(pDataFL, 0, m_bufferSizeBytes); + Q_memset(pDataFR, 0, m_bufferSizeBytes); + Q_memset(pDataRL, 0, m_bufferSizeBytes); + Q_memset(pDataRR, 0, m_bufferSizeBytes); + + if (m_bSurroundCenter) + Q_memset(pDataFC, 0, m_bufferSizeBytes); + + pDSBufFL->Unlock(pDataFL, dwSizeFL, NULL, 0); + pDSBufFR->Unlock(pDataFR, dwSizeFR, NULL, 0); + pDSBufRL->Unlock(pDataRL, dwSizeRL, NULL, 0); + pDSBufRR->Unlock(pDataRR, dwSizeRR, NULL, 0); + + if (m_bSurroundCenter) + pDSBufFC->Unlock(pDataFC, dwSizeFC, NULL, 0); + + return; + } + + if ( !pDSBuf ) + return; + + if ( DeviceSampleBits() == 8 ) + clear = 0x80; + else + clear = 0; + + if (pDSBuf) + { + DWORD dwSize; + DWORD *pData; + int reps; + HRESULT hresult; + + reps = 0; + while ((hresult = pDSBuf->Lock(0, m_bufferSizeBytes, (void**)&pData, &dwSize, NULL, NULL, 0)) != DS_OK) + { + if (hresult != DSERR_BUFFERLOST) + { + Msg("S_ClearBuffer: DS::Lock Sound Buffer Failed\n"); + S_Shutdown(); + return; + } + + if (++reps > 10000) + { + Msg("S_ClearBuffer: DS: couldn't restore buffer\n"); + S_Shutdown(); + return; + } + } + + Q_memset(pData, clear, dwSize); + + pDSBuf->Unlock(pData, dwSize, NULL, 0); + } +} + +void CAudioDirectSound::StopAllSounds( void ) +{ +} + +bool CAudioDirectSound::SNDDMA_InitInterleaved( LPDIRECTSOUND lpDS, WAVEFORMATEX* lpFormat, int channelCount ) +{ + WAVEFORMATEXTENSIBLE wfx = { 0 } ; // DirectSoundBuffer wave format (extensible) + + // set the channel mask and number of channels based on the command line parameter + if(channelCount == 2) + { + wfx.Format.nChannels = 2; + wfx.dwChannelMask = KSAUDIO_SPEAKER_STEREO; // SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; + } + else if(channelCount == 4) + { + wfx.Format.nChannels = 4; + wfx.dwChannelMask = KSAUDIO_SPEAKER_QUAD; // SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; + } + else if(channelCount == 6) + { + wfx.Format.nChannels = 6; + wfx.dwChannelMask = KSAUDIO_SPEAKER_5POINT1; // SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; + } + else + { + return false; + } + + // setup the extensible structure + wfx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; + //wfx.Format.nChannels = SET ABOVE + wfx.Format.nSamplesPerSec = lpFormat->nSamplesPerSec; + wfx.Format.wBitsPerSample = lpFormat->wBitsPerSample; + wfx.Format.nBlockAlign = wfx.Format.wBitsPerSample / 8 * wfx.Format.nChannels; + wfx.Format.nAvgBytesPerSec = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign; + wfx.Format.cbSize = 22; // size from after this to end of extensible struct. sizeof(WORD + DWORD + GUID) + wfx.Samples.wValidBitsPerSample = lpFormat->wBitsPerSample; + //wfx.dwChannelMask = SET ABOVE BASED ON COMMAND LINE PARAMETERS + wfx.SubFormat = KSDATAFORMAT_SUBTYPE_PCM; + + // setup the DirectSound + DSBUFFERDESC dsbdesc = { 0 }; // DirectSoundBuffer descriptor + dsbdesc.dwSize = sizeof(DSBUFFERDESC); + dsbdesc.dwFlags = 0; + + dsbdesc.dwBufferBytes = SECONDARY_BUFFER_SIZE_SURROUND * channelCount; + + dsbdesc.lpwfxFormat = (WAVEFORMATEX*)&wfx; + bool bSuccess = false; + for ( int i = 0; i < 3; i++ ) + { + switch(i) + { + case 0: + dsbdesc.dwFlags = DSBCAPS_LOCHARDWARE; + break; + case 1: + dsbdesc.dwFlags = DSBCAPS_LOCSOFTWARE; + break; + case 2: + dsbdesc.dwFlags = 0; + break; + } + if ( !snd_mute_losefocus.GetBool() ) + { + dsbdesc.dwFlags |= DSBCAPS_GLOBALFOCUS; + } + + if(!FAILED(lpDS->CreateSoundBuffer(&dsbdesc, &pDSBuf, NULL))) + { + bSuccess = true; + break; + } + } + if ( !bSuccess ) + return false; + + DWORD dwSize = 0, dwWrite; + DWORD *pBuffer = 0; + if ( !LockDSBuffer( pDSBuf, &pBuffer, &dwSize, "DS_INTERLEAVED", DSBLOCK_ENTIREBUFFER ) ) + return false; + + m_deviceChannels = wfx.Format.nChannels; + m_deviceSampleBits = wfx.Format.wBitsPerSample; + m_deviceDmaSpeed = wfx.Format.nSamplesPerSec; + m_bufferSizeBytes = dsbdesc.dwBufferBytes; + m_isInterleaved = true; + + Q_memset( pBuffer, 0, dwSize ); + + pDSBuf->Unlock(pBuffer, dwSize, NULL, 0); + + // Make sure mixer is active (this was moved after the zeroing to avoid popping on startup -- at least when using the dx9.0b debug .dlls) + pDSBuf->Play(0, 0, DSBPLAY_LOOPING); + + pDSBuf->Stop(); + pDSBuf->GetCurrentPosition(&m_outputBufferStartOffset, &dwWrite); + + pDSBuf->Play(0, 0, DSBPLAY_LOOPING); + + return true; +} + +/* +================== +SNDDMA_InitDirect + +Direct-Sound support +================== +*/ +sndinitstat CAudioDirectSound::SNDDMA_InitDirect( void ) +{ + DSBUFFERDESC dsbuf; + DSBCAPS dsbcaps; + DWORD dwSize, dwWrite; + WAVEFORMATEX format; + WAVEFORMATEX pformat; + HRESULT hresult; + void *lpData = NULL; + bool primary_format_set = false; + int pri_channels = 2; + + if (!m_hInstDS) + { + m_hInstDS = LoadLibrary("dsound.dll"); + if (m_hInstDS == NULL) + { + Warning( "Couldn't load dsound.dll\n"); + return SIS_FAILURE; + } + + pDirectSoundCreate = (long (__stdcall *)(struct _GUID *,struct IDirectSound ** ,struct IUnknown *))GetProcAddress(m_hInstDS,"DirectSoundCreate"); + if (!pDirectSoundCreate) + { + Warning( "Couldn't get DS proc addr\n"); + return SIS_FAILURE; + } + } + + while ((hresult = pDirectSoundCreate(NULL, &pDS, NULL)) != DS_OK) + { + if (hresult != DSERR_ALLOCATED) + { + DevMsg ("DirectSound create failed\n"); + return SIS_FAILURE; + } + + return SIS_NOTAVAIL; + } + + // get snd_surround value from window settings + DetectWindowsSpeakerSetup(); + + m_bSurround = false; + m_bSurroundCenter = false; + m_bHeadphone = false; + m_isInterleaved = false; + + switch ( snd_surround.GetInt() ) + { + case 0: + m_bHeadphone = true; // stereo headphone + pri_channels = 2; // primary buffer mixes stereo input data + break; + default: + case 2: + pri_channels = 2; // primary buffer mixes stereo input data + break; // no surround + case 4: + m_bSurround = true; // quad surround + pri_channels = 1; // primary buffer mixes 3d mono input data + break; + case 5: + case 7: + m_bSurround = true; // 5.1 surround + m_bSurroundCenter = true; + pri_channels = 1; // primary buffer mixes 3d mono input data + break; + } + + m_deviceChannels = pri_channels; // secondary buffers should have same # channels as primary + m_deviceSampleBits = 16; // hardware bits per sample + m_deviceDmaSpeed = SOUND_DMA_SPEED; // hardware playback rate + + Q_memset( &format, 0, sizeof(format) ); + format.wFormatTag = WAVE_FORMAT_PCM; + format.nChannels = pri_channels; + format.wBitsPerSample = m_deviceSampleBits; + format.nSamplesPerSec = m_deviceDmaSpeed; + format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8; + format.cbSize = 0; + format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign; + + DSCAPS dscaps; + Q_memset( &dscaps, 0, sizeof(dscaps) ); + dscaps.dwSize = sizeof(dscaps); + if (DS_OK != pDS->GetCaps(&dscaps)) + { + Warning( "Couldn't get DS caps\n"); + } + + if (dscaps.dwFlags & DSCAPS_EMULDRIVER) + { + Warning( "No DirectSound driver installed\n"); + Shutdown(); + return SIS_FAILURE; + } + + if (DS_OK != pDS->SetCooperativeLevel(*pmainwindow, DSSCL_EXCLUSIVE)) + { + Warning( "Set coop level failed\n"); + Shutdown(); + return SIS_FAILURE; + } + + // get access to the primary buffer, if possible, so we can set the + // sound hardware format + Q_memset( &dsbuf, 0, sizeof(dsbuf) ); + dsbuf.dwSize = sizeof(DSBUFFERDESC); + dsbuf.dwFlags = DSBCAPS_PRIMARYBUFFER; + if ( snd_legacy_surround.GetBool() || m_bSurround ) + { + dsbuf.dwFlags |= DSBCAPS_CTRL3D; + } + dsbuf.dwBufferBytes = 0; + dsbuf.lpwfxFormat = NULL; + + Q_memset( &dsbcaps, 0, sizeof(dsbcaps) ); + dsbcaps.dwSize = sizeof(dsbcaps); + + if ( !CommandLine()->CheckParm("-snoforceformat")) + { + if (DS_OK == pDS->CreateSoundBuffer(&dsbuf, &pDSPBuf, NULL)) + { + pformat = format; + + if (DS_OK != pDSPBuf->SetFormat(&pformat)) + { + if (snd_firsttime) + DevMsg ("Set primary sound buffer format: no\n"); + } + else + { + if (snd_firsttime) + DevMsg ("Set primary sound buffer format: yes\n"); + + primary_format_set = true; + } + } + } + + if ( m_bSurround ) + { + // try to init surround + m_bSurround = false; + if ( snd_legacy_surround.GetBool() ) + { + if (snd_surround.GetInt() == 4) + { + // attempt to init 4 channel surround + m_bSurround = SNDDMA_InitSurround(pDS, &format, &dsbcaps, 4); + } + else if (snd_surround.GetInt() == 5 || snd_surround.GetInt() == 7) + { + // attempt to init 5 channel surround + m_bSurroundCenter = SNDDMA_InitSurround(pDS, &format, &dsbcaps, 5); + m_bSurround = m_bSurroundCenter; + } + } + if ( !m_bSurround ) + { + pri_channels = 6; + if ( snd_surround.GetInt() < 5 ) + { + pri_channels = 4; + } + + m_bSurround = SNDDMA_InitInterleaved( pDS, &format, pri_channels ); + } + } + + if ( !m_bSurround ) + { + // snd_surround.SetValue( 0 ); + if ( !primary_format_set || !CommandLine()->CheckParm ("-primarysound") ) + { + // create the secondary buffer we'll actually work with + Q_memset( &dsbuf, 0, sizeof(dsbuf) ); + dsbuf.dwSize = sizeof(DSBUFFERDESC); + dsbuf.dwFlags = DSBCAPS_LOCSOFTWARE; // NOTE: don't use CTRLFREQUENCY (slow) + dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE; + dsbuf.lpwfxFormat = &format; + if ( !snd_mute_losefocus.GetBool() ) + { + dsbuf.dwFlags |= DSBCAPS_GLOBALFOCUS; + } + + if (DS_OK != pDS->CreateSoundBuffer(&dsbuf, &pDSBuf, NULL)) + { + Warning( "DS:CreateSoundBuffer Failed"); + Shutdown(); + return SIS_FAILURE; + } + + m_deviceChannels = format.nChannels; + m_deviceSampleBits = format.wBitsPerSample; + m_deviceDmaSpeed = format.nSamplesPerSec; + + Q_memset(&dsbcaps, 0, sizeof(dsbcaps)); + dsbcaps.dwSize = sizeof(dsbcaps); + + if (DS_OK != pDSBuf->GetCaps( &dsbcaps )) + { + Warning( "DS:GetCaps failed\n"); + Shutdown(); + return SIS_FAILURE; + } + + if ( snd_firsttime ) + DevMsg ("Using secondary sound buffer\n"); + } + else + { + if (DS_OK != pDS->SetCooperativeLevel(*pmainwindow, DSSCL_WRITEPRIMARY)) + { + Warning( "Set coop level failed\n"); + Shutdown(); + return SIS_FAILURE; + } + + Q_memset(&dsbcaps, 0, sizeof(dsbcaps)); + dsbcaps.dwSize = sizeof(dsbcaps); + if (DS_OK != pDSPBuf->GetCaps(&dsbcaps)) + { + Msg ("DS:GetCaps failed\n"); + return SIS_FAILURE; + } + + pDSBuf = pDSPBuf; + DevMsg ("Using primary sound buffer\n"); + } + + if ( snd_firsttime ) + { + DevMsg(" %d channel(s)\n" + " %d bits/sample\n" + " %d samples/sec\n", + DeviceChannels(), DeviceSampleBits(), DeviceDmaSpeed()); + } + + // initialize the buffer + m_bufferSizeBytes = dsbcaps.dwBufferBytes; + int reps = 0; + while ((hresult = pDSBuf->Lock(0, m_bufferSizeBytes, (void**)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK) + { + if (hresult != DSERR_BUFFERLOST) + { + Warning( "SNDDMA_InitDirect: DS::Lock Sound Buffer Failed\n"); + Shutdown(); + return SIS_FAILURE; + } + + if (++reps > 10000) + { + Warning( "SNDDMA_InitDirect: DS: couldn't restore buffer\n"); + Shutdown(); + return SIS_FAILURE; + } + } + + Q_memset( lpData, 0, dwSize ); + pDSBuf->Unlock(lpData, dwSize, NULL, 0); + + // Make sure mixer is active (this was moved after the zeroing to avoid popping on startup -- at least when using the dx9.0b debug .dlls) + pDSBuf->Play(0, 0, DSBPLAY_LOOPING); + + // we don't want anyone to access the buffer directly w/o locking it first. + lpData = NULL; + + pDSBuf->Stop(); + + pDSBuf->GetCurrentPosition(&m_outputBufferStartOffset, &dwWrite); + + pDSBuf->Play(0, 0, DSBPLAY_LOOPING); + } + + // number of mono samples output buffer may hold + m_deviceSampleCount = m_bufferSizeBytes/(DeviceSampleBytes()); + + return SIS_SUCCESS; + +} + +static DWORD GetSpeakerConfigForSurroundMode( int surroundMode, const char **pConfigDesc ) +{ + DWORD newSpeakerConfig = DSSPEAKER_STEREO; + const char *speakerConfigDesc = ""; + + switch ( surroundMode ) + { + case 0: + newSpeakerConfig = DSSPEAKER_HEADPHONE; + speakerConfigDesc = "headphone"; + break; + + case 2: + default: + newSpeakerConfig = DSSPEAKER_STEREO; + speakerConfigDesc = "stereo speaker"; + break; + + case 4: + newSpeakerConfig = DSSPEAKER_QUAD; + speakerConfigDesc = "quad speaker"; + break; + + case 5: + newSpeakerConfig = DSSPEAKER_5POINT1; + speakerConfigDesc = "5.1 speaker"; + break; + + case 7: + newSpeakerConfig = DSSPEAKER_7POINT1; + speakerConfigDesc = "7.1 speaker"; + break; + } + if ( pConfigDesc ) + { + *pConfigDesc = speakerConfigDesc; + } + return newSpeakerConfig; +} + +// Read the speaker config from windows +static DWORD GetWindowsSpeakerConfig() +{ + DWORD speaker_config = windows_speaker_config.GetInt(); + if ( windows_speaker_config.GetInt() < 0 ) + { + speaker_config = DSSPEAKER_STEREO; + if (DS_OK == pDS->GetSpeakerConfig( &speaker_config )) + { + // split out settings + speaker_config = DSSPEAKER_CONFIG(speaker_config); + if ( speaker_config == DSSPEAKER_7POINT1_SURROUND ) + speaker_config = DSSPEAKER_7POINT1; + if ( speaker_config == DSSPEAKER_5POINT1_SURROUND) + speaker_config = DSSPEAKER_5POINT1; + } + windows_speaker_config.SetValue((int)speaker_config); + } + + return speaker_config; +} + +// Writes snd_surround convar given a directsound speaker config +static void SetSurroundModeFromSpeakerConfig( DWORD speakerConfig ) +{ + // set the cvar to be the windows setting + switch (speakerConfig) + { + case DSSPEAKER_HEADPHONE: + snd_surround.SetValue(0); + break; + + case DSSPEAKER_MONO: + case DSSPEAKER_STEREO: + default: + snd_surround.SetValue( 2 ); + break; + + case DSSPEAKER_QUAD: + snd_surround.SetValue(4); + break; + + case DSSPEAKER_5POINT1: + snd_surround.SetValue(5); + break; + + case DSSPEAKER_7POINT1: + snd_surround.SetValue(7); + break; + } +} +/* + Sets the snd_surround_speakers cvar based on the windows setting +*/ + +void CAudioDirectSound::DetectWindowsSpeakerSetup() +{ + // detect speaker settings from windows + DWORD speaker_config = GetWindowsSpeakerConfig(); + SetSurroundModeFromSpeakerConfig(speaker_config); + + // DEBUG + if (speaker_config == DSSPEAKER_MONO) + DevMsg( "DS:mono configuration detected\n"); + + if (speaker_config == DSSPEAKER_HEADPHONE) + DevMsg( "DS:headphone configuration detected\n"); + + if (speaker_config == DSSPEAKER_STEREO) + DevMsg( "DS:stereo speaker configuration detected\n"); + + if (speaker_config == DSSPEAKER_QUAD) + DevMsg( "DS:quad speaker configuration detected\n"); + + if (speaker_config == DSSPEAKER_SURROUND) + DevMsg( "DS:surround speaker configuration detected\n"); + + if (speaker_config == DSSPEAKER_5POINT1) + DevMsg( "DS:5.1 speaker configuration detected\n"); + + if (speaker_config == DSSPEAKER_7POINT1) + DevMsg( "DS:7.1 speaker configuration detected\n"); +} + +/* + Updates windows settings based on snd_surround_speakers cvar changing + This should only happen if the user has changed it via the console or the UI + Changes won't take effect until the engine has restarted +*/ +void OnSndSurroundCvarChanged( IConVar *pVar, const char *pOldString, float flOldValue ) +{ + // if the old value is -1, we're setting this from the detect routine for the first time + // no need to reset the device + if (!pDS || flOldValue == -1 ) + return; + + // get the user's previous speaker config + DWORD speaker_config = GetWindowsSpeakerConfig(); + + // get the new config + DWORD newSpeakerConfig = 0; + const char *speakerConfigDesc = ""; + + ConVarRef var( pVar ); + newSpeakerConfig = GetSpeakerConfigForSurroundMode( var.GetInt(), &speakerConfigDesc ); + // make sure the config has changed + if (newSpeakerConfig == speaker_config) + return; + + // set new configuration + windows_speaker_config.SetValue( (int)newSpeakerConfig ); + + Msg("Speaker configuration has been changed to %s.\n", speakerConfigDesc); + + // restart sound system so it takes effect + g_pSoundServices->RestartSoundSystem(); +} + +void OnSndSurroundLegacyChanged( IConVar *pVar, const char *pOldString, float flOldValue ) +{ + if ( pDS && CAudioDirectSound::m_pSingleton ) + { + ConVarRef var( pVar ); + // should either be interleaved or have legacy surround set, not both + if ( CAudioDirectSound::m_pSingleton->IsInterleaved() == var.GetBool() ) + { + Msg( "Legacy Surround %s.\n", var.GetBool() ? "enabled" : "disabled" ); + // restart sound system so it takes effect + g_pSoundServices->RestartSoundSystem(); + } + } +} + +void OnSndVarChanged( IConVar *pVar, const char *pOldString, float flOldValue ) +{ + ConVarRef var(pVar); + // restart sound system so the change takes effect + if ( var.GetInt() != int(flOldValue) ) + { + g_pSoundServices->RestartSoundSystem(); + } +} + +/* + Release all Surround buffer pointers +*/ +void ReleaseSurround(void) +{ + if ( pDSBuf3DFL != NULL ) + { + pDSBuf3DFL->Release(); + pDSBuf3DFL = NULL; + } + + if ( pDSBuf3DFR != NULL) + { + pDSBuf3DFR->Release(); + pDSBuf3DFR = NULL; + } + + if ( pDSBuf3DRL != NULL ) + { + pDSBuf3DRL->Release(); + pDSBuf3DRL = NULL; + } + + if ( pDSBuf3DRR != NULL ) + { + pDSBuf3DRR->Release(); + pDSBuf3DRR = NULL; + } + + if ( pDSBufFL != NULL ) + { + pDSBufFL->Release(); + pDSBufFL = NULL; + } + + if ( pDSBufFR != NULL ) + { + pDSBufFR->Release(); + pDSBufFR = NULL; + } + + if ( pDSBufRL != NULL ) + { + pDSBufRL->Release(); + pDSBufRL = NULL; + } + + if ( pDSBufRR != NULL ) + { + pDSBufRR->Release(); + pDSBufRR = NULL; + } + + if ( pDSBufFC != NULL ) + { + pDSBufFC->Release(); + pDSBufFC = NULL; + } +} + +void DEBUG_DS_FillSquare( void *lpData, DWORD dwSize ) +{ + short *lpshort = (short *)lpData; + DWORD j = min((DWORD)10000, dwSize/2); + + for (DWORD i = 0; i < j; i++) + lpshort[i] = 8000; +} + +void DEBUG_DS_FillSquare2( void *lpData, DWORD dwSize ) +{ + short *lpshort = (short *)lpData; + DWORD j = min((DWORD)1000, dwSize/2); + + for (DWORD i = 0; i < j; i++) + lpshort[i] = 16000; +} + +// helper to set default buffer params +void DS3D_SetBufferParams( LPDIRECTSOUND3DBUFFER pDSBuf3D, D3DVECTOR *pbpos, D3DVECTOR *pbdir ) +{ + DS3DBUFFER bparm; + D3DVECTOR bvel; + D3DVECTOR bpos, bdir; + HRESULT hr; + + bvel.x = 0.0f; bvel.y = 0.0f; bvel.z = 0.0f; + bpos = *pbpos; + bdir = *pbdir; + + bparm.dwSize = sizeof(DS3DBUFFER); + + hr = pDSBuf3D->GetAllParameters( &bparm ); + + bparm.vPosition = bpos; + bparm.vVelocity = bvel; + bparm.dwInsideConeAngle = 5.0; // narrow cones for each speaker + bparm.dwOutsideConeAngle = 10.0; + bparm.vConeOrientation = bdir; + bparm.lConeOutsideVolume = DSBVOLUME_MIN; + bparm.flMinDistance = 100.0; // no rolloff (until > 2.0 meter distance) + bparm.flMaxDistance = DS3D_DEFAULTMAXDISTANCE; + bparm.dwMode = DS3DMODE_NORMAL; + + hr = pDSBuf3D->SetAllParameters( &bparm, DS3D_DEFERRED ); +} + +// Initialization for Surround sound support (4 channel or 5 channel). +// Creates 4 or 5 mono 3D buffers to be used as Front Left, (Front Center), Front Right, Rear Left, Rear Right +bool CAudioDirectSound::SNDDMA_InitSurround(LPDIRECTSOUND lpDS, WAVEFORMATEX* lpFormat, DSBCAPS* lpdsbc, int cchan) +{ + DSBUFFERDESC dsbuf; + WAVEFORMATEX wvex; + DWORD dwSize, dwWrite; + int reps; + HRESULT hresult; + void *lpData = NULL; + + if ( lpDS == NULL ) return FALSE; + + // Force format to mono channel + + memcpy(&wvex, lpFormat, sizeof(WAVEFORMATEX)); + wvex.nChannels = 1; + wvex.nBlockAlign = wvex.nChannels * wvex.wBitsPerSample / 8; + wvex.nAvgBytesPerSec = wvex.nSamplesPerSec * wvex.nBlockAlign; + + memset (&dsbuf, 0, sizeof(dsbuf)); + dsbuf.dwSize = sizeof(DSBUFFERDESC); + // NOTE: LOCHARDWARE causes SB AWE64 to crash in it's DSOUND driver + dsbuf.dwFlags = DSBCAPS_CTRL3D; // don't use CTRLFREQUENCY (slow) + if ( !snd_mute_losefocus.GetBool() ) + { + dsbuf.dwFlags |= DSBCAPS_GLOBALFOCUS; + } + + // reserve space for each buffer + + dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE_SURROUND; + + dsbuf.lpwfxFormat = &wvex; + + // create 4 mono buffers FL, FR, RL, RR + + if (DS_OK != lpDS->CreateSoundBuffer(&dsbuf, &pDSBufFL, NULL)) + { + Warning( "DS:CreateSoundBuffer for 3d front left failed"); + ReleaseSurround(); + return FALSE; + } + + if (DS_OK != lpDS->CreateSoundBuffer(&dsbuf, &pDSBufFR, NULL)) + { + Warning( "DS:CreateSoundBuffer for 3d front right failed"); + ReleaseSurround(); + return FALSE; + } + + if (DS_OK != lpDS->CreateSoundBuffer(&dsbuf, &pDSBufRL, NULL)) + { + Warning( "DS:CreateSoundBuffer for 3d rear left failed"); + ReleaseSurround(); + return FALSE; + } + + if (DS_OK != lpDS->CreateSoundBuffer(&dsbuf, &pDSBufRR, NULL)) + { + Warning( "DS:CreateSoundBuffer for 3d rear right failed"); + ReleaseSurround(); + return FALSE; + } + + // create center channel + + if (cchan == 5) + { + if (DS_OK != lpDS->CreateSoundBuffer(&dsbuf, &pDSBufFC, NULL)) + { + Warning( "DS:CreateSoundBuffer for 3d front center failed"); + ReleaseSurround(); + return FALSE; + } + } + + // Try to get 4 or 5 3D buffers from the mono DS buffers + + if (DS_OK != pDSBufFL->QueryInterface(IID_IDirectSound3DBufferDef, (void**)&pDSBuf3DFL)) + { + Warning( "DS:Query 3DBuffer for 3d front left failed"); + ReleaseSurround(); + return FALSE; + } + + if (DS_OK != pDSBufFR->QueryInterface(IID_IDirectSound3DBufferDef, (void**)&pDSBuf3DFR)) + { + Warning( "DS:Query 3DBuffer for 3d front right failed"); + ReleaseSurround(); + return FALSE; + } + + if (DS_OK != pDSBufRL->QueryInterface(IID_IDirectSound3DBufferDef, (void**)&pDSBuf3DRL)) + { + Warning( "DS:Query 3DBuffer for 3d rear left failed"); + ReleaseSurround(); + return FALSE; + } + + if (DS_OK != pDSBufRR->QueryInterface(IID_IDirectSound3DBufferDef, (void**)&pDSBuf3DRR)) + { + Warning( "DS:Query 3DBuffer for 3d rear right failed"); + ReleaseSurround(); + return FALSE; + } + + if (cchan == 5) + { + if (DS_OK != pDSBufFC->QueryInterface(IID_IDirectSound3DBufferDef, (void**)&pDSBuf3DFC)) + { + Warning( "DS:Query 3DBuffer for 3d front center failed"); + ReleaseSurround(); + return FALSE; + } + } + + // set listener position & orientation. + // DS uses left handed coord system: +x is right, +y is up, +z is forward + + HRESULT hr; + + IDirectSound3DListener *plistener = NULL; + + hr = pDSPBuf->QueryInterface(IID_IDirectSound3DListener, (void**)&plistener); + if (plistener) + { + DS3DLISTENER lparm; + lparm.dwSize = sizeof(DS3DLISTENER); + + hr = plistener->GetAllParameters( &lparm ); + + hr = plistener->SetOrientation( 0.0f,0.0f,1.0f, 0.0f,1.0f,0.0f, DS3D_IMMEDIATE); // frontx,y,z topx,y,z + hr = plistener->SetPosition(0.0f, 0.0f, 0.0f, DS3D_IMMEDIATE); + } + else + { + Warning( "DS: failed to get 3D listener interface."); + ReleaseSurround(); + return FALSE; + } + + // set 3d buffer position and orientation params + + D3DVECTOR bpos, bdir; + + bpos.x = -1.0; bpos.y = 0.0; bpos.z = 1.0; // FL + bdir.x = 1.0; bdir.y = 0.0; bdir.z = -1.0; + + DS3D_SetBufferParams( pDSBuf3DFL, &bpos, &bdir ); + + bpos.x = 1.0; bpos.y = 0.0; bpos.z = 1.0; // FR + bdir.x = -1.0; bdir.y = 0.0; bdir.z = -1.0; + + DS3D_SetBufferParams( pDSBuf3DFR, &bpos, &bdir ); + + bpos.x = -1.0; bpos.y = 0.0; bpos.z = -1.0; // RL + bdir.x = 1.0; bdir.y = 0.0; bdir.z = 1.0; + + DS3D_SetBufferParams( pDSBuf3DRL, &bpos, &bdir ); + + bpos.x = 1.0; bpos.y = 0.0; bpos.z = -1.0; // RR + bdir.x = -1.0; bdir.y = 0.0; bdir.z = 1.0; + + DS3D_SetBufferParams( pDSBuf3DRR, &bpos, &bdir ); + + if (cchan == 5) + { + bpos.x = 0.0; bpos.y = 0.0; bpos.z = 1.0; // FC + bdir.x = 0.0; bdir.y = 0.0; bdir.z = -1.0; + + DS3D_SetBufferParams( pDSBuf3DFC, &bpos, &bdir ); + } + + // commit all buffer param settings + + hr = plistener->CommitDeferredSettings(); + + m_deviceChannels = 1; // 1 mono 3d output buffer + m_deviceSampleBits = lpFormat->wBitsPerSample; + m_deviceDmaSpeed = lpFormat->nSamplesPerSec; + + memset(lpdsbc, 0, sizeof(DSBCAPS)); + lpdsbc->dwSize = sizeof(DSBCAPS); + + if (DS_OK != pDSBufFL->GetCaps (lpdsbc)) + { + Warning( "DS:GetCaps failed for 3d sound buffer\n"); + ReleaseSurround(); + return FALSE; + } + + pDSBufFL->Play(0, 0, DSBPLAY_LOOPING); + pDSBufFR->Play(0, 0, DSBPLAY_LOOPING); + pDSBufRL->Play(0, 0, DSBPLAY_LOOPING); + pDSBufRR->Play(0, 0, DSBPLAY_LOOPING); + + if (cchan == 5) + pDSBufFC->Play(0, 0, DSBPLAY_LOOPING); + + if (snd_firsttime) + DevMsg(" %d channel(s)\n" + " %d bits/sample\n" + " %d samples/sec\n", + cchan, DeviceSampleBits(), DeviceDmaSpeed()); + + m_bufferSizeBytes = lpdsbc->dwBufferBytes; + + // Test everything just like in the normal initialization. + if (cchan == 5) + { + reps = 0; + while ((hresult = pDSBufFC->Lock(0, lpdsbc->dwBufferBytes, (void**)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK) + { + if (hresult != DSERR_BUFFERLOST) + { + Warning( "SNDDMA_InitDirect: DS::Lock Sound Buffer Failed for FC\n"); + ReleaseSurround(); + return FALSE; + } + + if (++reps > 10000) + { + Warning( "SNDDMA_InitDirect: DS: couldn't restore buffer for FC\n"); + ReleaseSurround(); + return FALSE; + } + } + memset(lpData, 0, dwSize); +// DEBUG_DS_FillSquare( lpData, dwSize ); + pDSBufFC->Unlock(lpData, dwSize, NULL, 0); + } + + reps = 0; + while ((hresult = pDSBufFL->Lock(0, lpdsbc->dwBufferBytes, (void**)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK) + { + if (hresult != DSERR_BUFFERLOST) + { + Warning( "SNDDMA_InitSurround: DS::Lock Sound Buffer Failed for 3d FL\n"); + ReleaseSurround(); + return FALSE; + } + + if (++reps > 10000) + { + Warning( "SNDDMA_InitSurround: DS: couldn't restore buffer for 3d FL\n"); + ReleaseSurround(); + return FALSE; + } + } + memset(lpData, 0, dwSize); +// DEBUG_DS_FillSquare( lpData, dwSize ); + pDSBufFL->Unlock(lpData, dwSize, NULL, 0); + + reps = 0; + while ((hresult = pDSBufFR->Lock(0, lpdsbc->dwBufferBytes, (void**)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK) + { + if (hresult != DSERR_BUFFERLOST) + { + Warning( "SNDDMA_InitSurround: DS::Lock Sound Buffer Failed for 3d FR\n"); + ReleaseSurround(); + return FALSE; + } + + if (++reps > 10000) + { + Warning( "SNDDMA_InitSurround: DS: couldn't restore buffer for FR\n"); + ReleaseSurround(); + return FALSE; + } + } + memset(lpData, 0, dwSize); +// DEBUG_DS_FillSquare( lpData, dwSize ); + pDSBufFR->Unlock(lpData, dwSize, NULL, 0); + + reps = 0; + while ((hresult = pDSBufRL->Lock(0, lpdsbc->dwBufferBytes, (void**)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK) + { + if (hresult != DSERR_BUFFERLOST) + { + Warning( "SNDDMA_InitDirect: DS::Lock Sound Buffer Failed for RL\n"); + ReleaseSurround(); + return FALSE; + } + + if (++reps > 10000) + { + Warning( "SNDDMA_InitDirect: DS: couldn't restore buffer for RL\n"); + ReleaseSurround(); + return FALSE; + } + } + memset(lpData, 0, dwSize); +// DEBUG_DS_FillSquare( lpData, dwSize ); + pDSBufRL->Unlock(lpData, dwSize, NULL, 0); + + reps = 0; + while ((hresult = pDSBufRR->Lock(0, lpdsbc->dwBufferBytes, (void**)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK) + { + if (hresult != DSERR_BUFFERLOST) + { + Warning( "SNDDMA_InitDirect: DS::Lock Sound Buffer Failed for RR\n"); + ReleaseSurround(); + return FALSE; + } + + if (++reps > 10000) + { + Warning( "SNDDMA_InitDirect: DS: couldn't restore buffer for RR\n"); + ReleaseSurround(); + return FALSE; + } + } + memset(lpData, 0, dwSize); +// DEBUG_DS_FillSquare( lpData, dwSize ); + pDSBufRR->Unlock(lpData, dwSize, NULL, 0); + + lpData = NULL; // this is invalid now + + // OK Stop and get our positions and were good to go. + pDSBufFL->Stop(); + pDSBufFR->Stop(); + pDSBufRL->Stop(); + pDSBufRR->Stop(); + if (cchan == 5) + pDSBufFC->Stop(); + + // get hardware playback position, store it, syncronize all buffers to FL + + pDSBufFL->GetCurrentPosition(&m_outputBufferStartOffset, &dwWrite); + pDSBufFR->SetCurrentPosition(m_outputBufferStartOffset); + pDSBufRL->SetCurrentPosition(m_outputBufferStartOffset); + pDSBufRR->SetCurrentPosition(m_outputBufferStartOffset); + if (cchan == 5) + pDSBufFC->SetCurrentPosition(m_outputBufferStartOffset); + + pDSBufFL->Play(0, 0, DSBPLAY_LOOPING); + pDSBufFR->Play(0, 0, DSBPLAY_LOOPING); + pDSBufRL->Play(0, 0, DSBPLAY_LOOPING); + pDSBufRR->Play(0, 0, DSBPLAY_LOOPING); + if (cchan == 5) + pDSBufFC->Play(0, 0, DSBPLAY_LOOPING); + + if (snd_firsttime) + Warning( "3d surround sound initialization successful\n"); + + return TRUE; +} + +void CAudioDirectSound::UpdateListener( const Vector& position, const Vector& forward, const Vector& right, const Vector& up ) +{ +} + +void CAudioDirectSound::ChannelReset( int entnum, int channelIndex, float distanceMod ) +{ +} + +const char *CAudioDirectSound::DeviceName( void ) +{ + if ( m_bSurroundCenter ) + return "5 Channel Surround"; + + if ( m_bSurround ) + return "4 Channel Surround"; + + return "Direct Sound"; +} + +// use the partial buffer locking code in stereo as well - not available when recording a movie +ConVar snd_lockpartial("snd_lockpartial","1"); + +// Transfer up to a full paintbuffer (PAINTBUFFER_SIZE) of stereo samples +// out to the directsound secondary buffer(s). +// For 4 or 5 ch surround, there are 4 or 5 mono 16 bit secondary DS streaming buffers. +// For stereo speakers, there is one stereo 16 bit secondary DS streaming buffer. + +void CAudioDirectSound::TransferSamples( int end ) +{ + int lpaintedtime = g_paintedtime; + int endtime = end; + + // When Surround is enabled, divert to 4 or 5 chan xfer scheme. + if ( m_bSurround ) + { + if ( m_isInterleaved ) + { + S_TransferSurround16Interleaved( PAINTBUFFER, REARPAINTBUFFER, CENTERPAINTBUFFER, lpaintedtime, endtime); + } + else + { + int cchan = ( m_bSurroundCenter ? 5 : 4); + + S_TransferSurround16( PAINTBUFFER, REARPAINTBUFFER, CENTERPAINTBUFFER, lpaintedtime, endtime, cchan); + } + return; + } + else if ( snd_lockpartial.GetBool() && DeviceChannels() == 2 && DeviceSampleBits() == 16 && !SND_IsRecording() ) + { + S_TransferSurround16Interleaved( PAINTBUFFER, NULL, NULL, lpaintedtime, endtime ); + } + else + { + DWORD *pBuffer = NULL; + DWORD dwSize = 0; + if ( !LockDSBuffer( pDSBuf, &pBuffer, &dwSize, "DS_STEREO" ) ) + { + S_Shutdown(); + S_Startup(); + return; + } + if ( pBuffer ) + { + if ( DeviceChannels() == 2 && DeviceSampleBits() == 16 ) + { + S_TransferStereo16( pBuffer, PAINTBUFFER, lpaintedtime, endtime ); + } + else + { + // UNDONE: obsolete - no 8 bit mono output supported + S_TransferPaintBuffer( pBuffer, PAINTBUFFER, lpaintedtime, endtime ); + } + pDSBuf->Unlock( pBuffer, dwSize, NULL, 0 ); + } + } +} + +bool CAudioDirectSound::IsUsingBufferPerSpeaker() +{ + return m_bSurround && !m_isInterleaved; +} + +bool CAudioDirectSound::LockDSBuffer( LPDIRECTSOUNDBUFFER pBuffer, DWORD **pdwWriteBuffer, DWORD *pdwSizeBuffer, const char *pBufferName, int lockFlags ) +{ + if ( !pBuffer ) + return false; + HRESULT hr; + int reps = 0; + while ((hr = pBuffer->Lock(0, m_bufferSizeBytes, (void**)pdwWriteBuffer, pdwSizeBuffer, + NULL, NULL, lockFlags)) != DS_OK) + { + if (hr != DSERR_BUFFERLOST) + { + Msg ("DS::Lock Sound Buffer Failed %s\n", pBufferName); + return false; + } + + if (++reps > 10000) + { + Msg ("DS:: couldn't restore buffer %s\n", pBufferName); + return false; + } + } + return true; +} + +////////////////////////////////////////////////////////////////////////////////////////////////// +// Given front, rear and center stereo paintbuffers, split samples into 4 or 5 mono directsound buffers (FL, FC, FR, RL, RR) +void CAudioDirectSound::S_TransferSurround16( portable_samplepair_t *pfront, portable_samplepair_t *prear, portable_samplepair_t *pcenter, int lpaintedtime, int endtime, int cchan) +{ + int lpos; + DWORD *pdwWriteFL=NULL, *pdwWriteFR=NULL, *pdwWriteRL=NULL, *pdwWriteRR=NULL, *pdwWriteFC=NULL; + DWORD dwSizeFL=0, dwSizeFR=0, dwSizeRL=0, dwSizeRR=0, dwSizeFC=0; + int i, j, *snd_p, *snd_rp, *snd_cp, volumeFactor; + short *snd_out_fleft, *snd_out_fright, *snd_out_rleft, *snd_out_rright, *snd_out_fcenter; + + pdwWriteFC = NULL; // compiler warning + dwSizeFC = 0; + snd_out_fcenter = NULL; + + volumeFactor = S_GetMasterVolume() * 256; + + // lock all 4 or 5 mono directsound buffers FL, FR, RL, RR, FC + if ( !LockDSBuffer( pDSBufFL, &pdwWriteFL, &dwSizeFL, "FL" ) || + !LockDSBuffer( pDSBufFR, &pdwWriteFR, &dwSizeFR, "FR" ) || + !LockDSBuffer( pDSBufRL, &pdwWriteRL, &dwSizeRL, "RL" ) || + !LockDSBuffer( pDSBufRR, &pdwWriteRR, &dwSizeRR, "RR" ) ) + { + S_Shutdown(); + S_Startup(); + return; + } + + if (cchan == 5 && !LockDSBuffer( pDSBufFC, &pdwWriteFC, &dwSizeFC, "FC" )) + { + S_Shutdown (); + S_Startup (); + return; + } + + // take stereo front and rear paintbuffers, and center paintbuffer if provided, + // and copy samples into the 4 or 5 mono directsound buffers + + snd_rp = (int *)prear; + snd_cp = (int *)pcenter; + snd_p = (int *)pfront; + + int linearCount; // space in output buffer for linearCount mono samples + int sampleMonoCount = DeviceSampleCount(); // number of mono samples per output buffer (was;(DeviceSampleCount()>>1)) + int sampleMask = sampleMonoCount - 1; + + // paintedtime - number of full samples that have played since start + // endtime - number of full samples to play to - endtime is g_soundtime + mixahead samples + + while (lpaintedtime < endtime) + { + lpos = lpaintedtime & sampleMask; // lpos is next output position in output buffer + + linearCount = sampleMonoCount - lpos; + + // limit output count to requested number of samples + + if (linearCount > endtime - lpaintedtime) + linearCount = endtime - lpaintedtime; + + snd_out_fleft = (short *)pdwWriteFL + lpos; + snd_out_fright = (short *)pdwWriteFR + lpos; + snd_out_rleft = (short *)pdwWriteRL + lpos; + snd_out_rright = (short *)pdwWriteRR + lpos; + + if (cchan == 5) + snd_out_fcenter = (short *)pdwWriteFC + lpos; + + // for 16 bit sample in the front and rear stereo paintbuffers, copy + // into the 4 or 5 FR, FL, RL, RR, FC directsound paintbuffers + + for (i=0, j= 0 ; i<linearCount ; i++, j+=2) + { + snd_out_fleft[i] = (snd_p[j]*volumeFactor)>>8; + snd_out_fright[i] = (snd_p[j + 1]*volumeFactor)>>8; + snd_out_rleft[i] = (snd_rp[j]*volumeFactor)>>8; + snd_out_rright[i] = (snd_rp[j + 1]*volumeFactor)>>8; + } + + // copy front center buffer (mono) data to center chan directsound paintbuffer + + if (cchan == 5) + { + for (i=0, j=0 ; i<linearCount ; i++, j+=2) + { + snd_out_fcenter[i] = (snd_cp[j]*volumeFactor)>>8; + + } + } + + snd_p += linearCount << 1; + snd_rp += linearCount << 1; + snd_cp += linearCount << 1; + + lpaintedtime += linearCount; + } + + pDSBufFL->Unlock(pdwWriteFL, dwSizeFL, NULL, 0); + pDSBufFR->Unlock(pdwWriteFR, dwSizeFR, NULL, 0); + pDSBufRL->Unlock(pdwWriteRL, dwSizeRL, NULL, 0); + pDSBufRR->Unlock(pdwWriteRR, dwSizeRR, NULL, 0); + + if (cchan == 5) + pDSBufFC->Unlock(pdwWriteFC, dwSizeFC, NULL, 0); +} + +struct surround_transfer_t +{ + int paintedtime; + int linearCount; + int sampleMask; + int channelCount; + int *snd_p; + int *snd_rp; + int *snd_cp; + short *pOutput; +}; + +static void TransferSamplesToSurroundBuffer( int outputCount, surround_transfer_t &transfer ) +{ + int i, j; + int volumeFactor = S_GetMasterVolume() * 256; + + if ( transfer.channelCount == 2 ) + { + for (i=0, j=0; i<outputCount ; i++, j+=2) + { + transfer.pOutput[0] = (transfer.snd_p[j]*volumeFactor)>>8; // FL + transfer.pOutput[1] = (transfer.snd_p[j + 1]*volumeFactor)>>8; // FR + transfer.pOutput += 2; + } + } + // no center channel, 4 channel surround + else if ( transfer.channelCount == 4 ) + { + for (i=0, j=0; i<outputCount ; i++, j+=2) + { + transfer.pOutput[0] = (transfer.snd_p[j]*volumeFactor)>>8; // FL + transfer.pOutput[1] = (transfer.snd_p[j + 1]*volumeFactor)>>8; // FR + transfer.pOutput[2] = (transfer.snd_rp[j]*volumeFactor)>>8; // RL + transfer.pOutput[3] = (transfer.snd_rp[j + 1]*volumeFactor)>>8; // RR + transfer.pOutput += 4; + //Assert( baseOffset <= (DeviceSampleCount()) ); + } + } + else + { + Assert(transfer.snd_cp); + // 6 channel / 5.1 + for (i=0, j=0 ; i<outputCount ; i++, j+=2) + { + transfer.pOutput[0] = (transfer.snd_p[j]*volumeFactor)>>8; // FL + transfer.pOutput[1] = (transfer.snd_p[j + 1]*volumeFactor)>>8; // FR + + transfer.pOutput[2] = (transfer.snd_cp[j]*volumeFactor)>>8; // Center + + transfer.pOutput[3] = 0; + + transfer.pOutput[4] = (transfer.snd_rp[j]*volumeFactor)>>8; // RL + transfer.pOutput[5] = (transfer.snd_rp[j + 1]*volumeFactor)>>8; // RR + +#if 0 + // average channels into the subwoofer, let the sub filter the output + // NOTE: avg l/r rear to do 2 shifts instead of divide by 5 + int sumFront = (int)transfer.pOutput[0] + (int)transfer.pOutput[1] + (int)transfer.pOutput[2]; + int sumRear = (int)transfer.pOutput[4] + (int)transfer.pOutput[5]; + transfer.pOutput[3] = (sumFront + (sumRear>>1)) >> 2; +#endif + + transfer.pOutput += 6; + //Assert( baseOffset <= (DeviceSampleCount()) ); + } + } + + transfer.snd_p += outputCount << 1; + if ( transfer.snd_rp ) + { + transfer.snd_rp += outputCount << 1; + } + if ( transfer.snd_cp ) + { + transfer.snd_cp += outputCount << 1; + } + + transfer.paintedtime += outputCount; + transfer.linearCount -= outputCount; + +} + +void CAudioDirectSound::S_TransferSurround16Interleaved_FullLock( const portable_samplepair_t *pfront, const portable_samplepair_t *prear, const portable_samplepair_t *pcenter, int lpaintedtime, int endtime ) +{ + int lpos; + DWORD *pdwWrite = NULL; + DWORD dwSize = 0; + int i, j, *snd_p, *snd_rp, *snd_cp, volumeFactor; + + volumeFactor = S_GetMasterVolume() * 256; + int channelCount = m_bSurroundCenter ? 5 : 4; + if ( DeviceChannels() == 2 ) + { + channelCount = 2; + } + + // lock single interleaved buffer + if ( !LockDSBuffer( pDSBuf, &pdwWrite, &dwSize, "DS_INTERLEAVED" ) ) + { + S_Shutdown (); + S_Startup (); + return; + } + + // take stereo front and rear paintbuffers, and center paintbuffer if provided, + // and copy samples into the 4 or 5 mono directsound buffers + + snd_rp = (int *)prear; + snd_cp = (int *)pcenter; + snd_p = (int *)pfront; + + int linearCount; // space in output buffer for linearCount mono samples + int sampleMonoCount = m_bufferSizeBytes/(DeviceSampleBytes()*DeviceChannels()); // number of mono samples per output buffer (was;(DeviceSampleCount()>>1)) + int sampleMask = sampleMonoCount - 1; + + // paintedtime - number of full samples that have played since start + // endtime - number of full samples to play to - endtime is g_soundtime + mixahead samples + + short *pOutput = (short *)pdwWrite; + while (lpaintedtime < endtime) + { + lpos = lpaintedtime & sampleMask; // lpos is next output position in output buffer + + linearCount = sampleMonoCount - lpos; + + // limit output count to requested number of samples + + if (linearCount > endtime - lpaintedtime) + linearCount = endtime - lpaintedtime; + + if ( channelCount == 4 ) + { + int baseOffset = lpos * channelCount; + for (i=0, j= 0 ; i<linearCount ; i++, j+=2) + { + pOutput[baseOffset+0] = (snd_p[j]*volumeFactor)>>8; // FL + pOutput[baseOffset+1] = (snd_p[j + 1]*volumeFactor)>>8; // FR + pOutput[baseOffset+2] = (snd_rp[j]*volumeFactor)>>8; // RL + pOutput[baseOffset+3] = (snd_rp[j + 1]*volumeFactor)>>8; // RR + baseOffset += 4; + } + } + else + { + Assert(channelCount==5); // 6 channel / 5.1 + int baseOffset = lpos * 6; + for (i=0, j= 0 ; i<linearCount ; i++, j+=2) + { + pOutput[baseOffset+0] = (snd_p[j]*volumeFactor)>>8; // FL + pOutput[baseOffset+1] = (snd_p[j + 1]*volumeFactor)>>8; // FR + + pOutput[baseOffset+2] = (snd_cp[j]*volumeFactor)>>8; // Center + // NOTE: Let the hardware mix the sub from the main channels since + // we don't have any sub-specific sounds, or direct sub-addressing + pOutput[baseOffset+3] = 0; + + pOutput[baseOffset+4] = (snd_rp[j]*volumeFactor)>>8; // RL + pOutput[baseOffset+5] = (snd_rp[j + 1]*volumeFactor)>>8; // RR + + + baseOffset += 6; + } + } + + snd_p += linearCount << 1; + snd_rp += linearCount << 1; + snd_cp += linearCount << 1; + + lpaintedtime += linearCount; + } + + pDSBuf->Unlock(pdwWrite, dwSize, NULL, 0); +} + +void CAudioDirectSound::S_TransferSurround16Interleaved( const portable_samplepair_t *pfront, const portable_samplepair_t *prear, const portable_samplepair_t *pcenter, int lpaintedtime, int endtime ) +{ + if ( !pDSBuf ) + return; + if ( !snd_lockpartial.GetBool() ) + { + S_TransferSurround16Interleaved_FullLock( pfront, prear, pcenter, lpaintedtime, endtime ); + return; + } + // take stereo front and rear paintbuffers, and center paintbuffer if provided, + // and copy samples into the 4 or 5 mono directsound buffers + + surround_transfer_t transfer; + transfer.snd_rp = (int *)prear; + transfer.snd_cp = (int *)pcenter; + transfer.snd_p = (int *)pfront; + + int sampleMonoCount = DeviceSampleCount()/DeviceChannels(); // number of full samples per output buffer + Assert(IsPowerOfTwo(sampleMonoCount)); + transfer.sampleMask = sampleMonoCount - 1; + transfer.paintedtime = lpaintedtime; + transfer.linearCount = endtime - lpaintedtime; + // paintedtime - number of full samples that have played since start + // endtime - number of full samples to play to - endtime is g_soundtime + mixahead samples + int channelCount = m_bSurroundCenter ? 6 : 4; + if ( DeviceChannels() == 2 ) + { + channelCount = 2; + } + transfer.channelCount = channelCount; + void *pBuffer0=NULL; + void *pBuffer1=NULL; + DWORD size0, size1; + int lpos = transfer.paintedtime & transfer.sampleMask; // lpos is next output position in output buffer + + int offset = lpos*2*channelCount; + int lockSize = transfer.linearCount*2*channelCount; + int reps = 0; + HRESULT hr; + while ( (hr = pDSBuf->Lock( offset, lockSize, &pBuffer0, &size0, &pBuffer1, &size1, 0 )) != DS_OK ) + { + if ( hr == DSERR_BUFFERLOST ) + { + if ( ++reps < 10000 ) + continue; + } + Msg ("DS::Lock Sound Buffer Failed\n"); + return; + } + + if ( pBuffer0 ) + { + transfer.pOutput = (short *)pBuffer0; + TransferSamplesToSurroundBuffer( size0 / (channelCount*2), transfer ); + } + if ( pBuffer1 ) + { + transfer.pOutput = (short *)pBuffer1; + TransferSamplesToSurroundBuffer( size1 / (channelCount*2), transfer ); + } + pDSBuf->Unlock(pBuffer0, size0, pBuffer1, size1); +} + |