CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.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 <al.h>
#include <alc.h>
#include <efx.h>
#include <MMREG.H>
#ifdef EAX_SDK_AVAILABLE
#include <eax.h>
#endif

#include "hsTimer.h"
#include "hsGeometry3.h"
#include "plgDispatch.h"
#include "plProfile.h"
#include "plStatusLog/plStatusLog.h"

#include "plSound.h"
#include "plAudioCaps.h"
#include "plAudioSystem.h"
#include "plDSoundBuffer.h"
#include "plEAXEffects.h"
#include "plEAXListenerMod.h"
#include "plVoiceChat.h"

#include "pnMessage/plAudioSysMsg.h"
#include "plMessage/plRenderMsg.h"
#include "pnMessage/plRefMsg.h"
#include "plMessage/plAgeLoadedMsg.h"
#include "pnMessage/plTimeMsg.h"

#include "pnKeyedObject/plFixedKey.h"
#include "pnKeyedObject/plKey.h"


#define SAFE_RELEASE(p) if(p){ p->Release(); p = nil; }
#define FADE_TIME   3
#define MAX_NUM_SOURCES 128
#define UPDATE_TIME_MS 100

plProfile_CreateTimer("EAX Update", "Sound", SoundEAXUpdate);
plProfile_CreateTimer("Soft Update", "Sound", SoundSoftUpdate);
plProfile_CreateCounter("Max Sounds", "Sound", SoundMaxNum);
plProfile_CreateTimer("AudioUpdate", "RenderSetup", AudioUpdate);

typedef std::vector<DeviceDescriptor>::iterator DeviceIter;

//// Internal plSoftSoundNode Class Definition ///////////////////////////////
class plSoftSoundNode
{
    public:
        const plKey fSoundKey;
        hsScalar    fRank;

        plSoftSoundNode *fNext;
        plSoftSoundNode **fPrev;

        plSoftSoundNode *fSortNext;
        plSoftSoundNode **fSortPrev;

        plSoftSoundNode( const plKey s ) : fSoundKey( s ) { fNext = nil; fPrev = nil; }
        ~plSoftSoundNode() { Unlink(); }

        void    Link( plSoftSoundNode **prev )
        {
            fNext = *prev;
            fPrev = prev;
            if( fNext != nil )
                fNext->fPrev = &fNext;
            *prev = this;
        }

        void    Unlink( void )
        {
            if( fPrev != nil )
            {
                *fPrev = fNext;
                if( fNext )
                    fNext->fPrev = fPrev;
                fPrev = nil;
                fNext = nil;
            }
        }

        void    SortedLink( plSoftSoundNode **prev, hsScalar rank )
        {
            fRank = rank;

            fSortNext = *prev;
            fSortPrev = prev;
            if( fSortNext != nil )
                fSortNext->fSortPrev = &fSortNext;
            *prev = this;
        }

        // Larger values are first in the list
        void    AddToSortedLink( plSoftSoundNode *toAdd, hsScalar rank )
        {
            if( fRank > rank )
            {
                if( fSortNext != nil )
                    fSortNext->AddToSortedLink( toAdd, rank );
                else
                {
                    toAdd->SortedLink( &fSortNext, rank );
                }
            }
            else
            {
                // Cute trick here...
                toAdd->SortedLink( fSortPrev, rank );
            }
        }

        void    BootSourceOff( void )
        {
            plSound *sound = plSound::ConvertNoRef( fSoundKey->ObjectIsLoaded() );
            if( sound != nil )
            {
                sound->ForceUnregisterFromAudioSys();
            }
        }
};

// plAudioSystem //////////////////////////////////////////////////////////////////////////

Int32   plAudioSystem::fMaxNumSounds = 16;
Int32   plAudioSystem::fNumSoundsSlop = 8;

plAudioSystem::plAudioSystem() :
fStartTime(0),
fListenerInit(false),
fSoftRegionSounds(nil),
fActiveSofts(nil),
fCurrDebugSound(nil),
fDebugActiveSoundDisplay(nil),
fUsingEAX(false),
fRestartOnDestruct(false),
fWaitingForShutdown(false),
fActive(false),
fDisplayNumBuffers(false),
fStartFade(0),
fFadeLength(FADE_TIME),
fCaptureDevice(nil),
fLastUpdateTimeMs(0)
{
    fCurrListenerPos.Set( -1.e30, -1.e30, -1.e30 );
    //fCommittedListenerPos.Set( -1.e30, -1.e30, -1.e30 );
    fLastPos.Set(100, 100, 100);
}

plAudioSystem::~plAudioSystem()
{
}

void plAudioSystem::IEnumerateDevices()
{
    fDeviceList.clear();
    plStatusLog::AddLineS("audio.log", "--Audio Devices --" );
    char *devices = (char *)alcGetString(nil, ALC_DEVICE_SPECIFIER);
    int major, minor;

    while(*devices != nil)
    {
        ALCdevice *device = alcOpenDevice(devices);
        if (device) 
        {
            ALCcontext *context = alcCreateContext(device, NULL);
            if (context)
            {
                alcMakeContextCurrent(context);
                // if new actual device name isn't already in the list, then add it...
                bool bNewName = true;
                for (DeviceIter i = fDeviceList.begin(); i != fDeviceList.end(); i++) 
                {
                    if (strcmp((*i).GetDeviceName(), devices) == 0) 
                    {
                        bNewName = false;
                    }
                }
                if ((bNewName)) 
                {
                    alcGetIntegerv(device, ALC_MAJOR_VERSION, sizeof(int), &major);
                    alcGetIntegerv(device, ALC_MINOR_VERSION, sizeof(int), &minor);
                    plStatusLog::AddLineS("audio.log", "%s OpenAL ver: %d.%d", devices, major, minor );

                    // filter out any devices that aren't openal 1.1 compliant
                    if(major > 1 || (major == 1 && minor >= 1))
                    {
                        hsBool supportsEAX = false;
#ifdef EAX_SDK_AVAILABLE
                        if(alIsExtensionPresent((ALchar *)"EAX4.0") || alIsExtensionPresent((ALchar *) "EAX4.0Emulated"))       
                        {
                            supportsEAX = true;
                        }
#endif
                        DeviceDescriptor desc(devices, supportsEAX);
                        fDeviceList.push_back(desc);
                    }
                }
                alcMakeContextCurrent(nil);
                alcDestroyContext(context);
            }
            alcCloseDevice(device);
        }
        devices += strlen(devices) + 1;
    }

    DeviceDescriptor temp("", 0);
    // attempt to order devices
    for(unsigned i = 0; i < fDeviceList.size(); ++i)
    {
        if(strstr(fDeviceList[i].GetDeviceName(), "Software"))
        {
            temp = fDeviceList[i];
            fDeviceList[i] = fDeviceList[0];
            fDeviceList[0] = temp;
        }
        if(strstr(fDeviceList[i].GetDeviceName(), "Hardware"))
        {   
            temp = fDeviceList[i];
            fDeviceList[i] = fDeviceList[1];
            fDeviceList[1] = temp;
        }
    }
}

//// Init ////////////////////////////////////////////////////////////////////
hsBool  plAudioSystem::Init( hsWindowHndl hWnd )
{
    plgAudioSys::fRestarting = false;
    static hsBool firstTimeInit = true; 
    plStatusLog::AddLineS( "audio.log", plStatusLog::kBlue, "ASYS: -- Init --" );
    
    fMaxNumSources = 0;
    plStatusLog::AddLineS( "audio.log", plStatusLog::kGreen, "ASYS: Detecting caps..." );
    plSoundBuffer::Init();

    // Set the maximum number of sounds based on priority cutoff slider
    SetMaxNumberOfActiveSounds();
    const char *deviceName = plgAudioSys::fDeviceName.c_str();
    hsBool useDefaultDevice = true;
    
    if(firstTimeInit)
    {
        IEnumerateDevices();
        firstTimeInit = false;
    }

    if(!fDeviceList.size())
    {
        plStatusLog::AddLineS( "audio.log", plStatusLog::kRed, "ASYS: ERROR Unable to query any devices, is openal installed?" );
        return false;
    }

    // shouldn't ever happen, but just in case
    if(!deviceName)
        plgAudioSys::SetDeviceName(DEFAULT_AUDIO_DEVICE_NAME);

    for(DeviceIter i = fDeviceList.begin(); i != fDeviceList.end(); i++)
    {
        if(!strcmp((*i).GetDeviceName(), deviceName))
        {
            useDefaultDevice = false;
            break;
        }
    }
    
    if(useDefaultDevice)
    {
        // if no device has been specified we will use the "Generic Software" device by default. If "Generic Software" is unavailable(which can happen) we select the first available device
        // We want to use software by default since some audio cards have major problems with hardware + eax.
        const char *defaultDev = fDeviceList.front().GetDeviceName();
        for(DeviceIter i = fDeviceList.begin(); i != fDeviceList.end(); i++)
        {
            if(!strcmp(DEFAULT_AUDIO_DEVICE_NAME, (*i).GetDeviceName()))
            {
                defaultDev = DEFAULT_AUDIO_DEVICE_NAME;
                break;
            }
        }

        plgAudioSys::SetDeviceName(defaultDev, false);
        fDevice = alcOpenDevice(defaultDev);
        plStatusLog::AddLineS( "audio.log", plStatusLog::kRed, "ASYS: %s device selected", defaultDev );
        deviceName = defaultDev;
    }
    else
    {
        plgAudioSys::SetDeviceName(deviceName, false);
        fDevice = alcOpenDevice(deviceName);
        plStatusLog::AddLineS( "audio.log", plStatusLog::kRed, "ASYS: %s device selected", deviceName );
    }
    if(!fDevice)
    {
        plStatusLog::AddLineS( "audio.log", plStatusLog::kRed, "ASYS: ERROR initializing OpenAL" );
        return false;
    }
    
    fContext = alcCreateContext(fDevice, 0);
    alcMakeContextCurrent(fContext);

    ALenum error;
    if(alGetError() != AL_NO_ERROR)
    {
        plStatusLog::AddLineS( "audio.log", plStatusLog::kRed, "ASYS: ERROR alcMakeContextCurrent failed" );
        return false;
    }

    plStatusLog::AddLineS("audio.log", "OpenAL vendor: %s",     alGetString(AL_VENDOR));
    plStatusLog::AddLineS("audio.log", "OpenAL version: %s",    alGetString(AL_VERSION));
    plStatusLog::AddLineS("audio.log", "OpenAL renderer: %s",   alGetString(AL_RENDERER));
    plStatusLog::AddLineS("audio.log", "OpenAL extensions: %s", alGetString(AL_EXTENSIONS));
    plAudioCaps caps = plAudioCapsDetector::Detect();

    if(strcmp(deviceName, DEFAULT_AUDIO_DEVICE_NAME))       
    {
        // we are using a hardware device, set priority based on number of hardware voices
        unsigned int numVoices = caps.GetMaxNumVoices();
        
        if(numVoices < 16)
            plgAudioSys::SetPriorityCutoff(3);
        
        SetMaxNumberOfActiveSounds();
    }

    // setup capture device
    ALCsizei bufferSize = FREQUENCY * 2 * BUFFER_LEN_SECONDS;   // times 2 for 16-bit format
    //const char *dev = alcGetString(fDevice, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
    fCaptureDevice = alcCaptureOpenDevice(nil, FREQUENCY, AL_FORMAT_MONO16, bufferSize);
 
    fMaxNumSources = caps.GetMaxNumVoices();

    // attempt to init the EAX listener. 
    if( plgAudioSys::fEnableEAX )
    {
        fUsingEAX = plEAXListener::GetInstance().Init();
        if( fUsingEAX )
        {
            plStatusLog::AddLineS( "audio.log", plStatusLog::kGreen, "ASYS: EAX support detected and enabled." );
        }
        else
        {
            plStatusLog::AddLineS( "audio.log", plStatusLog::kRed, "ASYS: EAX support NOT detected. EAX effects disabled." );
        }
    }
    else
        fUsingEAX = false;
    
    plProfile_Set(SoundMaxNum, fMaxNumSounds);

    alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);   
    
    error = alGetError();

    fWaitingForShutdown = false;
    plgDispatch::Dispatch()->RegisterForExactType( plAgeLoadedMsg::Index(), GetKey() );
    return true;
}

//// Shutdown ////////////////////////////////////////////////////////////////

void plAudioSystem::Shutdown()
{
    plStatusLog::AddLineS( "audio.log", plStatusLog::kBlue, "ASYS: -- Shutdown --" );

    plSoundBuffer::Shutdown();

    // Delete our active sounds list
    delete fDebugActiveSoundDisplay;
    fDebugActiveSoundDisplay = nil;

    // Unregister soft sounds
    while( fSoftRegionSounds != nil )
    {
        fSoftRegionSounds->BootSourceOff();
        delete fSoftRegionSounds;
    }
    while( fActiveSofts != nil )
    {
        fActiveSofts->BootSourceOff();
        delete fActiveSofts;
    }

    while( fEAXRegions.GetCount() > 0 )
    {
        if( fEAXRegions[ 0 ] != nil && fEAXRegions[ 0 ]->GetKey() != nil )
        {
            GetKey()->Release( fEAXRegions[ 0 ]->GetKey() );
        }
        fEAXRegions.Remove( 0 );
    }
    plEAXListener::GetInstance().ClearProcessCache();

    plSound::SetCurrDebugPlate( nil );
    fCurrDebugSound = nil;

    // Reset this, just in case
    fPendingRegisters.Reset();

    //fListenerInit = false;
    
    if( fUsingEAX )
    {
        plEAXListener::GetInstance().Shutdown();
    }

    alcCaptureStop(fCaptureDevice);
    alcCaptureCloseDevice(fCaptureDevice);
    fCaptureDevice = nil;

    alcMakeContextCurrent(nil);
    alcDestroyContext(fContext);
    alcCloseDevice(fDevice);
    fContext = nil;
    fDevice = nil;

    fStartTime = 0;
    fUsingEAX = false;
    fCurrListenerPos.Set( -1.e30, -1.e30, -1.e30 );
    //fCommittedListenerPos.Set( -1.e30, -1.e30, -1.e30 );
    
    if( fRestartOnDestruct )
    {
        fRestartOnDestruct = false;
        plgAudioSys::Activate( true );
    }

    plgDispatch::Dispatch()->UnRegisterForExactType(plAgeLoadedMsg::Index(), GetKey() );
    fWaitingForShutdown = false;
}

int plAudioSystem::GetNumAudioDevices()
{
    return fDeviceList.size();
}

const char *plAudioSystem::GetAudioDeviceName(int index)
{
    if(index < 0 || index >= fDeviceList.size())
    {
        hsAssert(false, "Invalid index passed to GetAudioDeviceName");
        return nil;
    }
    return fDeviceList[index].GetDeviceName();
}

hsBool plAudioSystem::SupportsEAX(const char *deviceName)
{
    for(DeviceIter i = fDeviceList.begin(); i != fDeviceList.end(); i++)
    {
        if(!strcmp((*i).GetDeviceName(), deviceName))
        {
            return (*i).SupportsEAX();
        }
    }
    return false;
}

void plAudioSystem::SetDistanceModel(int i)
{
    switch(i)
    {
        case 0: alDistanceModel(AL_NONE); break;
        case 1: alDistanceModel(AL_INVERSE_DISTANCE ); break;
        case 2: alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED); break;
        case 3: alDistanceModel(AL_LINEAR_DISTANCE ); break;
        case 4: alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED ); break;
        case 5: alDistanceModel(AL_EXPONENT_DISTANCE ); break;
        case 6: alDistanceModel(AL_EXPONENT_DISTANCE_CLAMPED); break;
    }
}

// Set the number of active sounds the audio system is allowed to play, based on the priority cutoff
void plAudioSystem::SetMaxNumberOfActiveSounds()
{
    UInt16 priorityCutoff = plgAudioSys::GetPriorityCutoff();
    int maxNumSounds = 24;
    
    // Keep this to a reasonable amount based on the users hardware, since we want the sounds to be played in hardware
    if(maxNumSounds > fMaxNumSources && fMaxNumSources != 0 )
        maxNumSounds = fMaxNumSources / 2;

    // Allow a certain number of sounds based on a user specified setting.
    // Above that limit, we want 1/2 more sounds (8 for the max of 16) for a slop buffer, 
    // if they fit, so that sounds that shouldn't be playing can still play in case they suddenly pop
    // back into priority range (so we don't incur performance hits when sounds hover on
    // the edge of being high enough priority to play)
    fMaxNumSounds = maxNumSounds;
    fNumSoundsSlop = fMaxNumSounds / 2;

    plStatusLog::AddLineS( "audio.log", "Max Number of Sounds Set to: %d", fMaxNumSounds);
}

void plAudioSystem::SetListenerPos(const hsPoint3 pos)
{
    fCurrListenerPos = pos;
    alListener3f(AL_POSITION, pos.fX, pos.fZ, -pos.fY);     // negate z coord, since openal uses opposite handedness
}

void plAudioSystem::SetListenerVelocity(const hsVector3 vel)
{
    alListener3f(AL_VELOCITY, 0, 0, 0); // no doppler shift
}

void plAudioSystem::SetListenerOrientation(const hsVector3 view, const hsVector3 up)
{
    ALfloat orientation[] = { view.fX, view.fZ, -view.fY, up.fX, up.fZ, -up.fY };
    alListenerfv(AL_ORIENTATION, orientation);
}

void    plAudioSystem::SetActive( hsBool b ) 
{
    fActive = b;
    if( fActive )
    {
        // Clear to send activate message (if listener not inited yet, delay until then)
        plgDispatch::MsgSend( TRACKED_NEW plAudioSysMsg( plAudioSysMsg::kActivate ) );
    }
}

//// IRegisterSoftSound //////////////////////////////////////////////////////
//  Note: each sound might kick another off the top-n-ranked-sounds list, so
//  we call IUpdateSoftSounds() each time one is added. Ugly as sin, but at
//  least all the calc code is in one place. Possible optimization in the
//  future: when calling IUpdate(), any sounds that are already active don't
//  need to be recalced, just resorted.
void    plAudioSystem::RegisterSoftSound( const plKey soundKey )
{
    plSoftSoundNode *node = TRACKED_NEW plSoftSoundNode( soundKey );
    node->Link( &fSoftRegionSounds );

    fCurrDebugSound = nil;
    plSound::SetCurrDebugPlate( nil );
}

//// IUnregisterSoftSound ////////////////////////////////////////////////////

void    plAudioSystem::UnregisterSoftSound( const plKey soundKey )
{
    plSoftSoundNode *node;
    for( node = fActiveSofts; node != nil; node = node->fNext )
    {
        if( node->fSoundKey == soundKey )
        {
            delete node;
            return;
        }
    }

    for( node = fSoftRegionSounds; node != nil; node = node->fNext )
    {
        if( node->fSoundKey == soundKey )
        {
            delete node;
            return;
        }
    }

    // We might have unregistered it ourselves on destruction, so don't bother

    fCurrDebugSound = nil;
    plSound::SetCurrDebugPlate( nil );
}

//// IUpdateSoftSounds ///////////////////////////////////////////////////////
//  OK, so the listener moved. Since our sound soft volumes are all based on 
//  the listener's position, we have to update all sounds with soft volumes 
//  now. This involves some steps:
//      - Determining what volumes the listener has moved out of
//      - Determining what volumes the listener has changed position in
//      - Determining what volumes the listener has entered
//      - Updating the levels of all sounds associated with all of the above 
//          volumes
//  The first two tests are easy, since we'll have kept track of what volumes 
//  the listener was in last time. The last part is the tricky one and the 
//  one that will kill us in performance if we're not careful. However, we 
//  can first check the bounding box of the sounds in question, since outside
//  of them the soft volume won't have any effect. The last part is simply a 
//  matter of querying the sound volumes based on the listener's position and
//  setting the soft volume attenuation on the sound to that level.
//
//  Note: for each sound that is still in range, we call CalcSoftVolume() and
//  use the resulting value to rank each sound. Then, we take the top n sounds
//  and disable the rest. We *could* rank by distance to listener, which would
//  be far faster; however, we could have a sound (or background music) that
//  is technically closest to the listener but completely faded by a soft volume,
//  thus needlessly cutting off another sound that might be more important.
//  This way is slower, but better quality.
//  Also note: to differentiate between two sounds in the same soft volume at
//  full strength, we divide the soft volume ranks by the distSquared, thus
//  giving us a reasonable approximation at a good rank...<sigh>

void    plAudioSystem::IUpdateSoftSounds( const hsPoint3 &newPosition )
{
    plSoftSoundNode *node, *myNode;
    hsScalar        distSquared, rank;
    plSoftSoundNode *sortedList = nil;
    Int32           i;
    
    plProfile_BeginTiming(SoundSoftUpdate);
    
    // Check the sounds the listener is already inside of. If we moved out, stop sound, else
    // just change attenuation
    for( node = fActiveSofts; node != nil; )
    {
        plSound *sound = plSound::ConvertNoRef( node->fSoundKey->ObjectIsLoaded() );

        bool notActive = false;
        if(sound)
            sound->Update();
        
        // Quick checks for not-active
        if( sound == nil )
            notActive = true;
        else if( !sound->IsWithinRange( newPosition, &distSquared )  )
            notActive = true;
        else if(sound->GetPriority() > plgAudioSys::GetPriorityCutoff())
            notActive = true;

        if(plgAudioSys::fMutedStateChange)
        {
            sound->SetMuted(plgAudioSys::fMuted);
        }
        
        if( !notActive )
        {
            /// Our initial guess is that it's enabled...
            sound->CalcSoftVolume( true, distSquared );
            rank = sound->GetVolumeRank();
            if( rank <= 0.f )
                notActive = true;
            else
            {
                /// Queue up in our sorted list...
                if( sortedList == nil )
                    node->SortedLink( &sortedList, (10.0f - sound->GetPriority()) * rank );
                else
                    sortedList->AddToSortedLink( node, (10.0f - sound->GetPriority()) * rank );
                /// Still in radius, so consider it still "active". 
                node = node->fNext;
            }
        }

        if( notActive )
        {
            /// Moved out of range of the sound--stop the sound entirely and move it to our
            /// yeah-they're-registered-but-not-active list
            myNode = node;
            node = node->fNext;
            myNode->Unlink();
            myNode->Link( &fSoftRegionSounds );

            /// We know this sound won't be enabled, so skip the Calc() call
            if( sound != nil )
                sound->UpdateSoftVolume( false );
        }
    }
    
    // Now check remaining sounds to see if the listener moved into them
    for( node = fSoftRegionSounds; node != nil; )
    {
        if( !fListenerInit )
        {
            node = node->fNext;
            continue;
        }
    
        plSound *sound = plSound::ConvertNoRef( node->fSoundKey->ObjectIsLoaded() ); 
        if( !sound || sound->GetPriority() > plgAudioSys::GetPriorityCutoff() )
        {   
            node = node->fNext;
            continue;
        }

        sound->Update();
        if(plgAudioSys::fMutedStateChange)
        {
            sound->SetMuted(plgAudioSys::fMuted);
        }
        
        if( sound->IsWithinRange( newPosition, &distSquared ) )
        {
            /// Our initial guess is that it's enabled...
            sound->CalcSoftVolume( true, distSquared );
            rank = sound->GetVolumeRank();

            if( rank > 0.f )
            {           
                /// We just moved into its range, so move it to our active list and start the sucker
                myNode = node;
                node = node->fNext;
                myNode->Unlink();
                myNode->Link( &fActiveSofts );

                /// Queue up in our sorted list...
                if( sortedList == nil )
                    myNode->SortedLink( &sortedList, (10.0f - sound->GetPriority()) * rank );
                else
                    sortedList->AddToSortedLink( myNode, (10.0f - sound->GetPriority()) * rank );
            }
            else
            {
                /// Do NOT notify sound, since we were outside of its range and still are
                // (but if we're playing, we shouldn't be, so better update)
                if( sound->IsPlaying() )
                    sound->UpdateSoftVolume( false );

                node = node->fNext;
            }
        }
        else
        {
            /// Do NOT notify sound, since we were outside of its range and still are
            node = node->fNext;     
            sound->Disable();       // ensure that dist attenuation is set to zero so we don't accidentally play
        }
    }
    
    plgAudioSys::fMutedStateChange = false;
    /// Go through sorted list, enabling only the first n sounds and disabling the rest
    // DEBUG: Create a screen-only statusLog to display which sounds are what
    if( fDebugActiveSoundDisplay == nil )
        fDebugActiveSoundDisplay = plStatusLogMgr::GetInstance().CreateStatusLog( 32, "Active Sounds", plStatusLog::kDontWriteFile | plStatusLog::kDeleteForMe | plStatusLog::kFilledBackground );
    fDebugActiveSoundDisplay->Clear();

    if(fDisplayNumBuffers)
        fDebugActiveSoundDisplay->AddLineF(0xffffffff, "Num Buffers: %d", plDSoundBuffer::GetNumBuffers() );
    fDebugActiveSoundDisplay->AddLine("Not streamed", plStatusLog::kGreen);
    fDebugActiveSoundDisplay->AddLine("Disk streamed", plStatusLog::kYellow);
    fDebugActiveSoundDisplay->AddLine("RAM streamed", plStatusLog::kWhite);
    fDebugActiveSoundDisplay->AddLine("Ogg streamed", plStatusLog::kRed);
    fDebugActiveSoundDisplay->AddLine("Incidentals", 0xff00ffff);
    fDebugActiveSoundDisplay->AddLine("--------------------");
    
    for( i = 0; sortedList != nil && i < fMaxNumSounds; sortedList = sortedList->fSortNext )
    {
        plSound *sound = plSound::ConvertNoRef( sortedList->fSoundKey->GetObjectPtr() );
        if(!sound) continue;
    
        /// Notify sound that it really is still enabled
        sound->UpdateSoftVolume( true );
        
        UInt32 color = plStatusLog::kGreen;
        switch (sound->GetStreamType())
        {
            case plSound::kStreamFromDisk:      color = plStatusLog::kYellow;   break;
            case plSound::kStreamFromRAM:       color = plStatusLog::kWhite;    break;
            case plSound::kStreamCompressed:    color = plStatusLog::kRed;      break;
        }
        if(sound->GetType() == plgAudioSys::kVoice) color = 0xffff8800;
        if(sound->IsPropertySet(plSound::kPropIncidental)) color = 0xff00ffff;
        
        if( fUsingEAX && sound->GetEAXSettings().IsEnabled() )
        {
            fDebugActiveSoundDisplay->AddLineF(
                color, 
                "%d %1.2f %1.2f (%d occ) %s",
                sound->GetPriority(), 
                sortedList->fRank, 
                sound->GetVolume() ? sound->GetVolumeRank() / sound->GetVolume() : 0, 
                sound->GetEAXSettings().GetCurrSofts().GetOcclusion(), 
                sound->GetKeyName()
            );
        }
        else 
        {
            fDebugActiveSoundDisplay->AddLineF(
                color, 
                "%d %1.2f %1.2f %s", 
                sound->GetPriority(), 
                sortedList->fRank, 
                sound->GetVolume() ? sound->GetVolumeRank() / sound->GetVolume() : 0, 
                sound->GetKeyName()
            );
        }
        i++;
    }

    for( ; sortedList != nil; sortedList = sortedList->fSortNext, i++ )
    {
        plSound *sound = plSound::ConvertNoRef( sortedList->fSoundKey->GetObjectPtr() );
        if(!sound) continue;

        /// These unlucky sounds don't get to play (yet). Also, be extra mean
        /// and pretend we're updating for "the first time", which will force them to
        /// stop immediately
        // Update: since being extra mean can incur a nasty performance hit when sounds hover back and
        // forth around the fMaxNumSounds mark, we have a "slop" allowance: i.e. sounds that we're going
        // to say shouldn't be playing but we'll let them play for a bit anyway just in case they raise
        // in priority. So only be mean to the sounds outside this slop range
        sound->UpdateSoftVolume( false, ( i < fMaxNumSounds + fNumSoundsSlop ) ? false : true );
        fDebugActiveSoundDisplay->AddLineF(
            0xff808080,
            "%d %1.2f %s", 
            sound->GetPriority(), 
            sound->GetVolume() ? sound->GetVolumeRank() / sound->GetVolume() : 0, 
            sound->GetKeyName()
        );
    }
    
    plProfile_EndTiming(SoundSoftUpdate);
}

void    plAudioSystem::NextDebugSound( void )
{
    plSoftSoundNode     *node;

    if( fCurrDebugSound == nil )
        fCurrDebugSound = ( fSoftRegionSounds == nil ) ? fActiveSofts : fSoftRegionSounds;
    else
    {
        node = fCurrDebugSound;
        fCurrDebugSound = fCurrDebugSound->fNext;
        if( fCurrDebugSound == nil )
        {
            // Trace back to find which list we were in
            for( fCurrDebugSound = fSoftRegionSounds; fCurrDebugSound != nil; fCurrDebugSound = fCurrDebugSound->fNext )
            {
                if( fCurrDebugSound == node )   // Was in first list, move to 2nd
                {
                    fCurrDebugSound = fActiveSofts;     
                    break;
                }
            }
            // else Must've been in 2nd list, so keep nil
        }
    }

    if( fCurrDebugSound != nil )
        plSound::SetCurrDebugPlate( fCurrDebugSound->fSoundKey );
    else
        plSound::SetCurrDebugPlate( nil );
}

void plAudioSystem::SetFadeLength(float lengthSec)
{
    fFadeLength = lengthSec;
}
    
hsBool plAudioSystem::MsgReceive(plMessage* msg)
{
    if(plTimeMsg *time = plTimeMsg::ConvertNoRef( msg ) )
    {
        if(!plgAudioSys::IsMuted())
        {
            double currTime = hsTimer::GetSeconds();
            if(fStartFade == 0)
            {
                plStatusLog::AddLineS("audio.log", "Starting Fade %f", currTime);
            }
            if((currTime - fStartFade) > fFadeLength) 
            {
                fStartFade = 0;
                plgDispatch::Dispatch()->UnRegisterForExactType( plTimeMsg::Index(), GetKey() );
                plStatusLog::AddLineS("audio.log", "Stopping Fade %f", currTime);
                plgAudioSys::SetGlobalFadeVolume( 1.0 ); 
            }
            else
            {
                plgAudioSys::SetGlobalFadeVolume( (hsScalar)((currTime-fStartFade) / fFadeLength) );
            }
        }
        return true;
    }
    
    if (plAudioSysMsg* pASMsg = plAudioSysMsg::ConvertNoRef( msg ))
    {
        if (pASMsg->GetAudFlag() == plAudioSysMsg::kPing && fListenerInit)
        {
            plAudioSysMsg* pMsg = TRACKED_NEW plAudioSysMsg( plAudioSysMsg::kActivate );
            pMsg->AddReceiver( pASMsg->GetSender() );
            pMsg->SetBCastFlag(plMessage::kBCastByExactType, false);
            plgDispatch::MsgSend( pMsg );
            return true;
        }
        else if (pASMsg->GetAudFlag() == plAudioSysMsg::kSetVol)
        {
            return true;
        }
        else if( pASMsg->GetAudFlag() == plAudioSysMsg::kDestroy )
        {
            if( fWaitingForShutdown )
                Shutdown();
            return true;
        }
        else if( pASMsg->GetAudFlag() == plAudioSysMsg::kUnmuteAll )
        {
            if( !pASMsg->HasBCastFlag( plMessage::kBCastByExactType ) )
                plgAudioSys::SetMuted( false );
            return true;
        }
    }
    
    if(plRenderMsg* pRMsg = plRenderMsg::ConvertNoRef( msg ))
    {
        //if( fListener )
        {
            plProfile_BeginLap(AudioUpdate, this->GetKey()->GetUoid().GetObjectName());
            if(hsTimer::GetMilliSeconds() - fLastUpdateTimeMs > UPDATE_TIME_MS)
            {
                IUpdateSoftSounds( fCurrListenerPos );

                if( fUsingEAX )
                {
                    plProfile_BeginTiming(SoundEAXUpdate);
                    plEAXListener::GetInstance().ProcessMods( fEAXRegions );
                    plProfile_EndTiming(SoundEAXUpdate);
                }
                //fCommittedListenerPos = fCurrListenerPos;
            }
            plProfile_EndLap(AudioUpdate, this->GetKey()->GetUoid().GetObjectName());
        }
        
        return true;
    }

    if(plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef( msg ))
    {
        if( refMsg->GetContext() & ( plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace ) )
        {
            fEAXRegions.Append( plEAXListenerMod::ConvertNoRef( refMsg->GetRef() ) );
            plEAXListener::GetInstance().ClearProcessCache();
        }
        else if( refMsg->GetContext() & ( plRefMsg::kOnRemove | plRefMsg::kOnDestroy ) )
        {
            int idx = fEAXRegions.Find( plEAXListenerMod::ConvertNoRef( refMsg->GetRef() ) );
            if( idx != fEAXRegions.kMissingIndex )
                fEAXRegions.Remove( idx );
            plEAXListener::GetInstance().ClearProcessCache();
        }
        return true;
    }
    
    if(plAgeLoadedMsg *pALMsg = plAgeLoadedMsg::ConvertNoRef(msg))
    {
        if(!pALMsg->fLoaded)
        {
            fLastPos = fCurrListenerPos;
            fListenerInit = false;
        }
        else
        {
            fListenerInit = true;
        }
    }

    return hsKeyedObject::MsgReceive(msg);
}

// plgAudioSystem //////////////////////////////////////////////////////////////////////

plAudioSystem*  plgAudioSys::fSys = nil;
hsBool          plgAudioSys::fInit = false;
hsBool          plgAudioSys::fActive = false;
hsBool          plgAudioSys::fUseHardware = false;
hsBool          plgAudioSys::fMuted = true;
hsBool          plgAudioSys::fDelayedActivate = false;
hsBool          plgAudioSys::fEnableEAX = false;
hsWindowHndl    plgAudioSys::fWnd = nil;
hsScalar        plgAudioSys::fChannelVolumes[ kNumChannels ] = { 1.f, 1.f, 1.f, 1.f, 1.f, 1.f };
hsScalar        plgAudioSys::f2D3DBias = 0.75f;
UInt32          plgAudioSys::fDebugFlags = 0;
hsScalar        plgAudioSys::fStreamingBufferSize = 2.f;
hsScalar        plgAudioSys::fStreamFromRAMCutoff = 10.f;
UInt8           plgAudioSys::fPriorityCutoff = 9;           // We cut off sounds above this priority
hsBool          plgAudioSys::fEnableExtendedLogs = false;
hsScalar        plgAudioSys::fGlobalFadeVolume = 1.f;
hsBool          plgAudioSys::fLogStreamingUpdates = false;
std::string     plgAudioSys::fDeviceName;
hsBool          plgAudioSys::fRestarting = false;
hsBool          plgAudioSys::fMutedStateChange = false;

void plgAudioSys::Init(hsWindowHndl hWnd)
{
    fSys = TRACKED_NEW plAudioSystem;
    fSys->RegisterAs( kAudioSystem_KEY );
    plgDispatch::Dispatch()->RegisterForExactType( plAudioSysMsg::Index(), fSys->GetKey() );
    plgDispatch::Dispatch()->RegisterForExactType( plRenderMsg::Index(), fSys->GetKey() );

    if(hsPhysicalMemory() <= 380)   
    {
        plStatusLog::AddLineS("audio.log", "StreamFromRam Disabled");
        fStreamFromRAMCutoff = 4;
    }
    fWnd = hWnd;

    if(fMuted)
        SetGlobalFadeVolume(0.0f);

    if( fDelayedActivate )
        Activate( true );
}

void plgAudioSys::SetActive(hsBool b)
{
    fActive = b;
}

void plgAudioSys::SetMuted( hsBool b )
{
    fMuted = b;
    fMutedStateChange = true;

    if(fMuted)
        SetGlobalFadeVolume(0.0f);
    else
        SetGlobalFadeVolume(1.0);
}

void plgAudioSys::SetUseHardware(hsBool b)
{
    fUseHardware = b;
    if( fActive )
        Restart();
}

void plgAudioSys::EnableEAX( hsBool b )
{
    fEnableEAX = b;
    if( fActive )
        Restart();
}

void plgAudioSys::SetAudioMode(AudioMode mode)
{
    if(mode == kDisabled)
    {
        Activate(false);
        return;
    }
    else if(mode == kSoftware)
    {
        fActive = true;
        fUseHardware = false;
        fEnableEAX = false;
    }
    else if(mode == kHardware)
    {
        fActive = true;
        fUseHardware = true;
        fEnableEAX = false;
    }
    else if(mode == kHardwarePlusEAX)
    {
        fActive = true;
        fUseHardware = true;
        fEnableEAX = true;
    }
    Restart();
}

int plgAudioSys::GetAudioMode()
{
    if (fActive)
    {
        if (fUseHardware)
        {
            if (fEnableEAX)
            {
                return kHardwarePlusEAX;
            }
            else
            {
                return kHardware;
            }
        }
        else
        {
            return kSoftware;
        }
    }
    else
    {
        return kDisabled;
    }
}

void plgAudioSys::Restart( void )
{
    if( fSys )
    {
        fSys->fRestartOnDestruct = true;
        Activate( false );
        fRestarting = true;
    }
}

void plgAudioSys::Shutdown()
{
    Activate( false );
    if( fSys )
    {
        fSys->UnRegisterAs( kAudioSystem_KEY );
    }
}

void plgAudioSys::Activate(hsBool b)
{ 
    if( fSys == nil )
    {
        fDelayedActivate = true;
        return;
    }

    if (b == fInit)
        return;
    if (!fActive)
        return;
    if( b )
    {
        plStatusLog::AddLineS( "audio.log", plStatusLog::kBlue, "ASYS: -- Attempting audio system init --" );
        if( !fSys->Init( fWnd ) )
        {
            // Cannot init audio system. Don't activate
            return; 
        }
        fInit = true;
        fSys->SetActive( true );

        if( !IsMuted() )
        {
            SetMuted( true );
            plAudioSysMsg *msg = TRACKED_NEW plAudioSysMsg( plAudioSysMsg::kUnmuteAll );
            msg->SetTimeStamp( hsTimer::GetSysSeconds() );
            msg->AddReceiver( fSys->GetKey() );
            msg->SetBCastFlag( plMessage::kBCastByExactType, false );
            msg->Send();
        }
        return;
    }

    fSys->SetActive( false );
    
    plStatusLog::AddLineS( "audio.log", plStatusLog::kBlue, "ASYS: -- Sending deactivate/destroy messages --" );
    plgDispatch::MsgSend( TRACKED_NEW plAudioSysMsg( plAudioSysMsg::kDeActivate ) );

    // Send ourselves a shutdown message, so that the deactivates get processed first
    fSys->fWaitingForShutdown = true;
    plAudioSysMsg *msg = TRACKED_NEW plAudioSysMsg( plAudioSysMsg::kDestroy );
    msg->SetBCastFlag( plMessage::kBCastByExactType, false );
    msg->Send( fSys->GetKey() );
//  fSys->Shutdown();

    fInit = false;
}

void    plgAudioSys::SetChannelVolume( ASChannel chan, hsScalar vol )
{
    fChannelVolumes[ chan ] = vol;
}

void    plgAudioSys::SetGlobalFadeVolume( hsScalar vol )
{
    if(!fMuted)
        fGlobalFadeVolume = vol;
    else
        fGlobalFadeVolume = 0;
}

hsScalar    plgAudioSys::GetChannelVolume( ASChannel chan )
{
    return fChannelVolumes[ chan ];
}

void    plgAudioSys::NextDebugSound( void )
{
    fSys->NextDebugSound();
}

void plgAudioSys::Set2D3DBias( hsScalar bias )
{
    f2D3DBias = bias;
}

hsScalar plgAudioSys::Get2D3Dbias()
{
    return f2D3DBias;
}

void plgAudioSys::SetDeviceName(const char *device, hsBool restart /* = false */)
{
    fDeviceName = device;
    if(restart)
        Restart();
}

int plgAudioSys::GetNumAudioDevices()
{
    if(fSys)
        return fSys->GetNumAudioDevices();
    return 0;
}

const char *plgAudioSys::GetAudioDeviceName(int index)
{
    if(fSys)
    {
        return fSys->GetAudioDeviceName(index);
    }
    return nil;
}

ALCdevice *plgAudioSys::GetCaptureDevice()
{
    if(fSys)
    {
        return fSys->fCaptureDevice;
    }
    return nil;
}

hsBool plgAudioSys::SupportsEAX(const char *deviceName)
{
    if(fSys)
    {
        return fSys->SupportsEAX(deviceName);
    }
    return nil;
}

void plgAudioSys::RegisterSoftSound( const plKey soundKey )
{
    if(fSys)
    {
        fSys->RegisterSoftSound(soundKey);
    }
}

void plgAudioSys::UnregisterSoftSound( const plKey soundKey )
{
    if(fSys)
    {
        fSys->UnregisterSoftSound(soundKey);
    }
}

void plgAudioSys::SetListenerPos(const hsPoint3 pos)
{
    if(fSys)
    {
        fSys->SetListenerPos(pos);
    }
}

void plgAudioSys::SetListenerVelocity(const hsVector3 vel)
{
    if(fSys)
    {
        fSys->SetListenerVelocity(vel);
    }
}

void plgAudioSys::SetListenerOrientation(const hsVector3 view, const hsVector3 up)
{
    if(fSys)
    {
        fSys->SetListenerOrientation(view, up);
    }
}