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

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : StreamTrackDS.h
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 19/10/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Console.h"
#include "Common/Error.h"
#include "Common/Assert.h"
#include "Common/Directory.h"
#include "Wave/Wav.h"
#include "Wave/Ogg.h"
#include "Sound/SoundDS.h"

#include "Sound/StreamTrackDS.h"

//-------------------------------------------------------------------------------------------------------------------------
KStreamTrack::KStreamTrack()
{
        m_pWaveFile             = NULL;
        m_pDSBuffer             = NULL;
        m_pDSNotify             = NULL;
        m_hStopEvent1   = NULL;
        m_hStopEvent2   = NULL;
        m_Fade                  = KSTF_NONE;
        m_StartFade             = 0;
        m_EndFade               = 0;
}

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

//---------------------------------------------------------------------------------------------
bool KStreamTrack::LoadTrack( KStreamTrackBank* pStreamTrackBank, KStr& sFileName )
{
        KASSERT( !m_pWaveFile );
        KASSERT( !m_pDSBuffer );
        KASSERT( !m_pDSNotify );
        KASSERT( pStreamTrackBank );
        
        IDirectSound8*  pDS = pStreamTrackBank->GetSound()->GetDirectSound();
        HRESULT                 hr;
        
        // Determine le module de decompression à utiliser en fonction de l'extension
        char* pExtension = KFile::GetFileExtension( sFileName );
        if( !pExtension )
                return false;

        if( !stricmp( pExtension, "wav" ) )
        {
                // Wav
                m_pWaveFile = new KWav();
        }
        else if( !stricmp( pExtension, "ogg" ) )
        {
                // Ogg
                m_pWaveFile = new KOgg();
        }
        else
                return false;

        // Ouvre le Wave
        if( !m_pWaveFile->OpenWave( sFileName ) )
        {
                Deletep( m_pWaveFile );
                return false;
        }

        // Creation du Buffer Secondaire
        DSBUFFERDESC    dsdd;

        memset( &dsdd, 0, sizeof( dsdd ) );
        dsdd.dwSize                     = sizeof( dsdd );
        dsdd.dwFlags            = /*DSBCAPS_GLOBALFOCUS |*/ DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPOSITIONNOTIFY | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_LOCSOFTWARE;
        dsdd.dwBufferBytes      = m_pWaveFile->GetMaxBlockSize() * 2;
        dsdd.lpwfxFormat        = m_pWaveFile->GetWaveFormat();

        IDirectSoundBuffer*     pDSB;
        if( FAILED( hr = pDS->CreateSoundBuffer( &dsdd, &pDSB, NULL ) ) )
        {
                KError::FatalError( NULL, "KStreamTrack::LoadTrack(...) %s.", DXGetErrorString9( hr ) );
                return false;
        }

        if( FAILED( hr = pDSB->QueryInterface( IID_IDirectSoundBuffer8, (LPVOID*)&m_pDSBuffer ) ) )
        {
                KError::FatalError( NULL, "KStreamTrack::LoadTrack(...) %s.", DXGetErrorString9( hr ) );
                return false;
        }

        pDSB->Release();

        // Notify
        if( FAILED( hr = m_pDSBuffer->QueryInterface( IID_IDirectSoundNotify8, (LPVOID*)&m_pDSNotify ) ) )
        {
                KError::FatalError( NULL, "KStreamTrack::LoadTrack(...) %s.", DXGetErrorString9( hr ) );
                return false;
        }
        
        // Preremplissage
        CopyNextBlock( 0 );
        CopyNextBlock( 1 );
        
        // Event
        m_hStopEvent1 = CreateEvent( NULL, FALSE, FALSE, NULL );
        if( !m_hStopEvent1 )
                return false;

        m_hStopEvent2 = CreateEvent( NULL, FALSE, FALSE, NULL );
        if( !m_hStopEvent2 )
                return false;

        DSBPOSITIONNOTIFY       dspn[2];

        dspn[0].dwOffset                = m_pWaveFile->GetMaxBlockSize() - 1;
        dspn[0].hEventNotify    = m_hStopEvent1;
        dspn[1].dwOffset                = m_pWaveFile->GetMaxBlockSize() * 2 - 1;
        dspn[1].hEventNotify    = m_hStopEvent2;
        m_pDSNotify->SetNotificationPositions( 2, dspn );
        m_pDSNotify->Release();
        m_pDSNotify = NULL;

        m_sFileName = sFileName;

        return true;
}

//---------------------------------------------------------------------------------------------
bool KStreamTrack::UnloadTrack()
{
        if( m_hStopEvent1 )
        {
                CloseHandle( m_hStopEvent1 );
                m_hStopEvent1 = NULL;
        }
        
        if( m_hStopEvent2 )
        {
                CloseHandle( m_hStopEvent2 );
                m_hStopEvent2 = NULL;
        }
        
        if( m_pWaveFile )
        {
                m_pWaveFile->CloseWave();
                SafeDeletep( m_pWaveFile );
        }

        SafeRelease( m_pDSBuffer );
        SafeRelease( m_pDSNotify );

        return true;    
}

//-------------------------------------------------------------------------------------------------------------------------
bool KStreamTrack::Lock( void** pData, u32* Size, u32 StartOffset, u32 SizeToLock )
{
        HRESULT hr;

        if( FAILED( hr = m_pDSBuffer->Lock( StartOffset, SizeToLock, pData, Size, NULL, NULL, SizeToLock ? 0 : DSBLOCK_ENTIREBUFFER ) ) )
        {
                KError::Error( NULL, "KStreamTrack::Lock(...) %s.", DXGetErrorString9( hr ) );
                return false;
        }

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KStreamTrack::Unlock( void* pData, u32 Size )
{
        HRESULT hr;

        if( FAILED( hr = m_pDSBuffer->Unlock( pData, Size, NULL, NULL ) ) )
        {
                KError::Error( NULL, "KStreamTrack::Unlock(...) %s.", DXGetErrorString9( hr ) );
                return false;
        }

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KStreamTrack::Play( bool bFadeIn, KTIME FadeTime )
{
        KASSERT( m_pDSBuffer );

        HRESULT hr;

        if( bFadeIn )
        {
                m_Fade          = KSTF_IN;
                m_StartFade = g_Time.GetTime();
                m_EndFade       = m_StartFade + FadeTime;
        }
        else
        {
                m_Fade = KSTF_NONE;
                m_pDSBuffer->SetVolume( DSBVOLUME_MAX );
        }

        if( FAILED( hr = m_pDSBuffer->Play( 0, 0, true ) ) )
        {
                KError::Error( NULL, "KStreamTrack::Play(...) %s.", DXGetErrorString9( hr ) );
                return false;
        }

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KStreamTrack::Stop( bool bFadeOut, KTIME FadeTime )
{
        HRESULT hr;

        if( bFadeOut )
        {
                m_Fade          = KSTF_OUT;
                m_StartFade = g_Time.GetTime();
                m_EndFade       = m_StartFade + FadeTime;
        }
        else
        {
                m_Fade = KSTF_NONE;
                m_pDSBuffer->SetVolume( DSBVOLUME_MAX );
                
                if( FAILED( hr = m_pDSBuffer->Stop() ) )
                {
                        KError::Error( NULL, "KStreamTrack::Stop(...) %s.", DXGetErrorString9( hr ) );
                        return false;
                }
        }

        return true;
}


//-------------------------------------------------------------------------------------------------------------------------
void KStreamTrack::SetPlayPos( u32 Position )
{
        KASSERT( m_pDSBuffer );

        m_pDSBuffer->SetCurrentPosition( Position );
}

//-------------------------------------------------------------------------------------------------------------------------
bool KStreamTrack::IsPlaying()
{
        KASSERT( m_pDSBuffer );

        DWORD   Status;
        
        m_pDSBuffer->GetStatus( &Status );
        
        if( Status & DSBSTATUS_PLAYING )
                return true;

        return false;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KStreamTrack::CopyNextBlock( u32 BufferId )
{
        u32             SizeRead;
        u32             StartOffset;

        StartOffset = BufferId * m_pWaveFile->GetMaxBlockSize();
        
        // Lit le bloc suivant
        if( !m_pWaveFile->ReadNextBlock( &SizeRead ) )
        {
                return false;
//              m_pWaveFile->CloseWave();
//              Deletep( m_pWaveFile );
//              m_pDSBuffer->Release();
//              m_pDSBuffer = NULL;
        }

        // Fin du fichier wave?
        if( m_pWaveFile->IsEnd() )
        {
                //Stop();
                m_pWaveFile->Rewind();
//              return false;
        }

        KASSERT( SizeRead <= m_pWaveFile->GetMaxBlockSize() );

        // Si le bloc n'est pas complet, on ajoute du vide a la fin
        if( SizeRead < m_pWaveFile->GetMaxBlockSize() )
        {
                for( u32 i = SizeRead; i < m_pWaveFile->GetMaxBlockSize(); i ++ )
                {
                        m_pWaveFile->GetBlock()[i] = 0;
                }
                SizeRead = m_pWaveFile->GetMaxBlockSize();
        }

        if( SizeRead == 0 )
                return false;

        // Copie
        u8*             pBuffer = NULL;
        u32             Size = 0;

        Lock( (void**)&pBuffer, &Size, StartOffset, SizeRead );
        KASSERT( Size == SizeRead );
        memcpy( pBuffer, m_pWaveFile->GetBlock(), Size );       
        Unlock( (void*)pBuffer, Size );

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
bool KStreamTrack::Manage()
{
        KTIME   Time = g_Time.GetTime();
        float   delta = (float)( Time - m_StartFade ) / (float)( m_EndFade - m_StartFade );

        switch( m_Fade )
        {
        case KSTF_NONE:
                break;
        case KSTF_IN:
                {
                        if( delta > 1.0f )
                        {
                                delta   = 1.0f;
                                m_Fade  = KSTF_NONE;
                        }

                        LONG Volume = (LONG)( delta * (float)(DSBVOLUME_MAX - KDSBVOLUME_MIN)) + KDSBVOLUME_MIN;
                        m_pDSBuffer->SetVolume( Volume );
//                      g_Console << "Volume : " << Volume << KENDL;
                }
                break;
        case KSTF_OUT:
                {
                        if( delta > 1.0f )
                        {
                                delta   = 1.0f;
                                m_Fade  = KSTF_NONE;

                                HRESULT hr;
                                if( FAILED( hr = m_pDSBuffer->Stop() ) )
                                {
                                        KError::Error( NULL, "KStreamTrack::Manage(...) Stop failed\n%s.", DXGetErrorString9( hr ) );
                                        return false;
                                }
                        }

                        LONG Volume = (LONG)( (1.0f - delta) * (float)(DSBVOLUME_MAX - KDSBVOLUME_MIN)) + KDSBVOLUME_MIN;
                        m_pDSBuffer->SetVolume( Volume );
//                      g_Console << "Volume : " << Volume << KENDL;
                }
                break;
        }

        return true;
}

//-------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------
KStreamTrackBank::KStreamTrackBank( KSound* pSound )
{
        m_pSound                = pSound;
        m_nTracks               = 0;
}

//---------------------------------------------------------------------------------------------
KStreamTrackBank::~KStreamTrackBank()
{
        for(u32 i = 0;i < m_nTracks;i ++)
                Deletep( m_pTrack[i] );

        m_pTrack.Clear();
}

//---------------------------------------------------------------------------------------------
KStreamTrack* KStreamTrackBank::GetTrack( KSTREAMTRACK TrackId )
{
        KASSERT( TrackId < m_nTracks );
//      KASSERT( m_pTrack[TrackId] );

        return m_pTrack[TrackId];
}

//---------------------------------------------------------------------------------------------
KSTREAMTRACK KStreamTrackBank::LoadTrack( KStr& sFileName )
{
        KStr    sFullFileName;

        for( s32 Path = 0; Path < g_Directory.GetnPath(); Path ++ )
        {
                sFullFileName = g_Directory.GetPath( KStr( "Sounds" ), Path );
                sFullFileName += sFileName;
                
                KStreamTrack*   pTrack = NULL;
                KSTREAMTRACK    TrackId = 0;

                pTrack = new KStreamTrack();
                if( !pTrack->LoadTrack( this, sFullFileName ) )
                {
                        Deletep( pTrack );
                        continue;
                }

                TrackId = m_pTrack.Add( pTrack );
                m_nTracks ++;
                
                g_Console << "Sound loaded : " << sFileName.GetpString() << KENDL;

                return TrackId;
        }

        KError::Error( NULL, "KStreamTrackBank::LoadTrack(...) Cannot load sound %s.", sFileName.GetpString() );
        
        return KSTREAMTRACK_NO;
}

//---------------------------------------------------------------------------------------------
bool KStreamTrackBank::UnloadTrack( KSTREAMTRACK& Track )
{
        if( Track < 0 )
                return false;

        if( Track >= m_pTrack.GetSize() )
        {
                KError::Error( NULL, "KStreamTrackBank::UnloadTrack() : Invalid TrackId : %i", Track );
                return false;
        }

        m_pTrack[Track]->UnloadTrack();
        SafeDeletep( m_pTrack[Track] );

        Track = KSTREAMTRACK_NO;

        return true;
}

---