D:/Zythum/DinoKod/Sound/SoundDS.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : SoundDS.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 09/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Error.h"
#include "Common/Assert.h"

#include "Sound/SoundDS.h"

//-------------------------------------------------------------------------------------------------------------------------
KSound::KSound( HINSTANCE hInstance, HWND hWnd )
: KThread()
{
        m_hInstance                     = hInstance;
        m_hWnd                          = hWnd;
        m_pTrackBank            = NULL;
        m_pStreamTrackBank      = NULL;
        m_pDS                           = NULL;
        m_pDSL                          = NULL;
        m_pDSPrimary            = NULL;
        m_fVolume                       = 1.0f ;
}

//-------------------------------------------------------------------------------------------------------------------------
KSound::~KSound()
{
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::Init()
{
        HRESULT         hr;

        // DirectSound Init
        if( FAILED( hr = DirectSoundCreate8( NULL, &m_pDS, NULL ) ) )
        {
                KError::FatalError( m_hWnd, "KSound::Init() : DirectSoundCreate8(..) %s", DXGetErrorString9( hr ) );
                return false;
        }

        if( FAILED( hr = m_pDS->SetCooperativeLevel( m_hWnd, DSSCL_PRIORITY ) ) )
        {
                KError::FatalError( m_hWnd, "KSound::Init() : SetCooperativeLevel(...) %s", DXGetErrorString9( hr ) );
                return false;
        }

        DSBUFFERDESC                            dsbd;
        LPDIRECTSOUND3DLISTENER8        lp3DListener = NULL;

        ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) );
        dsbd.dwSize             = sizeof(DSBUFFERDESC);
        dsbd.dwFlags    = DSBCAPS_PRIMARYBUFFER | DSBCAPS_CTRL3D | DSBCAPS_CTRLVOLUME;

        if( SUCCEEDED( hr = m_pDS->CreateSoundBuffer( &dsbd, &m_pDSPrimary, NULL ) ) )
        {
                hr = m_pDSPrimary->QueryInterface( IID_IDirectSound3DListener8, (LPVOID*)&m_pDSL );
        }

        m_pTrackBank = new KTrackBank( this );
        m_pStreamTrackBank = new KStreamTrackBank( this );

        // Thread Init
//      SetPriority( KCTP_LOWEST );
        StartThread();

//      SetVolume(0.7f) ;

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::End()
{
        StopThread();

        SafeDeletep( m_pTrackBank );
        SafeRelease( m_pDSL );
        SafeRelease( m_pDSPrimary );
        SafeRelease( m_pDS );

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::Play( KTRACK TrackId, bool bLooping )
{
        if( TrackId == KTRACK_NO )
                return false;
        KASSERT( m_pTrackBank );
        
        KTrack* pTrack = m_pTrackBank->GetTrack( TrackId );

        if( pTrack )
        {
                // Arret le son s'il est déja en train d'etre joué
                if( pTrack->IsPlaying() )
                {
                        pTrack->Stop();
                        pTrack->SetPlayPos( 0 );
                }

                // Play
                pTrack->Play( bLooping );
        }

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::Stop( KTRACK TrackId )
{
        KASSERT( m_pTrackBank );
        
        KTrack* pTrack = m_pTrackBank->GetTrack( TrackId );

        if( pTrack )
                pTrack->Stop();

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
KTRACK KSound::LoadTrack( KStr& sFileName, KSTRACKTYPE TrackType )
{
        KASSERT( m_pTrackBank );
        return m_pTrackBank->LoadTrack( sFileName, TrackType );
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::UnloadTrack( KTRACK& Track )
{
        return m_pTrackBank->UnloadTrack( Track );
}

//-------------------------------------------------------------------------------------------------------------------------
void KSound::SetPosition( KTRACK TrackId, KVector& Position )
{
        KASSERT( m_pTrackBank );
        
        KTrack* pTrack = m_pTrackBank->GetTrack( TrackId );

        if( pTrack )
                pTrack->SetPosition( Position );
}

//-------------------------------------------------------------------------------------------------------------------------
void KSound::SetDistance( KTRACK TrackId, float Min, float Max )
{
        KASSERT( m_pTrackBank );
        
        KTrack* pTrack = m_pTrackBank->GetTrack( TrackId );

        if( pTrack )
                pTrack->SetDistance( Min, Max );
}

//-------------------------------------------------------------------------------------------------------------------------
void KSound::SetPosition( KVector& Position )
{
        KASSERT( m_pDSL );

        m_pDSL->SetPosition( Position.x, Position.z, Position.y, DS3D_DEFERRED );
}

//-------------------------------------------------------------------------------------------------------------------------
void KSound::SetOrientation( KVector& Front, KVector& Top )
{
        KASSERT( m_pDSL );

        m_pDSL->SetOrientation( Front.x, Front.z, Front.y, Top.x, Top.z, Top.y, DS3D_DEFERRED );
}

//-------------------------------------------------------------------------------------------------------------------------
void KSound::Manage3DSound( KVector& Position, KVector& Front, KVector& Top )
{
        KASSERT( m_pDSL );

        m_pDSL->CommitDeferredSettings();
        SetPosition( Position );
        SetOrientation( Front, Top );
}

//-------------------------------------------------------------------------------------------------------------------------
void KSound::SetVolume( float Volume )
{
        if( Volume < 0.0f )
                Volume = 0.0f;

        if( Volume > 1.0f )
                Volume = 1.0f;

        m_fVolume = Volume ;

        LONG lVolume = (LONG)( Volume * (float)(DSBVOLUME_MAX - KDSBVOLUME_MIN)) + KDSBVOLUME_MIN;

        m_pDSPrimary->SetVolume( lVolume );
}


//-------------------------------------------------------------------------------------------------------------------------
// STREAM
//-------------------------------------------------------------------------------------------------------------------------
KSTREAMTRACK KSound::LoadStreamTrack( KStr& sFileName )
{
        KSTREAMTRACK    Track;
        
        // Lock la TrackBank
        m_StreamTrackBankMutex.Lock();

        KASSERT( m_pStreamTrackBank );

        Track = m_pStreamTrackBank->LoadTrack( sFileName );

        // Unlock la StreamTrackBank
        m_StreamTrackBankMutex.Unlock();

        return Track;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::UnloadStreamTrack( KSTREAMTRACK& Track )
{
        bool    Result;
        
        // Lock la TrackBank
        m_StreamTrackBankMutex.Lock();

        KASSERT( m_pStreamTrackBank );

        Result = m_pStreamTrackBank->UnloadTrack( Track );

        // Unlock la StreamTrackBank
        m_StreamTrackBankMutex.Unlock();

        return Result;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::PlayStreamTrack( KSTREAMTRACK TrackId, bool bFadeIn, KTIME FadeTime )
{
        if( TrackId == KSTREAMTRACK_NO )
                return false;

        // Lock la StreamTrackBank
        m_StreamTrackBankMutex.Lock();

        KASSERT( m_pStreamTrackBank );
        
        KStreamTrack*   pTrack = m_pStreamTrackBank->GetTrack( TrackId );

        if( pTrack )
        {
                // Arrete le son s'il est déja en train d'etre joué
                if( pTrack->IsPlaying() )
                {
                        pTrack->Stop();
                        pTrack->SetPlayPos( 0 );
                }

                // Play
                pTrack->Play( bFadeIn, FadeTime );
        }

        // Unlock la StreamTrackBank
        m_StreamTrackBankMutex.Unlock();

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::StopStreamTrack( KTRACK TrackId, bool bFadeIn, KTIME FadeTime )
{
        // Lock la StreamTrackBank
        m_StreamTrackBankMutex.Lock();

        KASSERT( m_pStreamTrackBank );
        
        KStreamTrack*   pTrack = m_pStreamTrackBank->GetTrack( TrackId );

        if( pTrack )
                pTrack->Stop( bFadeIn, FadeTime );

        // Unlock la StreamTrackBank
        m_StreamTrackBankMutex.Unlock();

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KSound::ProcessStreamTrack()
{
        // Lock la TrackBank
        m_StreamTrackBankMutex.Lock();

        KASSERT( m_pStreamTrackBank );

//      KError::Debug( NULL, "KSound::ProcessBuffers()" );

        // Gere les streams
        KSTREAMTRACK            TrackId;
        for( TrackId = 0; TrackId < m_pStreamTrackBank->GetnTracks(); TrackId ++ )
        {
//              KError::Debug( NULL, "- Track %i", TrackId );
                KStreamTrack*           pTrack = m_pStreamTrackBank->GetTrack( TrackId );
                if( !pTrack )
                        continue;

                bool bStop1 = ( WaitForSingleObject( pTrack->GethStopEvent1(), 0 ) == WAIT_OBJECT_0 ) ? true : false;
                bool bStop2 = ( WaitForSingleObject( pTrack->GethStopEvent2(), 0 ) == WAIT_OBJECT_0 ) ? true : false;

                if( bStop1 )
                {
                        //ResetEvent( pTrack->GethStopEvent1() );
                        pTrack->CopyNextBlock( 0 );
//                              KError::Debug( NULL, "Track %i Buffer 0 %i %i %s", TrackId, pTrack->GethStopEvent1(), timeGetTime(), pTrack->GetFileName() );
                }

                if( bStop2 )
                {
                        //ResetEvent( pTrack->GethStopEvent2() );
                        pTrack->CopyNextBlock( 1 );
//                              KError::Debug( NULL, "Track %i Buffer 1 %i %i %s", TrackId, pTrack->GethStopEvent2(), timeGetTime(), pTrack->GetFileName() );
                }

                // Manage la piste
                pTrack->Manage();
        }

        // Unlock la TrackBank
        m_StreamTrackBankMutex.Unlock();

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
u32 KSound::ThreadProc()
{
        while( IsThreadRunning() )
        {
                //KError::Debug( NULL, "Process Buffer" );
                ProcessStreamTrack();
                Sleep( 10 );
        }

        return 0;
}

//-------------------------------------------------------------------------------------------------------------------------
KStreamTrackBank* KSound::LockStreamTrackBank()
{
        m_StreamTrackBankMutex.Lock();

        return m_pStreamTrackBank;
}

//-------------------------------------------------------------------------------------------------------------------------
void KSound::UnlockStreamTrackBank( KStreamTrackBank** pStreamTrackBank )
{
        KASSERT( *pStreamTrackBank == m_pStreamTrackBank );

        *pStreamTrackBank = NULL;

        m_StreamTrackBankMutex.Unlock();
}

---