win_snd.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#include "../../idlib/precompiled.h"
#pragma hdrstop

// DirectX SDK
#include <DxErr.h>

#include <ks.h>
#include <ksmedia.h>
#include "../../sound/snd_local.h"
#include "win_local.h"

#include "../../openal/idal.cpp"

#define SAFE_DELETE(p)       { if(p) { delete (p);     (p)=NULL; } }
#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p);   (p)=NULL; } }
#define SAFE_RELEASE(p)      { if(p) { (p)->Release(); (p)=NULL; } }

class idAudioBufferWIN32 : public idAudioBuffer {
public:
    idAudioBufferWIN32( LPDIRECTSOUNDBUFFER apDSBuffer, dword dwDSBufferSize, idWaveFile* pWaveFile=NULL );
    ~idAudioBufferWIN32();

    int FillBufferWithSound( LPDIRECTSOUNDBUFFER pDSB, bool bRepeatWavIfBufferLarger );

        bool Lock( void **pDSLockedBuffer, ulong *dwDSLockedBufferSize );
        bool Unlock(void *pDSLockedBuffer, dword dwDSLockedBufferSize );
        bool GetCurrentPosition( ulong *pdwCurrentWriteCursor );

    int Play( dword dwPriority=0, dword dwFlags=0 );
    int Stop( void );
    int Reset( void );
    bool    IsSoundPlaying( void );
        void SetVolume( float x);

    idWaveFile*                 m_pWaveFile;
private:
    LPDIRECTSOUNDBUFFER         m_apDSBuffer;
    dword                                       m_dwDSBufferSize;

    int RestoreBuffer( LPDIRECTSOUNDBUFFER pDSB, bool* pbWasRestored );
};

class idAudioHardwareWIN32 : public idAudioHardware {

public:
    idAudioHardwareWIN32();
    ~idAudioHardwareWIN32();

    bool Initialize( );
        bool InitializeSpeakers( byte *buffer, int bufferSize, dword dwPrimaryFreq, dword dwPrimaryBitRate, dword dwSpeakers );

        void SetPrimaryBufferFormat( dword dwPrimaryFreq, dword dwPrimaryBitRate, dword dwSpeakers );

    int Create( idWaveFile* pWaveFile, idAudioBuffer** ppiab );
    int Create( idAudioBuffer** ppSound, const char* strWaveFileName, dword dwCreationFlags = 0 );
    int CreateFromMemory( idAudioBufferWIN32** ppSound, byte* pbData, ulong ulDataSize, waveformatextensible_t *pwfx, dword dwCreationFlags = 0 );

        bool Lock( void **pDSLockedBuffer, ulong *dwDSLockedBufferSize );
        bool Unlock( void *pDSLockedBuffer, dword dwDSLockedBufferSize );
        bool GetCurrentPosition( ulong *pdwCurrentWriteCursor );
        
        int                             GetNumberOfSpeakers()                           { return numSpeakers; }
        int                             GetMixBufferSize()                                      { return MIXBUFFER_SAMPLES * blockAlign; }

        // WIN32 driver doesn't support write API
        bool Flush( void ) { return true; }
        void Write( bool ) { }
        short* GetMixBuffer( void ) { return NULL; }

private:
    LPDIRECTSOUND                       m_pDS;
    LPDIRECTSOUNDBUFFER         pDSBPrimary;
        idAudioBufferWIN32              *speakers;

        int                                             numSpeakers;
        int                                             bitsPerSample;
        int                                             bufferSize;             // allocate buffer handed over to DirectSound
        int                                             blockAlign;             // channels * bits per sample / 8: sound frame size
};

idAudioHardware *idAudioHardware::Alloc() { return new idAudioHardwareWIN32; }
idAudioHardware::~idAudioHardware() {}

/*
================
idAudioHardwareWIN32::idAudioHardware
================
*/
idAudioHardwareWIN32::idAudioHardwareWIN32() {
    m_pDS = NULL;
        pDSBPrimary = NULL;
        speakers = NULL;
}

/*
================
idAudioHardwareWIN32::~idAudioHardware
================
*/
idAudioHardwareWIN32::~idAudioHardwareWIN32() {
        SAFE_DELETE( speakers );
        SAFE_RELEASE( pDSBPrimary );
    SAFE_RELEASE( m_pDS ); 
}

/*
===============
idAudioHardwareWIN32::Initialize
===============
*/
bool idAudioHardwareWIN32::Initialize( void ) {
    int             hr;

        bufferSize = 0;
        numSpeakers = 0;
        blockAlign = 0;

    SAFE_RELEASE( m_pDS );

    // Create IDirectSound using the primary sound device
    if( FAILED( hr = DirectSoundCreate( NULL, &m_pDS, NULL ) )) {
        return false;
        }

    // Set primary buffer format
        SetPrimaryBufferFormat( PRIMARYFREQ, 16, idSoundSystemLocal::s_numberOfSpeakers.GetInteger() );
        return true;
}

/*
===============
idAudioHardwareWIN32::InitializeSpeakers
===============
*/
bool idAudioHardwareWIN32::InitializeSpeakers( byte *speakerData, int bufferSize, dword dwPrimaryFreq, dword dwPrimaryBitRate, dword dwSpeakers ) {
        if ( dwSpeakers == 2 ) {
                WAVEFORMATEXTENSIBLE wfx;
                ZeroMemory( &wfx, sizeof(WAVEFORMATEXTENSIBLE) ); 
                wfx.Format.wFormatTag      = WAVE_FORMAT_PCM; 
                wfx.Format.nChannels       = 2; 
                wfx.Format.nSamplesPerSec  = dwPrimaryFreq;
                wfx.Format.wBitsPerSample  = dwPrimaryBitRate; 
                wfx.Format.nBlockAlign     = wfx.Format.wBitsPerSample / 8 * wfx.Format.nChannels;
                wfx.Format.nAvgBytesPerSec = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
                wfx.Format.cbSize = sizeof(WAVEFORMATEX);

                CreateFromMemory( &speakers, speakerData, bufferSize, (waveformatextensible_t *)&wfx );

                common->Printf("sound: STEREO\n");
        } else {
                WAVEFORMATEXTENSIBLE    waveFormatPCMEx;
                ZeroMemory( &waveFormatPCMEx, sizeof(WAVEFORMATEXTENSIBLE) ); 

                waveFormatPCMEx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
                waveFormatPCMEx.Format.nChannels = 6;
                waveFormatPCMEx.Format.nSamplesPerSec = dwPrimaryFreq;
                waveFormatPCMEx.Format.wBitsPerSample  = dwPrimaryBitRate;
                waveFormatPCMEx.Format.nBlockAlign = waveFormatPCMEx.Format.wBitsPerSample / 8 * waveFormatPCMEx.Format.nChannels;
                waveFormatPCMEx.Format.nAvgBytesPerSec = waveFormatPCMEx.Format.nSamplesPerSec * waveFormatPCMEx.Format.nBlockAlign;
                waveFormatPCMEx.dwChannelMask = KSAUDIO_SPEAKER_5POINT1;
                                                                         // SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT |
                                                                         // SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY |
                                                                         // SPEAKER_BACK_LEFT  | SPEAKER_BACK_RIGHT
                waveFormatPCMEx.SubFormat =  KSDATAFORMAT_SUBTYPE_PCM;  // Specify PCM
                waveFormatPCMEx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE);
                waveFormatPCMEx.Samples.wValidBitsPerSample = 16;

                CreateFromMemory( &speakers, speakerData, bufferSize, (waveformatextensible_t *)&waveFormatPCMEx );

                common->Printf("sound: MULTICHANNEL\n");
        }

        if (!speakers) {
                return false;
        }

        speakers->Play(0,DSBPLAY_LOOPING);

        return true;
}

/*
===============
idAudioHardwareWIN32::SetPrimaryBufferFormat
Set primary buffer to a specified format 
For example, to set the primary buffer format to 22kHz stereo, 16-bit
then:   dwPrimaryChannels = 2
        dwPrimaryFreq     = 22050, 
        dwPrimaryBitRate  = 16
===============
*/
void idAudioHardwareWIN32::SetPrimaryBufferFormat( dword dwPrimaryFreq, dword dwPrimaryBitRate, dword dwSpeakers ) {
    HRESULT             hr;

    if( m_pDS == NULL ) {
        return;
        }

        ulong cfgSpeakers;
        m_pDS->GetSpeakerConfig( &cfgSpeakers );

        DSCAPS dscaps; 
        dscaps.dwSize = sizeof(DSCAPS); 
    m_pDS->GetCaps(&dscaps); 

        if (dscaps.dwFlags & DSCAPS_EMULDRIVER) {
                return;
        }

        // Get the primary buffer 
    DSBUFFERDESC dsbd;
    ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) );
    dsbd.dwSize        = sizeof(DSBUFFERDESC);
    dsbd.dwFlags       = DSBCAPS_PRIMARYBUFFER;
    dsbd.dwBufferBytes = 0;
    dsbd.lpwfxFormat   = NULL;
       
        // Obtain write-primary cooperative level. 
        if( FAILED( hr = m_pDS->SetCooperativeLevel(win32.hWnd, DSSCL_PRIORITY ) ) ) {
        DXTRACE_ERR( TEXT("SetPrimaryBufferFormat"), hr );
                return;
        }

        if( FAILED( hr = m_pDS->CreateSoundBuffer( &dsbd, &pDSBPrimary, NULL ) ) ) {
                return;
        }

        if ( dwSpeakers == 6 && (cfgSpeakers == DSSPEAKER_5POINT1 || cfgSpeakers == DSSPEAKER_SURROUND) ) {
                WAVEFORMATEXTENSIBLE    waveFormatPCMEx;
                ZeroMemory( &waveFormatPCMEx, sizeof(WAVEFORMATEXTENSIBLE) ); 

                waveFormatPCMEx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
                waveFormatPCMEx.Format.nChannels = 6;
                waveFormatPCMEx.Format.nSamplesPerSec = dwPrimaryFreq;
                waveFormatPCMEx.Format.wBitsPerSample  = (WORD) dwPrimaryBitRate; 
                waveFormatPCMEx.Format.nBlockAlign = waveFormatPCMEx.Format.wBitsPerSample / 8 * waveFormatPCMEx.Format.nChannels;
                waveFormatPCMEx.Format.nAvgBytesPerSec = waveFormatPCMEx.Format.nSamplesPerSec * waveFormatPCMEx.Format.nBlockAlign;
                waveFormatPCMEx.dwChannelMask = KSAUDIO_SPEAKER_5POINT1;
                                                                         // SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT |
                                                                         // SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY |
                                                                         // SPEAKER_BACK_LEFT  | SPEAKER_BACK_RIGHT
                waveFormatPCMEx.SubFormat =  KSDATAFORMAT_SUBTYPE_PCM;  // Specify PCM
                waveFormatPCMEx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE);
                waveFormatPCMEx.Samples.wValidBitsPerSample = 16;

                if( FAILED( hr = pDSBPrimary->SetFormat((WAVEFORMATEX*)&waveFormatPCMEx) ) ) {
                DXTRACE_ERR( TEXT("SetPrimaryBufferFormat"), hr );
                        return;
                }
                numSpeakers = 6;                // force it to think 5.1
                blockAlign = waveFormatPCMEx.Format.nBlockAlign;
        } else {
                if (dwSpeakers == 6) {
                        common->Printf("sound: hardware reported unable to use multisound, defaulted to stereo\n");
                }
                WAVEFORMATEX wfx;
                ZeroMemory( &wfx, sizeof(WAVEFORMATEX) ); 
                wfx.wFormatTag      = WAVE_FORMAT_PCM; 
                wfx.nChannels       = 2; 
                wfx.nSamplesPerSec  = dwPrimaryFreq; 
                wfx.wBitsPerSample  = (WORD) dwPrimaryBitRate; 
                wfx.nBlockAlign     = wfx.wBitsPerSample / 8 * wfx.nChannels;
                wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
                wfx.cbSize = sizeof(WAVEFORMATEX);

                if( FAILED( hr = pDSBPrimary->SetFormat(&wfx) ) ) {
                        return;
                }
                numSpeakers = 2;                // force it to think stereo
                blockAlign = wfx.nBlockAlign;
        }

        byte *speakerData;
        bufferSize = MIXBUFFER_SAMPLES * sizeof(word) * numSpeakers * ROOM_SLICES_IN_BUFFER;
        speakerData = (byte *)Mem_Alloc( bufferSize );
        memset( speakerData, 0, bufferSize );

        InitializeSpeakers( speakerData, bufferSize, dwPrimaryFreq, dwPrimaryBitRate, numSpeakers );
}

/*
===============
idAudioHardwareWIN32::Create
===============
*/
int idAudioHardwareWIN32::Create( idAudioBuffer** ppSound, 
                               const char* strWaveFileName, 
                                                           dword dwCreationFlags ) {
    int hr;
    LPDIRECTSOUNDBUFFER   apDSBuffer     = NULL;
    dword                 dwDSBufferSize = NULL;
    idWaveFile*          pWaveFile      = NULL;

    if( m_pDS == NULL )
        return -1;
    if( strWaveFileName == NULL || ppSound == NULL )
        return -1;

        pWaveFile = new idWaveFile();

    pWaveFile->Open( strWaveFileName, NULL );

    if( pWaveFile->GetOutputSize() == 0 )     {
        // Wave is blank, so don't create it.
        hr = E_FAIL;
        goto LFail;
    }

    // Make the DirectSound buffer the same size as the wav file
    dwDSBufferSize = pWaveFile->GetOutputSize();

    // Create the direct sound buffer, and only request the flags needed
    // since each requires some overhead and limits if the buffer can 
    // be hardware accelerated
    DSBUFFERDESC dsbd;
    memset( &dsbd, 0, sizeof(DSBUFFERDESC) );
    dsbd.dwSize          = sizeof(DSBUFFERDESC);
    dsbd.dwFlags         = dwCreationFlags;
    dsbd.dwBufferBytes   = dwDSBufferSize;
    dsbd.guid3DAlgorithm = GUID_NULL;
    dsbd.lpwfxFormat     = (WAVEFORMATEX*)&pWaveFile->mpwfx;

    // DirectSound is only guarenteed to play PCM data.  Other
    // formats may or may not work depending the sound card driver.
    if( FAILED( hr = m_pDS->CreateSoundBuffer( &dsbd, &apDSBuffer, NULL ) ) )
                return -1;

    // Create the sound
    *ppSound = new idAudioBufferWIN32( apDSBuffer, dwDSBufferSize, pWaveFile );
    
    pWaveFile->Close();

    return 0;

LFail:
    // Cleanup
    SAFE_DELETE( pWaveFile );
    return -1;
}

/*
===============
idAudioHardwareWIN32::Create
===============
*/
int idAudioHardwareWIN32::Create( idWaveFile* pWaveFile, idAudioBuffer** ppiab ) {
    int hr;
    LPDIRECTSOUNDBUFFER   apDSBuffer     = NULL;
    dword                dwDSBufferSize = NULL;

    if( m_pDS == NULL )
        return -1;

    if( pWaveFile == NULL )
        return -1;

        *ppiab = NULL;

    if( pWaveFile->GetOutputSize() == 0 )     {
        // Wave is blank, so don't create it.
        hr = E_FAIL;
        goto LFail;
    }

    // Make the DirectSound buffer the same size as the wav file
    dwDSBufferSize = pWaveFile->GetOutputSize();

    // Create the direct sound buffer, and only request the flags needed
    // since each requires some overhead and limits if the buffer can 
    // be hardware accelerated
    DSBUFFERDESC dsbd;
    memset( &dsbd, 0, sizeof(DSBUFFERDESC) );
    dsbd.dwSize          = sizeof(DSBUFFERDESC);
    dsbd.dwFlags         = 0;
    dsbd.dwBufferBytes   = dwDSBufferSize;
    dsbd.guid3DAlgorithm = GUID_NULL;
    dsbd.lpwfxFormat     = (WAVEFORMATEX*)&pWaveFile->mpwfx;

    // DirectSound is only guarenteed to play PCM data.  Other
    // formats may or may not work depending the sound card driver.
    if( FAILED( hr = m_pDS->CreateSoundBuffer( &dsbd, &apDSBuffer, NULL ) ) )
                return -1;

    // Create the sound
    *ppiab = new idAudioBufferWIN32( apDSBuffer, dwDSBufferSize, pWaveFile );
    
    return 0;

LFail:
    // Cleanup
    SAFE_DELETE( pWaveFile );
    return -1;
}

//-----------------------------------------------------------------------------
// Name: idAudioHardwareWIN32::CreateFromMemory()
// Desc: 
//-----------------------------------------------------------------------------
int idAudioHardwareWIN32::CreateFromMemory( idAudioBufferWIN32** ppSound, 
                                        byte* pbData,
                                        ulong  ulDataSize,
                                        waveformatextensible_t* pwfx,
                                                                                dword dwCreationFlags ) {
    int hr;
    LPDIRECTSOUNDBUFFER         apDSBuffer     = NULL;
    dword                                       dwDSBufferSize = NULL;
    idWaveFile*                 pWaveFile      = NULL;

    if( m_pDS == NULL )
        return -1;
    if( pbData == NULL || ppSound == NULL )
        return -1;

    pWaveFile = new idWaveFile();

    pWaveFile->OpenFromMemory( (short *)pbData, ulDataSize, (waveformatextensible_t *)pwfx);


    // Make the DirectSound buffer the same size as the wav file
    dwDSBufferSize = ulDataSize;

    // Create the direct sound buffer, and only request the flags needed
    // since each requires some overhead and limits if the buffer can 
    // be hardware accelerated
    DSBUFFERDESC dsbd;
    memset( &dsbd, 0, sizeof(DSBUFFERDESC) );
    dsbd.dwSize          = sizeof(DSBUFFERDESC);
    dsbd.dwFlags         = dwCreationFlags | DSBCAPS_GETCURRENTPOSITION2;
    dsbd.dwBufferBytes   = dwDSBufferSize;
    dsbd.guid3DAlgorithm = GUID_NULL;
    dsbd.lpwfxFormat     = (WAVEFORMATEX *)pwfx;

    if( FAILED( hr = m_pDS->CreateSoundBuffer( &dsbd, &apDSBuffer, NULL ) ) )
                return -1;

    // Create the sound
    *ppSound = new idAudioBufferWIN32( apDSBuffer, dwDSBufferSize, pWaveFile );

    return S_OK;
}

/*
===============
idAudioHardwareWIN32::Lock
===============
*/
bool idAudioHardwareWIN32::Lock( void **pDSLockedBuffer, ulong *dwDSLockedBufferSize ) {
        if (speakers) {
                return speakers->Lock( pDSLockedBuffer, dwDSLockedBufferSize );
        }
        return false;
}

/*
===============
idAudioHardwareWIN32::Unlock
===============
*/
bool idAudioHardwareWIN32::Unlock(void *pDSLockedBuffer, dword dwDSLockedBufferSize ) {
        if (speakers) {
                return speakers->Unlock( pDSLockedBuffer, dwDSLockedBufferSize );
        }
        return false;
}

/*
===============
idAudioHardwareWIN32::GetCurrentPosition
===============
*/
bool idAudioHardwareWIN32::GetCurrentPosition( ulong *pdwCurrentWriteCursor ) {
        if (speakers) {
                return speakers->GetCurrentPosition( pdwCurrentWriteCursor );
        }
        return false;
}

static HMODULE hOpenAL = NULL;

/*
===============
Sys_LoadOpenAL
===============
*/
bool Sys_LoadOpenAL( void ) {
#if ID_OPENAL
        const char *sym;

        if ( hOpenAL ) {
                return true;
        }

        hOpenAL = LoadLibrary( idSoundSystemLocal::s_libOpenAL.GetString() );
        if ( !hOpenAL ) {
                common->Warning( "LoadLibrary %s failed.", idSoundSystemLocal::s_libOpenAL.GetString() );
                return false;
        }
        if ( ( sym = InitializeIDAL( hOpenAL ) ) ) {
                common->Warning( "GetProcAddress %s failed.", sym );
                FreeLibrary( hOpenAL );
                hOpenAL = NULL;
                return false;
        }
        return true;
#else
        return false;
#endif
}

/*
===============
Sys_FreeOpenAL
===============
*/
void Sys_FreeOpenAL( void ) {
        if ( hOpenAL ) {
                FreeLibrary( hOpenAL );
                hOpenAL = NULL;
        }
}

/*
===============
idAudioBufferWIN32::idAudioBuffer
===============
*/
idAudioBufferWIN32::idAudioBufferWIN32( LPDIRECTSOUNDBUFFER apDSBuffer, dword dwDSBufferSize, idWaveFile* pWaveFile ) {

    m_apDSBuffer = apDSBuffer;

    m_dwDSBufferSize = dwDSBufferSize;
    m_pWaveFile      = pWaveFile;

        if (pWaveFile) {
            FillBufferWithSound( m_apDSBuffer, false );

                m_apDSBuffer->SetCurrentPosition(0);
        }
}

/*
===============
idAudioBufferWIN32::~idAudioBuffer
===============
*/
idAudioBufferWIN32::~idAudioBufferWIN32() {
        SAFE_DELETE(m_pWaveFile);
        SAFE_RELEASE( m_apDSBuffer ); 
        m_pWaveFile = NULL;
        m_apDSBuffer = NULL;
}

/*
===============
idAudioBufferWIN32::FillBufferWithSound
===============
*/
int idAudioBufferWIN32::FillBufferWithSound( LPDIRECTSOUNDBUFFER pDSB, bool bRepeatWavIfBufferLarger ) {
    int hr; 
    void*   pDSLockedBuffer      = NULL; // Pointer to locked buffer memory
    ulong   dwDSLockedBufferSize = 0;    // Size of the locked DirectSound buffer
    int         dwWavDataRead        = 0;    // Amount of data read from the wav file 

    if( pDSB == NULL )
        return -1;

        // we may not even have a wavefile
        if (m_pWaveFile==NULL) {
                return -1;
        }

    // Make sure we have focus, and we didn't just switch in from
    // an app which had a DirectSound device
    if( FAILED( hr = RestoreBuffer( pDSB, NULL ) ) ) {
        DXTRACE_ERR( TEXT("RestoreBuffer"), hr );
                return -1;
        }

    // Lock the buffer down
    if( FAILED( hr = pDSB->Lock( 0, m_dwDSBufferSize, &pDSLockedBuffer, &dwDSLockedBufferSize, NULL, NULL, 0L ) ) ) {
        DXTRACE_ERR( TEXT("Lock"), hr );
                return -1;
        }

    // Reset the wave file to the beginning 
    m_pWaveFile->ResetFile();

    if( FAILED( hr = m_pWaveFile->Read( (byte*) pDSLockedBuffer, dwDSLockedBufferSize, &dwWavDataRead ) ) ) {
        return DXTRACE_ERR( TEXT("Read"), hr );
        }

    if( dwWavDataRead == 0 ) {
        // Wav is blank, so just fill with silence
        memset( pDSLockedBuffer, (byte)(m_pWaveFile->mpwfx.Format.wBitsPerSample == 8 ? 128 : 0 ), dwDSLockedBufferSize );
    }  else if( dwWavDataRead < (int)dwDSLockedBufferSize ) {
        // If the wav file was smaller than the DirectSound buffer, 
        // we need to fill the remainder of the buffer with data 
        if( bRepeatWavIfBufferLarger ) {       
            // Reset the file and fill the buffer with wav data
            int dwReadSoFar = dwWavDataRead;    // From previous call above.
            while( dwReadSoFar < (int)dwDSLockedBufferSize ) {  
                // This will keep reading in until the buffer is full 
                // for very short files
                if( FAILED( hr = m_pWaveFile->ResetFile() ) ) {
                    return DXTRACE_ERR( TEXT("ResetFile"), hr );
                                }

                hr = m_pWaveFile->Read( (byte*)pDSLockedBuffer + dwReadSoFar, dwDSLockedBufferSize - dwReadSoFar, &dwWavDataRead );
                if( FAILED(hr) ) {
                    return DXTRACE_ERR( TEXT("Read"), hr );
                                }

                dwReadSoFar += dwWavDataRead;
            } 
        } else {
            // Don't repeat the wav file, just fill in silence 
            memset( (byte*) pDSLockedBuffer + dwWavDataRead, (byte)(m_pWaveFile->mpwfx.Format.wBitsPerSample == 8 ? 128 : 0 ), dwDSLockedBufferSize - dwWavDataRead);
        }
    }

    // Unlock the buffer, we don't need it anymore.
    pDSB->Unlock( pDSLockedBuffer, dwDSLockedBufferSize, NULL, 0 );

    return S_OK;
}

/*
===============
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;
    }
}

/*
===============
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;
}

/*
===============
idAudioBufferWIN32::Stop
Desc: Stops the sound from playing
===============
*/
int idAudioBufferWIN32::Stop() {
    if( this == NULL || m_apDSBuffer == NULL ) {
        return -1;
        }

        m_apDSBuffer->Stop();

    return 0;
}

/*
===============
idAudioBufferWIN32::Reset
Desc: Reset all of the sound buffers
===============
*/
int idAudioBufferWIN32::Reset() {
    if( m_apDSBuffer == NULL ) {
        return -1;
        }

    m_apDSBuffer->SetCurrentPosition( 0 );

    return 0;
}

/*
===============
idAudioBufferWIN32::IsSoundPlaying
Desc: Checks to see if a buffer is playing and returns true if it
===============
*/
bool idAudioBufferWIN32::IsSoundPlaying( ) {
    if( m_apDSBuffer == NULL ) {
        return false;
        }

        if( m_apDSBuffer ) {  
                ulong dwStatus = 0;
        m_apDSBuffer->GetStatus( &dwStatus );
        if ( dwStatus & DSBSTATUS_PLAYING ) {
                        return true;
                }
        }
        return false;
}

/*
===============
idAudioBufferWIN32::Lock
===============
*/
bool idAudioBufferWIN32::Lock( void **pDSLockedBuffer, ulong *dwDSLockedBufferSize ) {
        int hr;
    // Restore the buffer if it was lost
    bool bRestored;
    if( FAILED( hr = RestoreBuffer( m_apDSBuffer, &bRestored ) ) ) {
        return false;
        }

    // Lock the DirectSound buffer
    if( FAILED( hr = m_apDSBuffer->Lock( 0, m_dwDSBufferSize, pDSLockedBuffer, dwDSLockedBufferSize, NULL, NULL, 0 ) ) ) {
        return false;
        }
        return true;
}

/*
===============
idAudioBufferWIN32::Unlock
===============
*/
bool idAudioBufferWIN32::Unlock(void *pDSLockedBuffer, dword dwDSLockedBufferSize ) {
    // Unlock the DirectSound buffer
    m_apDSBuffer->Unlock( pDSLockedBuffer, dwDSLockedBufferSize, NULL, 0 );
        return true;
}

/*
===============
idAudioBufferWIN32::GetCurrentPosition
===============
*/
bool idAudioBufferWIN32::GetCurrentPosition( ulong *pdwCurrentWriteCursor ) {
        int hr;

    // Make sure we have focus, and we didn't just switch in from
    // an app which had a DirectSound device
    if( FAILED( hr = RestoreBuffer( m_apDSBuffer, NULL ) ) ) {
        DXTRACE_ERR( TEXT("RestoreBuffer"), hr );
                return false;
        }

    if( FAILED( hr = m_apDSBuffer->GetCurrentPosition( NULL, pdwCurrentWriteCursor ) ) ) {
        return false;
        }
        return true;
}

/*
===============
idAudioBufferWIN32::SetVolume
===============
*/
void idAudioBufferWIN32::SetVolume( float x) {
        if (m_apDSBuffer) {
                m_apDSBuffer->SetVolume(x);
        }
}