1 files changed, 1801 insertions, 0 deletions

diff --git a/linden/indra/llaudio/llaudioengine.cpp b/linden/indra/llaudio/llaudioengine.cpp
new file mode 100644
index 0000000..bed791a
--- /dev/null
+++ b/linden/indra/llaudio/llaudioengine.cpp
@@ -0,0 +1,1801 @@
+ /** 
+ * @file audioengine.cpp
+ * @brief implementation of LLAudioEngine class abstracting the Open
+ * AL audio support
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include <time.h>
+
+#include "linden_common.h"
+
+#include "llaudioengine.h"
+#include "llstreamingaudio.h"
+
+#include "llerror.h"
+#include "llmath.h"
+
+#include "sound_ids.h"  // temporary hack for min/max distances
+
+#include "llvfs.h"
+#include "lldir.h"
+#include "llaudiodecodemgr.h"
+#include "llassetstorage.h"
+
+
+// necessary for grabbing sounds from sim (implemented in viewer)       
+extern void request_sound(const LLUUID &sound_guid);
+
+LLAudioEngine* gAudiop = NULL;
+
+
+//
+// LLAudioEngine implementation
+//
+
+
+LLAudioEngine::LLAudioEngine()
+{
+        setDefaults();
+}
+
+
+LLAudioEngine::~LLAudioEngine()
+{
+}
+
+LLStreamingAudioInterface* LLAudioEngine::getStreamingAudioImpl()
+{
+        return mStreamingAudioImpl;
+}
+
+void LLAudioEngine::setStreamingAudioImpl(LLStreamingAudioInterface *impl)
+{
+        mStreamingAudioImpl = impl;
+}
+
+void LLAudioEngine::setDefaults()
+{
+        mMaxWindGain = 1.f;
+
+        mListenerp = NULL;
+
+        mMuted = false;
+        mUserData = NULL;
+
+        mLastStatus = 0;
+
+        mNumChannels = 0;
+        mEnableWind = false;
+
+        S32 i;
+        for (i = 0; i < MAX_CHANNELS; i++)
+        {
+                mChannels[i] = NULL;
+        }
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                mBuffers[i] = NULL;
+        }
+
+        mMasterGain = 1.f;
+        mInternalGain = 0.f;
+        mNextWindUpdate = 0.f;
+
+        mStreamingAudioImpl = NULL;
+
+        for (U32 i = 0; i < LLAudioEngine::AUDIO_TYPE_COUNT; i++)
+                mSecondaryGain[i] = 1.0f;
+}
+
+
+bool LLAudioEngine::init(const S32 num_channels, void* userdata)
+{
+        setDefaults();
+
+        mNumChannels = num_channels;
+        mUserData = userdata;
+        
+        allocateListener();
+
+        // Initialize the decode manager
+        gAudioDecodeMgrp = new LLAudioDecodeMgr;
+
+        llinfos << "LLAudioEngine::init() AudioEngine successfully initialized" << llendl;
+
+        return true;
+}
+
+
+void LLAudioEngine::shutdown()
+{
+        // Clean up decode manager
+        delete gAudioDecodeMgrp;
+        gAudioDecodeMgrp = NULL;
+
+        // Clean up wind source
+        cleanupWind();
+
+        // Clean up audio sources
+        source_map::iterator iter_src;
+        for (iter_src = mAllSources.begin(); iter_src != mAllSources.end(); iter_src++)
+        {
+                delete iter_src->second;
+        }
+
+
+        // Clean up audio data
+        data_map::iterator iter_data;
+        for (iter_data = mAllData.begin(); iter_data != mAllData.end(); iter_data++)
+        {
+                delete iter_data->second;
+        }
+
+
+        // Clean up channels
+        S32 i;
+        for (i = 0; i < MAX_CHANNELS; i++)
+        {
+                delete mChannels[i];
+                mChannels[i] = NULL;
+        }
+
+        // Clean up buffers
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                delete mBuffers[i];
+                mBuffers[i] = NULL;
+        }
+}
+
+
+// virtual
+void LLAudioEngine::startInternetStream(const std::string& url)
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->start(url);
+}
+
+
+// virtual
+void LLAudioEngine::stopInternetStream()
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->stop();
+}
+
+// virtual
+void LLAudioEngine::pauseInternetStream(int pause)
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->pause(pause);
+}
+
+// virtual
+void LLAudioEngine::updateInternetStream()
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->update();
+}
+
+// virtual
+int LLAudioEngine::isInternetStreamPlaying()
+{
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->isPlaying();
+
+        return 0; // Stopped
+}
+
+
+// virtual
+void LLAudioEngine::setInternetStreamGain(F32 vol)
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->setGain(vol);
+}
+
+// virtual
+std::string LLAudioEngine::getInternetStreamURL()
+{
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->getURL();
+        else return std::string();
+}
+
+
+void LLAudioEngine::updateChannels()
+{
+        S32 i;
+        for (i = 0; i < MAX_CHANNELS; i++)
+        {
+                if (mChannels[i])
+                {
+                        mChannels[i]->updateBuffer();
+                        mChannels[i]->update3DPosition();
+                        mChannels[i]->updateLoop();
+                }
+        }
+}
+
+static const F32 default_max_decode_time = .002f; // 2 ms
+void LLAudioEngine::idle(F32 max_decode_time)
+{
+        if (max_decode_time <= 0.f)
+        {
+                max_decode_time = default_max_decode_time;
+        }
+        
+        // "Update" all of our audio sources, clean up dead ones.
+        // Primarily does position updating, cleanup of unused audio sources.
+        // Also does regeneration of the current priority of each audio source.
+
+        S32 i;
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                if (mBuffers[i])
+                {
+                        mBuffers[i]->mInUse = false;
+                }
+        }
+
+        F32 max_priority = -1.f;
+        LLAudioSource *max_sourcep = NULL; // Maximum priority source without a channel
+        source_map::iterator iter;
+        for (iter = mAllSources.begin(); iter != mAllSources.end();)
+        {
+                LLAudioSource *sourcep = iter->second;
+
+                // Update this source
+                sourcep->update();
+                sourcep->updatePriority();
+
+                if (sourcep->isDone())
+                {
+                        // The source is done playing, clean it up.
+                        delete sourcep;
+                        mAllSources.erase(iter++);
+                        continue;
+                }
+
+                if (sourcep->isMuted())
+                {
+                        ++iter;
+                        continue;
+                }
+
+                if (!sourcep->getChannel() && sourcep->getCurrentBuffer())
+                {
+                        // We could potentially play this sound if its priority is high enough.
+                        if (sourcep->getPriority() > max_priority)
+                        {
+                                max_priority = sourcep->getPriority();
+                                max_sourcep = sourcep;
+                        }
+                }
+
+                // Move on to the next source
+                iter++;
+        }
+
+        // Now, do priority-based organization of audio sources.
+        // All channels used, check priorities.
+        // Find channel with lowest priority
+        if (max_sourcep)
+        {
+                LLAudioChannel *channelp = getFreeChannel(max_priority);
+                if (channelp)
+                {
+                        //llinfos << "Replacing source in channel due to priority!" << llendl;
+                        max_sourcep->setChannel(channelp);
+                        channelp->setSource(max_sourcep);
+                        if (max_sourcep->isSyncSlave())
+                        {
+                                // A sync slave, it doesn't start playing until it's synced up with the master.
+                                // Flag this channel as waiting for sync, and return true.
+                                channelp->setWaiting(true);
+                        }
+                        else
+                        {
+                                channelp->setWaiting(false);
+                                if (channelp->mCurrentBufferp)
+                                {
+                                        channelp->play();
+                                }
+                        }
+                }
+        }
+
+        
+        // Do this BEFORE we update the channels
+        // Update the channels to sync up with any changes that the source made,
+        // such as changing what sound was playing.
+        updateChannels();
+
+        // Update queued sounds (switch to next queued data if the current has finished playing)
+        for (iter = mAllSources.begin(); iter != mAllSources.end(); ++iter)
+        {
+                // This is lame, instead of this I could actually iterate through all the sources
+                // attached to each channel, since only those with active channels
+                // can have anything interesting happen with their queue? (Maybe not true)
+                LLAudioSource *sourcep = iter->second;
+                if (!sourcep->mQueuedDatap || sourcep->isMuted())
+                {
+                        // Muted, or nothing queued, so we don't care.
+                        continue;
+                }
+
+                LLAudioChannel *channelp = sourcep->getChannel();
+                if (!channelp)
+                {
+                        // This sound isn't playing, so we just process move the queue
+                        sourcep->mCurrentDatap = sourcep->mQueuedDatap;
+                        sourcep->mQueuedDatap = NULL;
+
+                        // Reset the timer so the source doesn't die.
+                        sourcep->mAgeTimer.reset();
+                        // Make sure we have the buffer set up if we just decoded the data
+                        if (sourcep->mCurrentDatap)
+                        {
+                                updateBufferForData(sourcep->mCurrentDatap);
+                        }
+
+                        // Actually play the associated data.
+                        sourcep->setupChannel();
+                        channelp = sourcep->getChannel();
+                        if (channelp)
+                        {
+                                channelp->updateBuffer();
+                                sourcep->getChannel()->play();
+                        }
+                        continue;
+                }
+                else
+                {
+                        // Check to see if the current sound is done playing, or looped.
+                        if (!channelp->isPlaying())
+                        {
+                                sourcep->mCurrentDatap = sourcep->mQueuedDatap;
+                                sourcep->mQueuedDatap = NULL;
+
+                                // Reset the timer so the source doesn't die.
+                                sourcep->mAgeTimer.reset();
+
+                                // Make sure we have the buffer set up if we just decoded the data
+                                if (sourcep->mCurrentDatap)
+                                {
+                                        updateBufferForData(sourcep->mCurrentDatap);
+                                }
+
+                                // Actually play the associated data.
+                                sourcep->setupChannel();
+                                channelp->updateBuffer();
+                                sourcep->getChannel()->play();
+                        }
+                        else if (sourcep->isLoop())
+                        {
+                                // It's a loop, we need to check and see if we're done with it.
+                                if (channelp->mLoopedThisFrame)
+                                {
+                                        sourcep->mCurrentDatap = sourcep->mQueuedDatap;
+                                        sourcep->mQueuedDatap = NULL;
+
+                                        // Actually, should do a time sync so if we're a loop master/slave
+                                        // we don't drift away.
+                                        sourcep->setupChannel();
+                                        sourcep->getChannel()->play();
+                                }
+                        }
+                }
+        }
+
+        // Lame, update the channels AGAIN.
+        // Update the channels to sync up with any changes that the source made,
+        // such as changing what sound was playing.
+        updateChannels();
+        
+        // Hack!  For now, just use a global sync master;
+        LLAudioSource *sync_masterp = NULL;
+        LLAudioChannel *master_channelp = NULL;
+        F32 max_sm_priority = -1.f;
+        for (iter = mAllSources.begin(); iter != mAllSources.end(); ++iter)
+        {
+                LLAudioSource *sourcep = iter->second;
+                if (sourcep->isMuted())
+                {
+                        continue;
+                }
+                if (sourcep->isSyncMaster())
+                {
+                        if (sourcep->getPriority() > max_sm_priority)
+                        {
+                                sync_masterp = sourcep;
+                                master_channelp = sync_masterp->getChannel();
+                                max_sm_priority = sourcep->getPriority();
+                        }
+                }
+        }
+
+        if (master_channelp && master_channelp->mLoopedThisFrame)
+        {
+                // Synchronize loop slaves with their masters
+                // Update queued sounds (switch to next queued data if the current has finished playing)
+                for (iter = mAllSources.begin(); iter != mAllSources.end(); ++iter)
+                {
+                        LLAudioSource *sourcep = iter->second;
+
+                        if (!sourcep->isSyncSlave())
+                        {
+                                // Not a loop slave, we don't need to do anything
+                                continue;
+                        }
+
+                        LLAudioChannel *channelp = sourcep->getChannel();
+                        if (!channelp)
+                        {
+                                // Not playing, don't need to bother.
+                                continue;
+                        }
+
+                        if (!channelp->isPlaying())
+                        {
+                                // Now we need to check if our loop master has just looped, and
+                                // start playback if that's the case.
+                                if (sync_masterp->getChannel())
+                                {
+                                        channelp->playSynced(master_channelp);
+                                        channelp->setWaiting(false);
+                                }
+                        }
+                }
+        }
+
+        // Sync up everything that the audio engine needs done.
+        commitDeferredChanges();
+        
+        // Flush unused buffers that are stale enough
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                if (mBuffers[i])
+                {
+                        if (!mBuffers[i]->mInUse && mBuffers[i]->mLastUseTimer.getElapsedTimeF32() > 30.f)
+                        {
+                                //llinfos << "Flushing unused buffer!" << llendl;
+                                mBuffers[i]->mAudioDatap->mBufferp = NULL;
+                                delete mBuffers[i];
+                                mBuffers[i] = NULL;
+                        }
+                }
+        }
+
+
+        // Clear all of the looped flags for the channels
+        for (i = 0; i < MAX_CHANNELS; i++)
+        {
+                if (mChannels[i])
+                {
+                        mChannels[i]->mLoopedThisFrame = false;
+                }
+        }
+
+        // Decode audio files
+        gAudioDecodeMgrp->processQueue(max_decode_time);
+        
+        // Call this every frame, just in case we somehow
+        // missed picking it up in all the places that can add
+        // or request new data.
+        startNextTransfer();
+
+        updateInternetStream();
+}
+
+
+
+bool LLAudioEngine::updateBufferForData(LLAudioData *adp, const LLUUID &audio_uuid)
+{
+        if (!adp)
+        {
+                return false;
+        }
+
+        // Update the audio buffer first - load a sound if we have it.
+        // Note that this could potentially cause us to waste time updating buffers
+        // for sounds that actually aren't playing, although this should be mitigated
+        // by the fact that we limit the number of buffers, and we flush buffers based
+        // on priority.
+        if (!adp->getBuffer())
+        {
+                if (adp->hasDecodedData())
+                {
+                        return adp->load();
+                }
+                else if (adp->hasLocalData())
+                {
+                        if (audio_uuid.notNull())
+                        {
+                                gAudioDecodeMgrp->addDecodeRequest(audio_uuid);
+                        }
+                }
+                else
+                {
+                        return false;
+                }
+        }
+        return true;
+}
+
+
+void LLAudioEngine::enableWind(bool enable)
+{
+        if (enable && (!mEnableWind))
+        {
+                initWind();
+                mEnableWind = enable;
+        }
+        else if (mEnableWind && (!enable))
+        {
+                mEnableWind = enable;
+                cleanupWind();
+        }
+}
+
+
+LLAudioBuffer * LLAudioEngine::getFreeBuffer()
+{
+        static clock_t last_info = 0;
+        static bool spamming = FALSE;
+
+        S32 i;
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                if (!mBuffers[i])
+                {
+                        mBuffers[i] = createBuffer();
+                        return mBuffers[i];
+                }
+        }
+
+
+        // Grab the oldest unused buffer
+        F32 max_age = -1.f;
+        S32 buffer_id = -1;
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                if (mBuffers[i])
+                {
+                        if (!mBuffers[i]->mInUse)
+                        {
+                                if (mBuffers[i]->mLastUseTimer.getElapsedTimeF32() > max_age)
+                                {
+                                        max_age = mBuffers[i]->mLastUseTimer.getElapsedTimeF32();
+                                        buffer_id = i;
+                                }
+                        }
+                }
+        }
+
+        if (buffer_id >= 0)
+        {
+                if (clock() - last_info > CLOCKS_PER_SEC)
+                {
+                        // Do not spam us with such messages...
+                        llinfos << "Taking over unused buffer " << buffer_id << llendl;
+                        last_info = clock();
+                }
+                else if (!spamming)
+                {
+                        // ... but warn us *once* when the buffer freeing frequency is abnormal.
+                        llwarns << "Excessive buffer freeing frequency, info messages throttled." << llendl;
+                        spamming = true;
+                }
+                mBuffers[buffer_id]->mAudioDatap->mBufferp = NULL;
+                delete mBuffers[buffer_id];
+                mBuffers[buffer_id] = createBuffer();
+                return mBuffers[buffer_id];
+        }
+        return NULL;
+}
+
+
+LLAudioChannel * LLAudioEngine::getFreeChannel(const F32 priority)
+{
+        S32 i;
+        for (i = 0; i < mNumChannels; i++)
+        {
+                if (!mChannels[i])
+                {
+                        // No channel allocated here, use it.
+                        mChannels[i] = createChannel();
+                        return mChannels[i];
+                }
+                else
+                {
+                        // Channel is allocated but not playing right now, use it.
+                        if (!mChannels[i]->isPlaying() && !mChannels[i]->isWaiting())
+                        {
+                                mChannels[i]->cleanup();
+                                if (mChannels[i]->getSource())
+                                {
+                                        mChannels[i]->getSource()->setChannel(NULL);
+                                }
+                                return mChannels[i];
+                        }
+                }
+        }
+
+        // All channels used, check priorities.
+        // Find channel with lowest priority and see if we want to replace it.
+        F32 min_priority = 10000.f;
+        LLAudioChannel *min_channelp = NULL;
+
+        for (i = 0; i < mNumChannels; i++)
+        {
+                LLAudioChannel *channelp = mChannels[i];
+                LLAudioSource *sourcep = channelp->getSource();
+                if (sourcep && sourcep->getPriority() < min_priority)
+                {
+                        min_channelp = channelp;
+                        min_priority = sourcep->getPriority();
+                }
+        }
+
+        if (min_priority > priority || !min_channelp)
+        {
+                // All playing channels have higher priority, return.
+                return NULL;
+        }
+
+        // Flush the minimum priority channel, and return it.
+        min_channelp->cleanup();
+        min_channelp->getSource()->setChannel(NULL);
+        return min_channelp;
+}
+
+
+void LLAudioEngine::cleanupBuffer(LLAudioBuffer *bufferp)
+{
+        S32 i;
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                if (mBuffers[i] == bufferp)
+                {
+                        delete mBuffers[i];
+                        mBuffers[i] = NULL;
+                }
+        }
+}
+
+
+bool LLAudioEngine::preloadSound(const LLUUID &uuid)
+{
+        gAudiop->getAudioData(uuid);    // We don't care about the return value, this is just to make sure
+                                                                        // that we have an entry, which will mean that the audio engine knows about this
+
+        if (gAudioDecodeMgrp->addDecodeRequest(uuid))
+        {
+                // This means that we do have a local copy, and we're working on decoding it.
+                return true;
+        }
+
+        // At some point we need to have the audio/asset system check the static VFS
+        // before it goes off and fetches stuff from the server.
+        //llwarns << "Used internal preload for non-local sound" << llendl;
+        return false;
+}
+
+
+bool LLAudioEngine::isWindEnabled()
+{
+        return mEnableWind;
+}
+
+
+void LLAudioEngine::setMuted(bool muted)
+{
+        if (muted != mMuted)
+        {
+                mMuted = muted;
+                setMasterGain(mMasterGain);
+        }
+        enableWind(!mMuted);
+}
+
+void LLAudioEngine::setMasterGain(const F32 gain)
+{
+        mMasterGain = gain;
+        F32 internal_gain = getMuted() ? 0.f : gain;
+        if (internal_gain != mInternalGain)
+        {
+                mInternalGain = internal_gain;
+                setInternalGain(mInternalGain);
+        }
+}
+
+F32 LLAudioEngine::getMasterGain()
+{
+        return mMasterGain;
+}
+
+void LLAudioEngine::setSecondaryGain(S32 type, F32 gain)
+{
+        llassert(type < LLAudioEngine::AUDIO_TYPE_COUNT);
+        
+        mSecondaryGain[type] = gain;
+}
+
+F32 LLAudioEngine::getSecondaryGain(S32 type)
+{
+        return mSecondaryGain[type];
+}
+
+F32 LLAudioEngine::getInternetStreamGain()
+{
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->getGain();
+        else
+                return 1.0f;
+}
+
+void LLAudioEngine::setMaxWindGain(F32 gain)
+{
+        mMaxWindGain = gain;
+}
+
+
+F64 LLAudioEngine::mapWindVecToGain(LLVector3 wind_vec)
+{
+        F64 gain = 0.0;
+        
+        gain = wind_vec.magVec();
+
+        if (gain)
+        {
+                if (gain > 20)
+                {
+                        gain = 20;
+                }
+                gain = gain/20.0;
+        }
+
+        return (gain);
+} 
+
+
+F64 LLAudioEngine::mapWindVecToPitch(LLVector3 wind_vec)
+{
+        LLVector3 listen_right;
+        F64 theta;
+  
+        // Wind frame is in listener-relative coordinates
+        LLVector3 norm_wind = wind_vec;
+        norm_wind.normVec();
+        listen_right.setVec(1.0,0.0,0.0);
+
+        // measure angle between wind vec and listener right axis (on 0,PI)
+        theta = acos(norm_wind * listen_right);
+
+        // put it on 0, 1
+        theta /= F_PI;                                  
+
+        // put it on [0, 0.5, 0]
+        if (theta > 0.5) theta = 1.0-theta;
+        if (theta < 0) theta = 0;
+
+        return (theta);
+}
+
+
+F64 LLAudioEngine::mapWindVecToPan(LLVector3 wind_vec)
+{
+        LLVector3 listen_right;
+        F64 theta;
+  
+        // Wind frame is in listener-relative coordinates
+        listen_right.setVec(1.0,0.0,0.0);
+
+        LLVector3 norm_wind = wind_vec;
+        norm_wind.normVec();
+
+        // measure angle between wind vec and listener right axis (on 0,PI)
+        theta = acos(norm_wind * listen_right);
+
+        // put it on 0, 1
+        theta /= F_PI;                                  
+
+        return (theta);
+}
+
+
+void LLAudioEngine::triggerSound(const LLUUID &audio_uuid, const LLUUID& owner_id, const F32 gain,
+                                                                 const S32 type, const LLVector3d &pos_global)
+{
+        // Create a new source (since this can't be associated with an existing source.
+        //llinfos << "Localized: " << audio_uuid << llendl;
+
+        if (mMuted)
+        {
+                return;
+        }
+
+        LLUUID source_id;
+        source_id.generate();
+
+        LLAudioSource *asp = new LLAudioSource(source_id, owner_id, gain, type);
+        gAudiop->addAudioSource(asp);
+        if (pos_global.isExactlyZero())
+        {
+                asp->setAmbient(true);
+        }
+        else
+        {
+                asp->setPositionGlobal(pos_global);
+        }
+        asp->updatePriority();
+        asp->play(audio_uuid);
+}
+
+
+void LLAudioEngine::setListenerPos(LLVector3 aVec)
+{
+        mListenerp->setPosition(aVec);  
+}
+
+
+LLVector3 LLAudioEngine::getListenerPos()
+{
+        if (mListenerp)
+        {
+                return(mListenerp->getPosition());  
+        }
+        else
+        {
+                return(LLVector3::zero);
+        }
+}
+
+
+void LLAudioEngine::setListenerVelocity(LLVector3 aVec)
+{
+        mListenerp->setVelocity(aVec);  
+}
+
+
+void LLAudioEngine::translateListener(LLVector3 aVec)
+{
+        mListenerp->translate(aVec);    
+}
+
+
+void LLAudioEngine::orientListener(LLVector3 up, LLVector3 at)
+{
+        mListenerp->orient(up, at);  
+}
+
+
+void LLAudioEngine::setListener(LLVector3 pos, LLVector3 vel, LLVector3 up, LLVector3 at)
+{
+        mListenerp->set(pos,vel,up,at);  
+}
+
+
+void LLAudioEngine::setDopplerFactor(F32 factor)
+{
+        if (mListenerp)
+        {
+                mListenerp->setDopplerFactor(factor);  
+        }
+}
+
+
+F32 LLAudioEngine::getDopplerFactor()
+{
+        if (mListenerp)
+        {
+                return mListenerp->getDopplerFactor();
+        }
+        else
+        {
+                return 0.f;
+        }
+}
+
+
+void LLAudioEngine::setRolloffFactor(F32 factor)
+{
+        if (mListenerp)
+        {
+                mListenerp->setRolloffFactor(factor);  
+        }
+}
+
+
+F32 LLAudioEngine::getRolloffFactor()
+{
+        if (mListenerp)
+        {
+                return mListenerp->getRolloffFactor();  
+        }
+        else
+        {
+                return 0.f;
+        }
+}
+
+
+void LLAudioEngine::commitDeferredChanges()
+{
+        mListenerp->commitDeferredChanges();  
+}
+
+
+LLAudioSource * LLAudioEngine::findAudioSource(const LLUUID &source_id)
+{
+        source_map::iterator iter;
+        iter = mAllSources.find(source_id);
+
+        if (iter == mAllSources.end())
+        {
+                return NULL;
+        }
+        else
+        {
+                return iter->second;
+        }
+}
+
+
+LLAudioData * LLAudioEngine::getAudioData(const LLUUID &audio_uuid)
+{
+        data_map::iterator iter;
+        iter = mAllData.find(audio_uuid);
+        if (iter == mAllData.end())
+        {
+                // Create the new audio data
+                LLAudioData *adp = new LLAudioData(audio_uuid);
+                mAllData[audio_uuid] = adp;
+                return adp;
+        }
+        else
+        {
+                return iter->second;
+        }
+}
+
+void LLAudioEngine::addAudioSource(LLAudioSource *asp)
+{
+        mAllSources[asp->getID()] = asp;
+}
+
+
+void LLAudioEngine::cleanupAudioSource(LLAudioSource *asp)
+{
+        source_map::iterator iter;
+        iter = mAllSources.find(asp->getID());
+        if (iter == mAllSources.end())
+        {
+                llwarns << "Cleaning up unknown audio source!" << llendl;
+                return;
+        }
+        delete asp;
+        mAllSources.erase(iter);
+}
+
+
+bool LLAudioEngine::hasDecodedFile(const LLUUID &uuid)
+{
+        std::string uuid_str;
+        uuid.toString(uuid_str);
+
+        std::string wav_path;
+        wav_path = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str);
+        wav_path += ".dsf";
+
+        if (gDirUtilp->fileExists(wav_path))
+        {
+                return true;
+        }
+        else
+        {
+                return false;
+        }
+}
+
+
+bool LLAudioEngine::hasLocalFile(const LLUUID &uuid)
+{
+        // See if it's in the VFS.
+        return gVFS->getExists(uuid, LLAssetType::AT_SOUND);
+}
+
+
+void LLAudioEngine::startNextTransfer()
+{
+        //llinfos << "LLAudioEngine::startNextTransfer()" << llendl;
+        if (mCurrentTransfer.notNull() || getMuted())
+        {
+                //llinfos << "Transfer in progress, aborting" << llendl;
+                return;
+        }
+
+        // Get the ID for the next asset that we want to transfer.
+        // Pick one in the following order:
+        LLUUID asset_id;
+        S32 i;
+        LLAudioSource *asp = NULL;
+        LLAudioData *adp = NULL;
+        data_map::iterator data_iter;
+
+        // Check all channels for currently playing sounds.
+        F32 max_pri = -1.f;
+        for (i = 0; i < MAX_CHANNELS; i++)
+        {
+                if (!mChannels[i])
+                {
+                        continue;
+                }
+
+                asp = mChannels[i]->getSource();
+                if (!asp)
+                {
+                        continue;
+                }
+                if (asp->getPriority() <= max_pri)
+                {
+                        continue;
+                }
+
+                if (asp->getPriority() <= max_pri)
+                {
+                        continue;
+                }
+
+                adp = asp->getCurrentData();
+                if (!adp)
+                {
+                        continue;
+                }
+
+                if (!adp->hasLocalData() && adp->hasValidData())
+                {
+                        asset_id = adp->getID();
+                        max_pri = asp->getPriority();
+                }
+        }
+
+        // Check all channels for currently queued sounds.
+        if (asset_id.isNull())
+        {
+                max_pri = -1.f;
+                for (i = 0; i < MAX_CHANNELS; i++)
+                {
+                        if (!mChannels[i])
+                        {
+                                continue;
+                        }
+
+                        LLAudioSource *asp;
+                        asp = mChannels[i]->getSource();
+                        if (!asp)
+                        {
+                                continue;
+                        }
+
+                        if (asp->getPriority() <= max_pri)
+                        {
+                                continue;
+                        }
+
+                        adp = asp->getQueuedData();
+                        if (!adp)
+                        {
+                                continue;
+                        }
+
+                        if (!adp->hasLocalData() && adp->hasValidData())
+                        {
+                                asset_id = adp->getID();
+                                max_pri = asp->getPriority();
+                        }
+                }
+        }
+
+        // Check all live channels for other sounds (preloads).
+        if (asset_id.isNull())
+        {
+                max_pri = -1.f;
+                for (i = 0; i < MAX_CHANNELS; i++)
+                {
+                        if (!mChannels[i])
+                        {
+                                continue;
+                        }
+
+                        LLAudioSource *asp;
+                        asp = mChannels[i]->getSource();
+                        if (!asp)
+                        {
+                                continue;
+                        }
+
+                        if (asp->getPriority() <= max_pri)
+                        {
+                                continue;
+                        }
+
+
+                        for (data_iter = asp->mPreloadMap.begin(); data_iter != asp->mPreloadMap.end(); data_iter++)
+                        {
+                                LLAudioData *adp = data_iter->second;
+                                if (!adp)
+                                {
+                                        continue;
+                                }
+
+                                if (!adp->hasLocalData() && adp->hasValidData())
+                                {
+                                        asset_id = adp->getID();
+                                        max_pri = asp->getPriority();
+                                }
+                        }
+                }
+        }
+
+        // Check all sources
+        if (asset_id.isNull())
+        {
+                max_pri = -1.f;
+                source_map::iterator source_iter;
+                for (source_iter = mAllSources.begin(); source_iter != mAllSources.end(); source_iter++)
+                {
+                        asp = source_iter->second;
+                        if (!asp)
+                        {
+                                continue;
+                        }
+
+                        if (asp->getPriority() <= max_pri)
+                        {
+                                continue;
+                        }
+
+                        adp = asp->getCurrentData();
+                        if (adp && !adp->hasLocalData() && adp->hasValidData())
+                        {
+                                asset_id = adp->getID();
+                                max_pri = asp->getPriority();
+                                continue;
+                        }
+
+                        adp = asp->getQueuedData();
+                        if (adp && !adp->hasLocalData() && adp->hasValidData())
+                        {
+                                asset_id = adp->getID();
+                                max_pri = asp->getPriority();
+                                continue;
+                        }
+
+                        for (data_iter = asp->mPreloadMap.begin(); data_iter != asp->mPreloadMap.end(); data_iter++)
+                        {
+                                LLAudioData *adp = data_iter->second;
+                                if (!adp)
+                                {
+                                        continue;
+                                }
+
+                                if (!adp->hasLocalData() && adp->hasValidData())
+                                {
+                                        asset_id = adp->getID();
+                                        max_pri = asp->getPriority();
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        if (asset_id.notNull())
+        {
+                llinfos << "Getting asset data for: " << asset_id << llendl;
+                gAudiop->mCurrentTransfer = asset_id;
+                gAudiop->mCurrentTransferTimer.reset();
+                gAssetStorage->getAssetData(asset_id, LLAssetType::AT_SOUND,
+                                                                        assetCallback, NULL);
+        }
+        else
+        {
+                //llinfos << "No pending transfers?" << llendl;
+        }
+}
+
+
+// static
+void LLAudioEngine::assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status)
+{
+        if (result_code)
+        {
+                llinfos << "Boom, error in audio file transfer: " << LLAssetStorage::getErrorString( result_code ) << " (" << result_code << ")" << llendl;
+                // Need to mark data as bad to avoid constant rerequests.
+                LLAudioData *adp = gAudiop->getAudioData(uuid);
+                if (adp)
+        {
+                        adp->setHasValidData(false);
+                        adp->setHasLocalData(false);
+                        adp->setHasDecodedData(false);
+                }
+        }
+        else
+        {
+                LLAudioData *adp = gAudiop->getAudioData(uuid);
+                if (!adp)
+        {
+                        // Should never happen
+                        llwarns << "Got asset callback without audio data for " << uuid << llendl;
+        }
+                else
+                {
+                        adp->setHasValidData(true);
+                    adp->setHasLocalData(true);
+                    gAudioDecodeMgrp->addDecodeRequest(uuid);
+                }
+        }
+        gAudiop->mCurrentTransfer = LLUUID::null;
+        gAudiop->startNextTransfer();
+}
+
+
+//
+// LLAudioSource implementation
+//
+
+
+LLAudioSource::LLAudioSource(const LLUUID& id, const LLUUID& owner_id, const F32 gain, const S32 type)
+:       mID(id),
+        mOwnerID(owner_id),
+        mPriority(0.f),
+        mGain(gain),
+        mSourceMuted(false),
+        mAmbient(false),
+        mLoop(false),
+        mSyncMaster(false),
+        mSyncSlave(false),
+        mQueueSounds(false),
+        mPlayedOnce(false),
+        mType(type),
+        mChannelp(NULL),
+        mCurrentDatap(NULL),
+        mQueuedDatap(NULL)
+{
+}
+
+
+LLAudioSource::~LLAudioSource()
+{
+        if (mChannelp)
+        {
+                // Stop playback of this sound
+                mChannelp->setSource(NULL);
+                mChannelp = NULL;
+        }
+}
+
+
+void LLAudioSource::setChannel(LLAudioChannel *channelp)
+{
+        if (channelp == mChannelp)
+        {
+                return;
+        }
+
+        mChannelp = channelp;
+}
+
+
+void LLAudioSource::update()
+{
+        if (!getCurrentBuffer())
+        {
+                if (getCurrentData())
+                {
+                        // Hack - try and load the sound.  Will do this as a callback
+                        // on decode later.
+                        if (getCurrentData()->load())
+                        {
+                                play(getCurrentData()->getID());
+                        }                       
+                }
+        }
+}
+
+void LLAudioSource::updatePriority()
+{
+        if (isAmbient())
+        {
+                mPriority = 1.f;
+        }
+        else if (isMuted())
+        {
+                mPriority = 0.f;
+        }
+        else
+        {
+                // Priority is based on distance
+                LLVector3 dist_vec;
+                dist_vec.setVec(getPositionGlobal());
+                dist_vec -= gAudiop->getListenerPos();
+                F32 dist_squared = llmax(1.f, dist_vec.magVecSquared());
+
+                mPriority = mGain / dist_squared;
+        }
+}
+
+bool LLAudioSource::setupChannel()
+{
+        LLAudioData *adp = getCurrentData();
+
+        if (!adp->getBuffer())
+        {
+                // We're not ready to play back the sound yet, so don't try and allocate a channel for it.
+                //llwarns << "Aborting, no buffer" << llendl;
+                return false;
+        }
+
+
+        if (!mChannelp)
+        {
+                // Update the priority, in case we need to push out another channel.
+                updatePriority();
+
+                setChannel(gAudiop->getFreeChannel(getPriority()));
+        }
+
+        if (!mChannelp)
+        {
+                // Ugh, we don't have any free channels.
+                // Now we have to reprioritize.
+                // For now, just don't play the sound.
+                //llwarns << "Aborting, no free channels" << llendl;
+                return false;
+        }
+
+        mChannelp->setSource(this);
+        return true;
+}
+
+
+bool LLAudioSource::play(const LLUUID &audio_uuid)
+{
+        // Special abuse of play(); don't play a sound, but kill it.
+        if (audio_uuid.isNull())
+        {
+                if (getChannel())
+                {
+                        getChannel()->setSource(NULL);
+                        setChannel(NULL);
+                        if (!isMuted())
+                        {
+                                mCurrentDatap = NULL;
+                        }
+                }
+                return false;
+        }
+
+        // Reset our age timeout if someone attempts to play the source.
+        mAgeTimer.reset();
+
+        LLAudioData *adp = gAudiop->getAudioData(audio_uuid);
+        addAudioData(adp);
+
+        if (isMuted())
+        {
+                return false;
+        }
+
+        bool has_buffer = gAudiop->updateBufferForData(adp, audio_uuid);
+        if (!has_buffer)
+        {
+                // Don't bother trying to set up a channel or anything, we don't have an audio buffer.
+                return false;
+        }
+
+        if (!setupChannel())
+        {
+                return false;
+        }
+
+        if (isSyncSlave())
+        {
+                // A sync slave, it doesn't start playing until it's synced up with the master.
+                // Flag this channel as waiting for sync, and return true.
+                getChannel()->setWaiting(true);
+                return true;
+        }
+
+        getChannel()->play();
+        return true;
+}
+
+
+bool LLAudioSource::isDone() const
+{
+        const F32 MAX_AGE = 60.f;
+        const F32 MAX_UNPLAYED_AGE = 15.f;
+        const F32 MAX_MUTED_AGE = 11.f;
+
+        if (isLoop())
+        {
+                // Looped sources never die on their own.
+                return false;
+        }
+
+        if (hasPendingPreloads())
+        {
+                return false;
+        }
+
+        if (mQueuedDatap)
+        {
+                // Don't kill this sound if we've got something queued up to play.
+                return false;
+        }
+
+        F32 elapsed = mAgeTimer.getElapsedTimeF32();
+
+        // This is a single-play source
+        if (!mChannelp)
+        {
+                if ((elapsed > (mSourceMuted ? MAX_MUTED_AGE : MAX_UNPLAYED_AGE)) || mPlayedOnce)
+                {
+                        // We don't have a channel assigned, and it's been
+                        // over 15 seconds since we tried to play it.  Don't bother.
+                        //llinfos << "No channel assigned, source is done" << llendl;
+                        return true;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        if (mChannelp->isPlaying())
+        {
+                if (elapsed > MAX_AGE)
+                {
+                        // Arbitarily cut off non-looped sounds when they're old.
+                        return true;
+                }
+                else
+                {
+                        // Sound is still playing and we haven't timed out, don't kill it.
+                        return false;
+                }
+        }
+
+        if ((elapsed > MAX_UNPLAYED_AGE) || mPlayedOnce)
+        {
+                // The sound isn't playing back after 15 seconds or we're already done playing it, kill it.
+                return true;
+        }
+
+        return false;
+}
+
+
+void LLAudioSource::addAudioData(LLAudioData *adp, const bool set_current)
+{
+        // Only handle a single piece of audio data associated with a source right now,
+        // until I implement prefetch.
+        if (set_current)
+        {
+                if (!mCurrentDatap)
+                {
+                        mCurrentDatap = adp;
+                        if (mChannelp)
+                        {
+                                mChannelp->updateBuffer();
+                                mChannelp->play();
+                        }
+
+                        // Make sure the audio engine knows that we want to request this sound.
+                        gAudiop->startNextTransfer();
+                        return;
+                }
+                else if (mQueueSounds)
+                {
+                        // If we have current data, and we're queuing, put
+                        // the object onto the queue.
+                        if (mQueuedDatap)
+                        {
+                                // We only queue one sound at a time, and it's a FIFO.
+                                // Don't put it onto the queue.
+                                return;
+                        }
+
+                        if (adp == mCurrentDatap && isLoop())
+                        {
+                                // No point in queueing the same sound if
+                                // we're looping.
+                                return;
+                        }
+                        mQueuedDatap = adp;
+
+                        // Make sure the audio engine knows that we want to request this sound.
+                        gAudiop->startNextTransfer();
+                }
+                else
+                {
+                        if (mCurrentDatap != adp)
+                        {
+                                // Right now, if we're currently playing this sound in a channel, we
+                                // update the buffer that the channel's associated with
+                                // and play it.  This may not be the correct behavior.
+                                mCurrentDatap = adp;
+                                if (mChannelp)
+                                {
+                                        mChannelp->updateBuffer();
+                                        mChannelp->play();
+                                }
+                                // Make sure the audio engine knows that we want to request this sound.
+                                gAudiop->startNextTransfer();
+                        }
+                }
+        }
+        else
+        {
+                // Add it to the preload list.
+                mPreloadMap[adp->getID()] = adp;
+                gAudiop->startNextTransfer();
+        }
+}
+
+
+bool LLAudioSource::hasPendingPreloads() const
+{
+        // Check to see if we've got any preloads on deck for this source
+        data_map::const_iterator iter;
+        for (iter = mPreloadMap.begin(); iter != mPreloadMap.end(); iter++)
+        {
+                LLAudioData *adp = iter->second;
+                // note: a bad UUID will forever be !hasDecodedData()
+                // but also !hasValidData(), hence the check for hasValidData()
+                if (!adp->hasDecodedData() && adp->hasValidData())
+                {
+                        // This source is still waiting for a preload
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+
+LLAudioData * LLAudioSource::getCurrentData()
+{
+        return mCurrentDatap;
+}
+
+LLAudioData * LLAudioSource::getQueuedData()
+{
+        return mQueuedDatap;
+}
+
+LLAudioBuffer * LLAudioSource::getCurrentBuffer()
+{
+        if (!mCurrentDatap)
+        {
+                return NULL;
+        }
+
+        return mCurrentDatap->getBuffer();
+}
+
+
+
+
+//
+// LLAudioChannel implementation
+//
+
+
+LLAudioChannel::LLAudioChannel() :
+        mCurrentSourcep(NULL),
+        mCurrentBufferp(NULL),
+        mLoopedThisFrame(false),
+        mWaiting(false),
+        mSecondaryGain(1.0f)
+{
+}
+
+
+LLAudioChannel::~LLAudioChannel()
+{
+        // Need to disconnect any sources which are using this channel.
+        //llinfos << "Cleaning up audio channel" << llendl;
+        if (mCurrentSourcep)
+        {
+                mCurrentSourcep->setChannel(NULL);
+        }
+        mCurrentBufferp = NULL;
+}
+
+
+void LLAudioChannel::setSource(LLAudioSource *sourcep)
+{
+        //llinfos << this << ": setSource(" << sourcep << ")" << llendl;
+
+        if (!sourcep)
+        {
+                // Clearing the source for this channel, don't need to do anything.
+                //llinfos << "Clearing source for channel" << llendl;
+                cleanup();
+                mCurrentSourcep = NULL;
+                mWaiting = false;
+                return;
+        }
+
+        if (sourcep == mCurrentSourcep)
+        {
+                // Don't reallocate the channel, this will make FMOD goofy.
+                //llinfos << "Calling setSource with same source!" << llendl;
+        }
+
+        mCurrentSourcep = sourcep;
+
+
+        updateBuffer();
+        update3DPosition();
+}
+
+
+bool LLAudioChannel::updateBuffer()
+{
+        if (!mCurrentSourcep)
+        {
+                // This channel isn't associated with any source, nothing
+                // to be updated
+                return false;
+        }
+
+        // Initialize the channel's gain setting for this sound.
+        if(gAudiop)
+        {
+                setSecondaryGain(gAudiop->getSecondaryGain(mCurrentSourcep->getType()));
+        }
+
+        LLAudioBuffer *bufferp = mCurrentSourcep->getCurrentBuffer();
+        if (bufferp == mCurrentBufferp)
+        {
+                if (bufferp)
+                {
+                        // The source hasn't changed what buffer it's playing
+                        bufferp->mLastUseTimer.reset();
+                        bufferp->mInUse = true;
+                }
+                return false;
+        }
+
+        //
+        // The source changed what buffer it's playing.  We need to clean up
+        // the existing channel
+        //
+        cleanup();
+
+        mCurrentBufferp = bufferp;
+        if (bufferp)
+        {
+                bufferp->mLastUseTimer.reset();
+                bufferp->mInUse = true;
+        }
+
+        if (!mCurrentBufferp)
+        {
+                // There's no new buffer to be played, so we just abort.
+                return false;
+        }
+
+        return true;
+}
+
+
+
+
+//
+// LLAudioData implementation
+//
+
+
+LLAudioData::LLAudioData(const LLUUID &uuid) :
+        mID(uuid),
+        mBufferp(NULL),
+        mHasLocalData(false),
+        mHasDecodedData(false),
+        mHasValidData(true)
+{
+        if (uuid.isNull())
+        {
+                // This is a null sound.
+                return;
+        }
+        
+        if (gAudiop && gAudiop->hasDecodedFile(uuid))
+        {
+                // Already have a decoded version, don't need to decode it.
+                mHasLocalData = true;
+                mHasDecodedData = true;
+        }
+        else if (gAssetStorage && gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
+        {
+                mHasLocalData = true;
+        }
+}
+
+
+bool LLAudioData::load()
+{
+        static clock_t last_info = 0;
+
+        // For now, just assume we're going to use one buffer per audiodata.
+        if (mBufferp)
+        {
+                // We already have this sound in a buffer, don't do anything.
+                llinfos << "Already have a buffer for this sound, don't bother loading!" << llendl;
+                return true;
+        }
+        
+        mBufferp = gAudiop->getFreeBuffer();
+        if (!mBufferp)
+        {
+                // No free buffers, abort.
+                if (clock() - last_info > CLOCKS_PER_SEC)       // Do not spam us with such messages
+                {
+                        llinfos << "Not able to allocate a new audio buffer, aborting." << llendl;
+                        last_info = clock();
+                }
+                return false;
+        }
+
+        std::string uuid_str;
+        std::string wav_path;
+        mID.toString(uuid_str);
+        wav_path= gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str) + ".dsf";
+
+        if (!mBufferp->loadWAV(wav_path))
+        {
+                // Hrm.  Right now, let's unset the buffer, since it's empty.
+                gAudiop->cleanupBuffer(mBufferp);
+                mBufferp = NULL;
+
+                // Maybe it was removed by another instance.  Send it to the preload queue.
+                gAudiop->preloadSound(mID);
+
+                return false;
+        }
+        mBufferp->mAudioDatap = this;
+        return true;
+}
+
+