CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program 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.

This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "HeadSpin.h"
#include "hsGeometry3.h"
#include "hsResMgr.h"
#include "plgDispatch.h"
#include "plProfile.h"
#include "plWin32StaticSound.h"
#include "plWin32Sound.h"
#include "plDSoundBuffer.h"
#include "plAudioSystem.h"
#include "plAudioCore/plSoundBuffer.h"
#include "plAudioCore/plSoundDeswizzler.h"
#include "pnMessage/plEventCallbackMsg.h"
#include "pnMessage/plAudioSysMsg.h"
#include "plMessage/plLinkToAgeMsg.h"
#include "plMessage/plAvatarMsg.h"

#include "plPipeline/plPlates.h"
#include "plStatusLog/plStatusLog.h"

plProfile_Extern(MemSounds);
plProfile_CreateAsynchTimer( "Static Shove Time", "Sound", StaticSndShoveTime );
plProfile_CreateAsynchTimer( "Static Swizzle Time", "Sound", StaticSwizzleTime );

plWin32StaticSound::plWin32StaticSound()
{
}

plWin32StaticSound::~plWin32StaticSound()
{
    DeActivate();
    IUnloadDataBuffer();
}

void plWin32StaticSound::Activate( hsBool forcePlay )
{
    plWin32Sound::Activate( forcePlay );
}

void plWin32StaticSound::DeActivate()
{
    plWin32Sound::DeActivate();
}

hsBool plWin32StaticSound::LoadSound( hsBool is3D )
{
    if (fFailed)
        return false;

    if( fPriority > plgAudioSys::GetPriorityCutoff() )
        return false;   // Don't set the failed flag, just return

    if (plgAudioSys::Active() && !fDSoundBuffer)
    {
        // Debug flag #1
        if( fChannelSelect > 0 && plgAudioSys::IsDebugFlagSet( plgAudioSys::kDisableRightSelect ) )
        {
            // Force a fail
            fFailed = true;
            return false;
        }

        // We need it to be resident to read in
        plSoundBuffer::ELoadReturnVal retVal = IPreLoadBuffer(true);
        plSoundBuffer *buffer = (plSoundBuffer *)fDataBufferKey->ObjectIsLoaded();  
        if(!buffer)
        {
            return plSoundBuffer::kError;
        }

        if( retVal == plSoundBuffer::kPending)  // we are still reading data. 
        {
            return true;
        }

        if( retVal == plSoundBuffer::kError )
        {
            char str[ 256 ];
            sprintf( str, "Unable to open .wav file %s", fDataBufferKey ? fDataBufferKey->GetName() : "nil");
            IPrintDbgMessage( str, true );
            fFailed = true;
            return false;
        }
        
        SetProperty( kPropIs3DSound, is3D );

        plWAVHeader header = buffer->GetHeader();

        // Debug flag #2
        if( fChannelSelect == 0 && header.fNumChannels > 1 && plgAudioSys::IsDebugFlagSet( plgAudioSys::kDisableLeftSelect ) )
        {
            // Force a fail
            fFailed = true;
            return false;
        }
        UInt32 bufferSize = buffer->GetDataLength();

        if( header.fNumChannels > 1 && is3D )
        {
            // We can only do a single channel of 3D sound. So copy over one (later)
            bufferSize              /= header.fNumChannels;
            header.fBlockAlign      /= header.fNumChannels;
            header.fAvgBytesPerSec  /= header.fNumChannels;
            header.fNumChannels = 1;
        }

        hsBool tryStatic = true;
        // If we want FX, we can't use a static voice, but EAX doesn't fit under that limitation :)
        if( 0 )
            tryStatic = false;

        // Create our DSound buffer (or rather, the wrapper around it)
        fDSoundBuffer = TRACKED_NEW plDSoundBuffer( bufferSize, header, is3D, IsPropertySet( kPropLooping ), tryStatic );
        if( !fDSoundBuffer->IsValid() )
        {
            char str[256];
            sprintf(str, "Can't create sound buffer for %s.wav. This could happen if the wav file is a stereo file. Stereo files are not supported on 3D sounds. If the file is not stereo then please report this error.", GetFileName());
            IPrintDbgMessage( str, true );
            fFailed = true;

            delete fDSoundBuffer;
            fDSoundBuffer = nil;

            return false;
        }
    
        plProfile_BeginTiming( StaticSndShoveTime );

        if(!fDSoundBuffer->FillBuffer(buffer->GetData(), buffer->GetDataLength(), &header))
        {
            delete fDSoundBuffer;
            fDSoundBuffer = nil;
            plStatusLog::AddLineS("audio.log", "Could not play static sound, no voices left %s", GetKeyName());
            return false;
        }
        
        plProfile_EndTiming( StaticSndShoveTime );
        IRefreshEAXSettings( true );

        fTotalBytes = bufferSize;
        
        plProfile_NewMem(MemSounds, fTotalBytes);

        // get pertinent info
        hsScalar length = (hsScalar)bufferSize / (hsScalar)header.fAvgBytesPerSec;
        SetLength(length);

        if( fLoadFromDiskOnDemand && !IsPropertySet( kPropLoadOnlyOnCall ) )
            FreeSoundData();

        return true;
    }
    return false;
}

void plWin32StaticSound::Update()
{
    plWin32Sound::Update();
    if(fDSoundBuffer)
    {
        if(fPlaying)    // we think we are playing
        {
            if(!fDSoundBuffer->IsPlaying()) // are we actually playing
            {
                Stop();
            }
        }
    }
}

void plWin32StaticSound::IDerivedActuallyPlay( void )
{
    // Ensure there's a stop notify for us
    if( !fReallyPlaying )
    {   
        for(;;)
        {
            if(IsPropertySet(kPropIncidental))
            {
                if(fIncidentalsPlaying >= MAX_INCIDENTALS)
                    break;
                ++fIncidentalsPlaying;
            }
        
            fDSoundBuffer->Play();
            fReallyPlaying = true;
            break;
        }
    }

    plSoundEvent    *event = IFindEvent( plSoundEvent::kStart );
    if( event != nil )
        event->SendCallbacks();
}

float plWin32StaticSound::GetActualTimeSec()
{
    if(fDSoundBuffer)
        return fDSoundBuffer->GetTimeOffsetSec();
    return 0.0f;
}

void plWin32StaticSound::ISetActualTime(double t)
{
    if( !fDSoundBuffer && plgAudioSys::Active())
        LoadSound( IsPropertySet( kPropIs3DSound ) );
    if( fDSoundBuffer )
    {
        if(!t)
            fDSoundBuffer->SetTimeOffsetSec((float)t);
    }
}

hsBool plWin32StaticSound::MsgReceive( plMessage* pMsg )
{
    return plWin32Sound::MsgReceive( pMsg );
}

void plWin32StaticSound::IRemoveCallback( plEventCallbackMsg *pCBMsg )
{
    plWin32Sound::IRemoveCallback( pCBMsg );
}

void plWin32StaticSound::IAddCallback( plEventCallbackMsg *pCBMsg )
{
    if( plSoundEvent::GetTypeFromCallbackMsg( pCBMsg ) != plSoundEvent::kStop &&
        plSoundEvent::GetTypeFromCallbackMsg( pCBMsg ) != plSoundEvent::kStart )
    {
        hsAssert( false, "Static sounds only support start and stop callbacks at this time." );
        return;
    }
    plWin32Sound::IAddCallback( pCBMsg );
}


plWin32LinkSound::plWin32LinkSound()
{
    SetLocalOnly(true); // linking sounds already synch at a higher level
    SetProperty( kPropDontFade, true );
}

void plWin32LinkSound::Read(hsStream* s, hsResMgr* mgr)
{
    plWin32StaticSound::Read(s, mgr);

    plgDispatch::Dispatch()->RegisterForExactType(plLinkEffectBCMsg::Index(), GetKey());
    plgDispatch::Dispatch()->RegisterForExactType(plAvatarStealthModeMsg::Index(), GetKey());
    plgDispatch::Dispatch()->RegisterForExactType(plPseudoLinkEffectMsg::Index(), GetKey());
    
    SetLocalOnly(true); // linking sounds already synch at a higher level
    SetProperty( kPropDontFade, true );
}

void plWin32LinkSound::Write(hsStream* s, hsResMgr* mgr)
{
    plWin32StaticSound::Write(s, mgr);
}

hsBool plWin32LinkSound::MsgReceive( plMessage* pMsg )
{
    plLinkEffectBCMsg *msg = plLinkEffectBCMsg::ConvertNoRef( pMsg );
    if( msg != nil && !msg->HasLinkFlag(plLinkEffectBCMsg::kMute))
    {
        if (msg->fLinkKey->GetUoid().GetClonePlayerID() == GetKey()->GetUoid().GetClonePlayerID())
        {
            if (!IsPropertySet(kPropFullyDisabled))
            {
                ISetActualTime(0);
                Play();
                //Activate(true);
            }
        }
        return true;
    }

    plPseudoLinkEffectMsg *psmsg = plPseudoLinkEffectMsg::ConvertNoRef( pMsg );
    if( psmsg != nil)
    {
        if (psmsg->fAvatarKey->GetUoid().GetClonePlayerID() == GetKey()->GetUoid().GetClonePlayerID())
        {
            if (!IsPropertySet(kPropFullyDisabled))
            {
                ISetActualTime(0);
                //Play();
                Activate(true);
            }
        }
        return true;
    }

    plAvatarStealthModeMsg *sMsg = plAvatarStealthModeMsg::ConvertNoRef(pMsg);
    if (sMsg)
    {
        if (sMsg->GetSender()->GetUoid().GetClonePlayerID() == GetKey()->GetUoid().GetClonePlayerID())
        {
            SetProperty(kPropFullyDisabled, (sMsg->fMode == plAvatarStealthModeMsg::kStealthCloaked));
            plNetApp::StaticDebugMsg("plWin32LinkSound: rcvd avatarStealth msg, cloaked=%d", sMsg->fMode == plAvatarStealthModeMsg::kStealthCloaked);           
        }
        return true;
    }
    
    return plWin32StaticSound::MsgReceive( pMsg );
}