Second Life viewer sources 1.13.2.12

18 files changed, 5847 insertions, 0 deletions

diff --git a/linden/indra/llaudio/audioengine.cpp b/linden/indra/llaudio/audioengine.cpp
new file mode 100644
index 0000000..46e621a
--- /dev/null
+++ b/linden/indra/llaudio/audioengine.cpp
@@ -0,0 +1,1672 @@
+/** 
+ * @file audioengine.cpp
+ * @brief implementation of LLAudioEngine class abstracting the Open
+ * AL audio support
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#if LL_LINUX
+#include <time.h>
+#endif
+
+//#include "message.h"
+
+#include "audioengine.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;
+
+// Maximum amount of time we wait for a transfer to complete before starting
+// off another one.
+const F32 MAX_CURRENT_TRANSFER_TIME = 60.f;
+
+//
+// LLAudioEngine implementation
+//
+
+
+LLAudioEngine::LLAudioEngine()
+{
+}
+
+
+LLAudioEngine::~LLAudioEngine()
+{
+}
+
+
+BOOL LLAudioEngine::init(const S32 num_channels, void* userdata)
+{
+        mMuted = FALSE;
+        mMasterGain = 1.f;
+        mInternetStreamGain = 0.125f;
+        mUserData = userdata;
+        mLastStatus = 0;
+
+        mNumChannels = num_channels;
+        
+
+        mMaxWindGain = 1.0;
+
+        mEnableWind = FALSE;
+
+        S32 i;
+        for (i = 0; i < MAX_BUFFERS; i++)
+        {
+                mBuffers[i] = NULL;
+        }
+        for (i = 0; i < num_channels; i++)
+        {
+                mChannels[i] = NULL;
+        }
+        
+        allocateListener();
+
+        // Initialize the decode manager
+        gAudioDecodeMgrp = new LLAudioDecodeMgr;
+
+        return TRUE;
+}
+
+
+void LLAudioEngine::shutdown()
+{
+        // Clean up decode manager
+        delete gAudioDecodeMgrp;
+        gAudioDecodeMgrp = NULL;
+
+        // 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;
+        if (mChannels)
+        {
+                for (i = 0; i < MAX_CHANNELS; i++)
+                {
+                        if (mChannels[i])
+                        {
+                                delete mChannels[i];
+                                mChannels[i] = NULL;
+                        }
+                }
+        }
+
+        // Clean up buffers
+        if (mBuffers)
+        {
+                for (i = 0; i < MAX_BUFFERS; i++)
+                {
+                        if (mBuffers[i])
+                        {
+                                delete mBuffers[i];
+                                mBuffers[i] = NULL;
+                        }
+                }
+        }
+}
+
+
+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.
+
+        if (getMuted())
+        {
+                setInternalGain(0.f);
+        }
+        else
+        {
+                setInternalGain(getMasterGain());
+        }
+
+        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->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);
+                                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)
+                {
+                        // 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->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();
+}
+
+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())
+                {
+                        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()
+{
+        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)
+        {
+                llinfos << "Taking over unused buffer " << buffer_id << llendl;
+                //llinfos << "Flushing unused buffer!" << llendl;
+                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->getPriority() < min_priority)
+                {
+                        min_channelp = channelp;
+                        min_priority = sourcep->getPriority();
+                }
+        }
+
+        if (min_priority > priority)
+        {
+                // 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)
+{
+        mMuted = muted;
+        enableWind(!mMuted);
+}
+
+
+void LLAudioEngine::setMasterGain(const F32 gain)
+{
+        mMasterGain = gain;
+        setInternalGain(gain);
+}
+
+F32 LLAudioEngine::getMasterGain()
+{
+        return mMasterGain;
+}
+
+F32 LLAudioEngine::getInternetStreamGain()
+{
+        return mInternetStreamGain;
+}
+
+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 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);
+        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::setDistanceFactor(F32 factor)
+{
+        if (mListenerp)
+        {
+                mListenerp->setDistanceFactor(factor);  
+        }
+}
+
+
+F32 LLAudioEngine::getDistanceFactor()
+{
+        if (mListenerp)
+        {
+                return mListenerp->getDistanceFactor();
+        }
+        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)
+{
+        char uuid_str[UUID_STR_LENGTH];                 /*Flawfinder: ignore*/
+        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)
+{
+        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)
+:       mID(id),
+        mOwnerID(owner_id),
+        mPriority(0.f),
+        mGain(gain),
+        mAmbient(FALSE),
+        mLoop(FALSE),
+        mSyncMaster(FALSE),
+        mSyncSlave(FALSE),
+        mQueueSounds(FALSE),
+        mPlayedOnce(FALSE),
+        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
+        {
+                // 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)
+{
+        if (audio_uuid.isNull())
+        {
+                if (getChannel())
+                {
+                        getChannel()->setSource(NULL);
+                        setChannel(NULL);
+                        addAudioData(NULL, TRUE);
+                }
+        }
+        // Reset our age timeout if someone attempts to play the source.
+        mAgeTimer.reset();
+
+        LLAudioData *adp = gAudiop->getAudioData(audio_uuid);
+
+        BOOL has_buffer = gAudiop->updateBufferForData(adp, audio_uuid);
+
+
+        addAudioData(adp);
+
+        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 F32 MAX_AGE = 60.f;
+        const F32 MAX_UNPLAYED_AGE = 15.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 > MAX_UNPLAYED_AGE) || mPlayedOnce)
+                {
+                        // We don't have a channel assigned, and it's been
+                        // over 5 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 20 seconds 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 5 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;
+                if (!adp->hasDecodedData())
+                {
+                        // 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)
+{
+}
+
+
+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;
+        }
+
+        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.  Whe need to clean up the
+        // existing fmod 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->hasDecodedFile(uuid))
+        {
+                // Already have a decoded version, don't need to decode it.
+                mHasLocalData = TRUE;
+                mHasDecodedData = TRUE;
+        }
+        else if (gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
+        {
+                mHasLocalData = TRUE;
+        }
+}
+
+
+BOOL LLAudioData::load()
+{
+        // 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.
+                llinfos << "Not able to allocate a new audio buffer, aborting." << llendl;
+                return FALSE;
+        }
+
+        char uuid_str[UUID_STR_LENGTH];                 /*Flawfinder: ignore*/
+        char wav_path[MAX_PATH];                                /*Flawfinder: ignore*/
+        mID.toString(uuid_str);
+        snprintf(wav_path, MAX_PATH, "%s.dsf",gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str).c_str()); /*Flawfinder: ignore*/
+
+        if (!mBufferp->loadWAV(wav_path))
+        {
+                // Hrm.  Right now, let's unset the buffer, since it's empty.
+                gAudiop->cleanupBuffer(mBufferp);
+                mBufferp = NULL;
+
+                return FALSE;
+        }
+        mBufferp->mAudioDatap = this;
+        return TRUE;
+}
+
diff --git a/linden/indra/llaudio/audioengine.h b/linden/indra/llaudio/audioengine.h
new file mode 100644
index 0000000..83f822b
--- /dev/null
+++ b/linden/indra/llaudio/audioengine.h
@@ -0,0 +1,428 @@
+/** 
+ * @file audioengine.h
+ * @brief Definition of LLAudioEngine base class abstracting the audio support
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+
+#ifndef LL_AUDIOENGINE_H
+#define LL_AUDIOENGINE_H
+
+#include <list>
+#include <map>
+
+#ifndef LL_FMOD
+#  define LL_FMOD 1
+#endif
+
+#include "listener.h"
+#include "v3math.h"
+#include "v3dmath.h"
+#include "listener.h"
+#include "lltimer.h"
+#include "lluuid.h"
+#include "llframetimer.h"
+#include "llassettype.h"
+
+const F32 LL_WIND_UPDATE_INTERVAL = 0.1f;
+const F32 LL_ROLLOFF_MULTIPLIER_UNDER_WATER = 5.f;                      //  How much sounds are weaker under water
+const F32 LL_WIND_UNDERWATER_CENTER_FREQ = 20.f;
+
+const F32 ATTACHED_OBJECT_TIMEOUT = 5.0f;
+const F32 DEFAULT_MIN_DISTANCE = 2.0f;
+
+#define MAX_CHANNELS 30
+#define MAX_BUFFERS 40  // Some extra for preloading, maybe?
+
+// This define is intended to allow us to switch from os based wav
+// file loading to vfs based wav file loading. The problem is that I
+// am unconvinced that the LLWaveFile works for loading sounds from
+// memory. So, until that is fixed up, changed, whatever, this remains
+// undefined.
+//#define USE_WAV_VFILE
+
+class LLVFS;
+
+class LLAudioSource;
+class LLAudioData;
+class LLAudioChannel;
+class LLAudioBuffer;
+
+
+
+//
+//  LLAudioEngine definition
+//
+
+class LLAudioEngine 
+{
+public:
+        LLAudioEngine();
+        virtual ~LLAudioEngine();
+
+        // initialization/startup/shutdown
+        //virtual BOOL init();
+
+        virtual BOOL init(const S32 num_channels, void *userdata);
+        virtual void shutdown();
+
+        // Used by the mechanics of the engine
+        //virtual void processQueue(const LLUUID &sound_guid);
+        virtual void setListener(LLVector3 pos,LLVector3 vel,LLVector3 up,LLVector3 at);
+        virtual void updateWind(LLVector3 direction, F32 camera_height_above_water) = 0;
+        virtual void idle(F32 max_decode_time = 0.f);
+        virtual void updateChannels();
+
+        //
+        // "End user" functionality
+        //
+        virtual BOOL isWindEnabled();
+        virtual void enableWind(BOOL state_b);
+
+        // Use these for temporarily muting the audio system.
+        // Does not change buffers, initialization, etc. but
+        // stops playing new sounds.
+        virtual void setMuted(BOOL muted);
+        virtual BOOL getMuted() const { return mMuted; }
+
+        F32 getMasterGain();
+        void setMasterGain(F32 gain);
+
+        F32 getInternetStreamGain();
+
+        virtual void setDopplerFactor(F32 factor);
+        virtual F32 getDopplerFactor();
+        virtual void setDistanceFactor(F32 factor);
+        virtual F32 getDistanceFactor();
+        virtual void setRolloffFactor(F32 factor);
+        virtual F32 getRolloffFactor();
+        virtual void setMaxWindGain(F32 gain);
+
+
+        // Methods actually related to setting up and removing sounds
+        // Owner ID is the owner of the object making the request
+        void triggerSound(const LLUUID &sound_id, const LLUUID& owner_id, const F32 gain, const LLVector3d &pos_global = LLVector3d::zero);
+        BOOL preloadSound(const LLUUID &id);
+
+        void addAudioSource(LLAudioSource *asp);
+        void cleanupAudioSource(LLAudioSource *asp);
+
+        LLAudioSource *findAudioSource(const LLUUID &source_id);
+        LLAudioData *getAudioData(const LLUUID &audio_uuid);
+
+
+        virtual void startInternetStream(const char* url) = 0;
+        virtual void stopInternetStream() = 0;
+        virtual void pauseInternetStream(int pause) = 0;
+        virtual int isInternetStreamPlaying() = 0;
+        virtual void getInternetStreamInfo(char* artist, char* title) { artist[0] = 0; title[0] = 0; }
+        // use a value from 0.0 to 1.0, inclusive
+        virtual void setInternetStreamGain(F32 vol) { mInternetStreamGain = vol; }
+        virtual const char* getInternetStreamURL() { return ""; }
+
+        // For debugging usage
+        virtual LLVector3 getListenerPos();
+
+        LLAudioBuffer *getFreeBuffer(); // Get a free buffer, or flush an existing one if you have to.
+        LLAudioChannel *getFreeChannel(const F32 priority); // Get a free channel or flush an existing one if your priority is higher
+        void cleanupBuffer(LLAudioBuffer *bufferp);
+
+        BOOL hasDecodedFile(const LLUUID &uuid);
+        BOOL hasLocalFile(const LLUUID &uuid);
+
+        BOOL updateBufferForData(LLAudioData *adp, const LLUUID &audio_uuid = LLUUID::null);
+
+
+        // Asset callback when we're retrieved a sound from the asset server.
+        void startNextTransfer();
+        static void assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code);
+
+
+        friend class LLPipeline; // For debugging
+public:
+        F32 mMaxWindGain; // Hack.  Public to set before fade in?
+
+protected:
+        virtual LLAudioBuffer *createBuffer() = 0;
+        virtual LLAudioChannel *createChannel() = 0;
+
+        virtual void initWind() = 0;
+        virtual void cleanupWind() = 0;
+        virtual void setInternalGain(F32 gain) = 0;
+
+        void commitDeferredChanges();
+
+        virtual void allocateListener() = 0;
+
+
+        // Internet stream methods
+        virtual void initInternetStream() {}
+        virtual void updateInternetStream() {}
+
+
+        // listener methods
+        virtual void setListenerPos(LLVector3 vec);
+        virtual void setListenerVelocity(LLVector3 vec);
+        virtual void orientListener(LLVector3 up, LLVector3 at);
+        virtual void translateListener(LLVector3 vec);
+
+
+        F64 mapWindVecToGain(LLVector3 wind_vec);
+        F64 mapWindVecToPitch(LLVector3 wind_vec);
+        F64 mapWindVecToPan(LLVector3 wind_vec);
+
+protected:
+        LLListener *mListenerp;
+
+        BOOL mMuted;
+        void* mUserData;
+
+        S32 mLastStatus;
+        
+        S32 mNumChannels;
+        BOOL mEnableWind;
+
+        LLUUID mCurrentTransfer; // Audio file currently being transferred by the system
+        LLFrameTimer mCurrentTransferTimer;
+
+        // A list of all audio sources that are known to the viewer at this time.
+        // This is most likely a superset of the ones that we actually have audio
+        // data for, or are playing back.
+        typedef std::map<LLUUID, LLAudioSource *> source_map;
+        typedef std::map<LLUUID, LLAudioData *> data_map;
+
+        source_map mAllSources;
+        data_map mAllData;
+
+        LLAudioChannel *mChannels[MAX_CHANNELS];
+
+        // Buffers needs to change into a different data structure, as the number of buffers
+        // that we have active should be limited by RAM usage, not count.
+        LLAudioBuffer *mBuffers[MAX_BUFFERS];
+        
+        F32 mMasterGain;
+
+        // Hack!  Internet streams are treated differently from other sources!
+        F32 mInternetStreamGain;
+
+        F32 mNextWindUpdate;
+
+        LLFrameTimer mWindUpdateTimer;
+};
+
+
+
+
+//
+// Standard audio source.  Can be derived from for special sources, such as those attached to objects.
+//
+
+
+class LLAudioSource
+{
+public:
+        // owner_id is the id of the agent responsible for making this sound
+        // play, for example, the owner of the object currently playing it
+        LLAudioSource(const LLUUID &id, const LLUUID& owner_id, const F32 gain);
+        virtual ~LLAudioSource();
+
+        virtual void update();                                          // Update this audio source
+        void updatePriority();
+
+        void preload(const LLUUID &audio_id); // Only used for preloading UI sounds, now.
+
+        void addAudioData(LLAudioData *adp, BOOL set_current = TRUE);
+
+        void setAmbient(const BOOL ambient)                                             { mAmbient = ambient; }
+        BOOL isAmbient() const                                                                  { return mAmbient; }
+
+        void setLoop(const BOOL loop)                                                   { mLoop = loop; }
+        BOOL isLoop() const                                                                             { return mLoop; }
+
+        void setSyncMaster(const BOOL master)                                   { mSyncMaster = master; }
+        BOOL isSyncMaster() const                                                               { return mSyncMaster; }
+
+        void setSyncSlave(const BOOL slave)                                             { mSyncSlave = slave; }
+        BOOL isSyncSlave() const                                                                { return mSyncSlave; }
+
+        void setQueueSounds(const BOOL queue)                                   { mQueueSounds = queue; }
+        BOOL isQueueSounds() const                                                              { return mQueueSounds; }
+
+        void setPlayedOnce(const BOOL played_once)                              { mPlayedOnce = played_once; }
+
+        void setPositionGlobal(const LLVector3d &position_global)               { mPositionGlobal = position_global; }
+        LLVector3d getPositionGlobal() const                                                    { return mPositionGlobal; }
+        LLVector3 getVelocity() const                                                                   { return mVelocity; }                           
+        F32 getPriority() const                                                                                 { return mPriority; }
+
+        // Gain should always be clamped between 0 and 1.
+        F32 getGain() const                                                                                             { return mGain; }
+        virtual void setGain(const F32 gain)                                                    { mGain = llclamp(gain, 0.f, 1.f); }
+
+        const LLUUID &getID() const             { return mID; }
+        BOOL isDone();
+
+        LLAudioData *getCurrentData();
+        LLAudioData *getQueuedData();
+        LLAudioBuffer *getCurrentBuffer();
+
+        BOOL setupChannel();
+        BOOL play(const LLUUID &audio_id);      // Start the audio source playing
+
+        BOOL hasPendingPreloads() const;        // Has preloads that haven't been done yet
+
+        friend class LLAudioEngine;
+        friend class LLAudioChannel;
+protected:
+        void setChannel(LLAudioChannel *channelp);
+        LLAudioChannel *getChannel() const                                              { return mChannelp; }
+
+protected:
+        LLUUID                  mID; // The ID of the source is that of the object if it's attached to an object.
+        LLUUID                  mOwnerID;       // owner of the object playing the sound
+        F32                             mPriority;
+        F32                             mGain;
+        BOOL                    mAmbient;
+        BOOL                    mLoop;
+        BOOL                    mSyncMaster;
+        BOOL                    mSyncSlave;
+        BOOL                    mQueueSounds;
+        BOOL                    mPlayedOnce;
+        LLVector3d              mPositionGlobal;
+        LLVector3               mVelocity;
+
+        //LLAudioSource *mSyncMasterp;  // If we're a slave, the source that we're synced to.
+        LLAudioChannel  *mChannelp;             // If we're currently playing back, this is the channel that we're assigned to.
+        LLAudioData             *mCurrentDatap;
+        LLAudioData             *mQueuedDatap;
+
+        typedef std::map<LLUUID, LLAudioData *> data_map;
+        data_map mPreloadMap;
+
+        LLFrameTimer mAgeTimer;
+};
+
+
+
+
+//
+// Generic metadata about a particular piece of audio data.
+// The actual data is handled by the derived LLAudioBuffer classes which are
+// derived for each audio engine.
+//
+
+
+class LLAudioData
+{
+public:
+        LLAudioData(const LLUUID &uuid);
+        BOOL load();
+
+        LLUUID getID() const                            { return mID; }
+        LLAudioBuffer *getBuffer() const        { return mBufferp; }
+
+        BOOL    hasLocalData() const            { return mHasLocalData; }
+        BOOL    hasDecodedData() const          { return mHasDecodedData; }
+        BOOL    hasValidData() const            { return mHasValidData; }
+
+        void    setHasLocalData(const BOOL hld)         { mHasLocalData = hld; }
+        void    setHasDecodedData(const BOOL hdd)       { mHasDecodedData = hdd; }
+        void    setHasValidData(const BOOL hvd)         { mHasValidData = hvd; }
+
+        friend class LLAudioEngine; // Severe laziness, bad.
+
+protected:
+        LLUUID mID;
+        LLAudioBuffer *mBufferp;        // If this data is being used by the audio system, a pointer to the buffer will be set here.
+        BOOL mHasLocalData;
+        BOOL mHasDecodedData;
+        BOOL mHasValidData;
+};
+
+
+//
+// Base class for an audio channel, i.e. a channel which is capable of playing back a sound.
+// Management of channels is done generically, methods for actually manipulating the channel
+// are derived for each audio engine.
+//
+
+
+class LLAudioChannel
+{
+public:
+        LLAudioChannel();
+        virtual ~LLAudioChannel();
+
+        virtual void setSource(LLAudioSource *sourcep);
+        LLAudioSource *getSource() const                        { return mCurrentSourcep; }
+
+        friend class LLAudioEngine;
+        friend class LLAudioSource;
+protected:
+        virtual void play() = 0;
+        virtual void playSynced(LLAudioChannel *channelp) = 0;
+        virtual void cleanup() = 0;
+        virtual BOOL isPlaying() = 0;
+        void setWaiting(const BOOL waiting)                     { mWaiting = waiting; }
+        BOOL isWaiting() const                                          { return mWaiting; }
+
+        virtual BOOL updateBuffer(); // Check to see if the buffer associated with the source changed, and update if necessary.
+        virtual void update3DPosition() = 0;
+        virtual void updateLoop() = 0; // Update your loop/completion status, for use by queueing/syncing.
+protected:
+        LLAudioSource   *mCurrentSourcep;
+        LLAudioBuffer   *mCurrentBufferp;
+        BOOL                    mLoopedThisFrame;
+        BOOL                    mWaiting;       // Waiting for sync.
+};
+
+
+
+
+// Basically an interface class to the engine-specific implementation
+// of audio data that's ready for playback.
+// Will likely get more complex as we decide to do stuff like real streaming audio.
+
+
+class LLAudioBuffer
+{
+public:
+        virtual ~LLAudioBuffer() {};
+        virtual BOOL loadWAV(const char *filename) = 0;
+        virtual U32 getLength() = 0;
+
+        friend class LLAudioEngine;
+        friend class LLAudioChannel;
+        friend class LLAudioData;
+protected:
+        BOOL mInUse;
+        LLAudioData *mAudioDatap;
+        LLFrameTimer mLastUseTimer;
+};
+
+
+
+extern LLAudioEngine* gAudiop;
+
+#endif
diff --git a/linden/indra/llaudio/audioengine_fmod.cpp b/linden/indra/llaudio/audioengine_fmod.cpp
new file mode 100644
index 0000000..a4ddd1f
--- /dev/null
+++ b/linden/indra/llaudio/audioengine_fmod.cpp
@@ -0,0 +1,1176 @@
+/** 
+ * @file audioengine_fmod.cpp
+ * @brief Implementation of LLAudioEngine class abstracting the audio
+ * support as a FMOD 3D implementation
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "audioengine_fmod.h"
+
+#if LL_FMOD
+
+#include "listener_fmod.h"
+
+#include "llerror.h"
+#include "llmath.h"
+#include "llrand.h"
+
+#include "fmod.h"
+#include "fmod_errors.h"
+#include "lldir.h"
+#include "llapr.h"
+
+#include "sound_ids.h"
+
+
+void * F_CALLBACKAPI windCallback(void *originalbuffer, void *newbuffer, int length, void* userdata);
+FSOUND_DSPUNIT *gWindDSP = NULL;
+
+// These globals for the wind filter.  Blech!
+F64 gbuf0 = 0.0;
+F64 gbuf1 = 0.0;
+F64 gbuf2 = 0.0;
+F64 gbuf3 = 0.0;
+F64 gbuf4 = 0.0;
+F64 gbuf5 = 0.0;
+F64 gY0 = 0.0;
+F64 gY1 = 0.0;
+
+F32 gTargetGain = 0.f;
+F32 gCurrentGain = 0.f;
+F32 gTargetFreq = 100.f;
+F32 gCurrentFreq = 100.f;
+F32 gTargetPanGainR = 0.5f;
+F32 gCurrentPanGainR = 0.5f;
+
+
+// Safe strcpy
+#if LL_WINDOWS || LL_LINUX
+static size_t strlcpy( char* dest, const char* src, size_t dst_size )
+{
+        size_t source_len = 0;
+        size_t min_len = 0;
+        if( dst_size > 0 )
+        {
+                if( src )
+                {
+                        source_len = strlen(src);       /*Flawfinder: ignore*/
+                        min_len = llmin( dst_size - 1, source_len );
+                        memcpy(dest, src, min_len);     /*Flawfinder: ignore*/  
+                }
+                dest[min_len] = '\0';
+        }
+        return source_len;
+}
+#else
+// apple ships with the non-standard strlcpy in /usr/include/string.h:
+// size_t strlcpy(char *, const char *, size_t);
+#endif
+
+
+LLAudioEngine_FMOD::LLAudioEngine_FMOD()
+{
+        mInited = FALSE;
+        mCurrentInternetStreamp = NULL;
+        mInternetStreamChannel = -1;
+}
+
+
+LLAudioEngine_FMOD::~LLAudioEngine_FMOD()
+{
+}
+
+
+BOOL LLAudioEngine_FMOD::init(const S32 num_channels, void* userdata)
+{
+        mFadeIn = -10000;
+
+        LLAudioEngine::init(num_channels, userdata);
+
+        // Reserve one extra channel for the http stream.
+        if (!FSOUND_SetMinHardwareChannels(num_channels + 1))
+        {
+                llwarns<< "FMOD::init[0](), error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+        }
+
+        llinfos << "LLAudioEngine_FMOD::init() initializing FMOD" << llendl;
+
+        F32 version = FSOUND_GetVersion();
+        if (version < FMOD_VERSION)
+        {
+                llwarns << "Error : You are using the wrong FMOD version (" << version
+                        << ")!  You should be using FMOD " << FMOD_VERSION << llendl;
+                //return FALSE;
+        }
+
+        U32 fmod_flags = 0x0;
+
+#if LL_WINDOWS
+        // Windows needs to know which window is frontmost.
+        // This must be called before FSOUND_Init() per the FMOD docs.
+        // This could be used to let FMOD handle muting when we lose focus,
+        // but we don't actually want to do that because we want to distinguish
+        // between minimized and not-focused states.
+        if (!FSOUND_SetHWND(userdata))
+        {
+                llwarns << "Error setting FMOD window: "
+                        << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                return FALSE;
+        }
+        // Play audio when we don't have focus.
+        // (For example, IM client on top of us.)
+        // This means we also try to play audio when minimized,
+        // so we manually handle muting in that case. JC
+        fmod_flags |= FSOUND_INIT_GLOBALFOCUS;
+#endif
+
+#if LL_LINUX
+        // initialize the FMOD engine
+
+        // This is a hack to use only FMOD's basic FPU mixer
+        // when the LL_VALGRIND environmental variable is set,
+        // otherwise valgrind will fall over on FMOD's MMX detection
+        if (getenv("LL_VALGRIND"))              /*Flawfinder: ignore*/
+        {
+                llinfos << "Pacifying valgrind in FMOD init." << llendl;
+                FSOUND_SetMixer(FSOUND_MIXER_QUALITY_FPU);
+        }
+
+        // If we don't set an output method, Linux FMOD always
+        // decides on OSS and fails otherwise.  So we'll manually
+        // try ESD, then OSS, then ALSA.
+        // Why this order?  See SL-13250, but in short, OSS emulated
+        // on top of ALSA is ironically more reliable than raw ALSA.
+        // Ack, and ESD has more reliable failure modes - but has worse
+        // latency - than all of them, so wins for now.
+        BOOL audio_ok = FALSE;
+
+        if (!audio_ok)
+                if (NULL == getenv("LL_BAD_ESD")) /*Flawfinder: ignore*/
+                {
+                        llinfos << "Trying ESD audio output..." << llendl;
+                        if(FSOUND_SetOutput(FSOUND_OUTPUT_ESD) &&
+                           FSOUND_Init(44100, num_channels, fmod_flags))
+                        {
+                                llinfos << "ESD audio output initialized OKAY"
+                                        << llendl;
+                                audio_ok = TRUE;
+                        } else {
+                                llwarns << "ESD audio output FAILED to initialize: "
+                                        << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                        }
+                } else {
+                        llinfos << "ESD audio output SKIPPED" << llendl;
+                }
+
+        if (!audio_ok)
+                if (NULL == getenv("LL_BAD_OSS"))        /*Flawfinder: ignore*/
+                {
+                        llinfos << "Trying OSS audio output..." << llendl;
+                        if(FSOUND_SetOutput(FSOUND_OUTPUT_OSS) &&
+                           FSOUND_Init(44100, num_channels, fmod_flags))
+                        {
+                                llinfos << "OSS audio output initialized OKAY" << llendl;
+                                audio_ok = TRUE;
+                        } else {
+                                llwarns << "OSS audio output FAILED to initialize: "
+                                        << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                        }
+                } else {
+                        llinfos << "OSS audio output SKIPPED" << llendl;
+                }
+
+        if (!audio_ok)
+                if (NULL == getenv("LL_BAD_ALSA"))              /*Flawfinder: ignore*/
+                {
+                        llinfos << "Trying ALSA audio output..." << llendl;
+                        if(FSOUND_SetOutput(FSOUND_OUTPUT_ALSA) &&
+                           FSOUND_Init(44100, num_channels, fmod_flags))
+                        {
+                                llinfos << "ALSA audio output initialized OKAY" << llendl;
+                                audio_ok = TRUE;
+                        } else {
+                                llwarns << "ALSA audio output FAILED to initialize: "
+                                        << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                        }
+                } else {
+                        llinfos << "OSS audio output SKIPPED" << llendl;
+                }
+
+        if (!audio_ok)
+        {
+                llwarns << "Overall audio init failure." << llendl;
+                return FALSE;
+        }
+
+        // On Linux, FMOD causes a SIGPIPE for some netstream error
+        // conditions (an FMOD bug); ignore SIGPIPE so it doesn't crash us.
+        // NOW FIXED in FMOD 3.x since 2006-10-01.
+        //signal(SIGPIPE, SIG_IGN);
+
+        // We're interested in logging which output method we
+        // ended up with, for QA purposes.
+        switch (FSOUND_GetOutput())
+        {
+        case FSOUND_OUTPUT_NOSOUND: llinfos << "Audio output: NoSound" << llendl; break;
+        case FSOUND_OUTPUT_OSS: llinfos << "Audio output: OSS" << llendl; break;
+        case FSOUND_OUTPUT_ESD: llinfos << "Audio output: ESD" << llendl; break;
+        case FSOUND_OUTPUT_ALSA: llinfos << "Audio output: ALSA" << llendl; break;
+        default: llinfos << "Audio output: Unknown!" << llendl; break;
+        };
+
+#else // LL_LINUX
+
+        // initialize the FMOD engine
+        if (!FSOUND_Init(44100, num_channels, fmod_flags))
+        {
+                llwarns << "Error initializing FMOD: "
+                        << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                return FALSE;
+        }
+        
+#endif
+
+        initInternetStream();
+
+        llinfos << "LLAudioEngine_FMOD::init() FMOD initialized correctly" << llendl;
+
+        mInited = TRUE;
+
+        return TRUE;
+}
+
+
+void LLAudioEngine_FMOD::idle(F32 max_decode_time)
+{
+        LLAudioEngine::idle(max_decode_time);
+
+        updateInternetStream();
+}
+
+
+void LLAudioEngine_FMOD::allocateListener(void)
+{       
+        mListenerp = (LLListener *) new LLListener_FMOD();
+        if (!mListenerp)
+        {
+                llwarns << "Listener creation failed" << llendl;
+        }
+}
+
+
+void LLAudioEngine_FMOD::shutdown()
+{
+        if (gWindDSP)
+        {
+                FSOUND_DSP_SetActive(gWindDSP,FALSE);
+                FSOUND_DSP_Free(gWindDSP);
+        }
+
+        stopInternetStream();
+
+        LLAudioEngine::shutdown();
+        
+        llinfos << "LLAudioEngine_FMOD::shutdown() closing FMOD" << llendl;
+        FSOUND_Close();
+        llinfos << "LLAudioEngine_FMOD::shutdown() done closing FMOD" << llendl;
+
+        delete mListenerp;
+        mListenerp = NULL;
+}
+
+
+LLAudioBuffer *LLAudioEngine_FMOD::createBuffer()
+{
+        return new LLAudioBufferFMOD();
+}
+
+
+LLAudioChannel *LLAudioEngine_FMOD::createChannel()
+{
+        return new LLAudioChannelFMOD();
+}
+
+
+void LLAudioEngine_FMOD::initWind()
+{
+        if (!gWindDSP)
+        {
+                gWindDSP = FSOUND_DSP_Create(&windCallback, FSOUND_DSP_DEFAULTPRIORITY_CLEARUNIT + 20, NULL);
+        }
+        if (gWindDSP)
+        {
+                FSOUND_DSP_SetActive(gWindDSP, TRUE);
+        }
+        mNextWindUpdate = 0.0;
+}
+
+
+void LLAudioEngine_FMOD::cleanupWind()
+{
+        if (gWindDSP)
+        {
+                FSOUND_DSP_SetActive(gWindDSP, FALSE);
+                FSOUND_DSP_Free(gWindDSP);
+                gWindDSP = NULL;
+        }
+}
+
+
+//-----------------------------------------------------------------------
+void LLAudioEngine_FMOD::updateWind(LLVector3 wind_vec, F32 camera_height_above_water)
+{
+        LLVector3 wind_pos;
+        F64 pitch;
+        F64 center_freq;
+
+        if (!mEnableWind)
+        {
+                return;
+        }
+        
+        if (mWindUpdateTimer.checkExpirationAndReset(LL_WIND_UPDATE_INTERVAL))
+        {
+                
+                // wind comes in as Linden coordinate (+X = forward, +Y = left, +Z = up)
+                // need to convert this to the conventional orientation DS3D and OpenAL use
+                // where +X = right, +Y = up, +Z = backwards
+
+                wind_vec.setVec(-wind_vec.mV[1], wind_vec.mV[2], -wind_vec.mV[0]);
+
+                // cerr << "Wind update" << endl;
+
+                pitch = 1.0 + mapWindVecToPitch(wind_vec);
+                center_freq = 80.0 * pow(pitch,2.5*(mapWindVecToGain(wind_vec)+1.0));
+                
+                gTargetFreq = (F32)center_freq;
+                gTargetGain = (F32)mapWindVecToGain(wind_vec) * mMaxWindGain;
+                gTargetPanGainR = (F32)mapWindVecToPan(wind_vec);
+        }
+}
+
+/*
+//-----------------------------------------------------------------------
+void LLAudioEngine_FMOD::setSourceMinDistance(U16 source_num, F64 distance)
+{
+        if (!mInited)
+        {
+                return;
+        }
+        if (mBuffer[source_num])
+        {
+                mMinDistance[source_num] = (F32) distance;
+                if (!FSOUND_Sample_SetMinMaxDistance(mBuffer[source_num],mMinDistance[source_num], mMaxDistance[source_num]))
+                {
+                        llwarns << "FMOD::setSourceMinDistance(" << source_num << "), error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                }
+        }
+}
+
+//-----------------------------------------------------------------------
+void LLAudioEngine_FMOD::setSourceMaxDistance(U16 source_num, F64 distance)
+{
+        if (!mInited)
+        {
+                return;
+        }
+        if (mBuffer[source_num])
+        {
+                mMaxDistance[source_num] = (F32) distance;
+                if (!FSOUND_Sample_SetMinMaxDistance(mBuffer[source_num],mMinDistance[source_num], mMaxDistance[source_num]))
+                {
+                        llwarns << "FMOD::setSourceMaxDistance(" << source_num << "), error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                }
+        }
+}
+
+//-----------------------------------------------------------------------
+void LLAudioEngine_FMOD::get3DParams(S32 source_num, S32 *volume, S32 *freq, S32 *inside, S32 *outside, LLVector3 *orient, S32 *out_volume, F32 *min_dist, F32 *max_dist)
+{
+        *volume = 0;
+        *freq = 0;
+        *inside = 0;
+        *outside = 0;
+        *orient = LLVector3::zero;
+        *out_volume = 0;
+        *min_dist = 0.f;
+        *max_dist = 0.f;
+}
+
+*/
+
+
+//-----------------------------------------------------------------------
+void LLAudioEngine_FMOD::setInternalGain(F32 gain)
+{
+        if (!mInited)
+        {
+                return;
+        }
+
+        gain = llclamp( gain, 0.0f, 1.0f );
+        FSOUND_SetSFXMasterVolume( llround( 255.0f * gain ) );
+
+        if ( mInternetStreamChannel != -1 )
+        {
+                F32 clamp_internet_stream_gain = llclamp( mInternetStreamGain, 0.0f, 1.0f );
+                FSOUND_SetVolumeAbsolute( mInternetStreamChannel, llround( 255.0f * clamp_internet_stream_gain ) );
+        }
+}
+
+//
+// LLAudioChannelFMOD implementation
+//
+
+LLAudioChannelFMOD::LLAudioChannelFMOD() : LLAudioChannel(), mChannelID(0), mLastSamplePos(0)
+{
+}
+
+
+LLAudioChannelFMOD::~LLAudioChannelFMOD()
+{
+        cleanup();
+}
+
+
+BOOL LLAudioChannelFMOD::updateBuffer()
+{
+        if (LLAudioChannel::updateBuffer())
+        {
+                // Base class update returned TRUE, which means that we need to actually
+                // set up the channel for a different buffer.
+
+                LLAudioBufferFMOD *bufferp = (LLAudioBufferFMOD *)mCurrentSourcep->getCurrentBuffer();
+
+                // Grab the FMOD sample associated with the buffer
+                FSOUND_SAMPLE *samplep = bufferp->getSample();
+                if (!samplep)
+                {
+                        // This is bad, there should ALWAYS be a sample associated with a legit
+                        // buffer.
+                        llerrs << "No FMOD sample!" << llendl;
+                        return FALSE;
+                }
+
+
+                // Actually play the sound.  Start it off paused so we can do all the necessary
+                // setup.
+                mChannelID = FSOUND_PlaySoundEx(FSOUND_FREE, samplep, FSOUND_DSP_GetSFXUnit(), TRUE);
+
+                //llinfos << "Setting up channel " << std::hex << mChannelID << std::dec << llendl;
+        }
+
+        // If we have a source for the channel, we need to update its gain.
+        if (mCurrentSourcep)
+        {
+                if (!FSOUND_SetVolume(mChannelID, llround(mCurrentSourcep->getGain() * 255.0f)))
+                {
+                        llwarns << "LLAudioChannelFMOD::updateBuffer error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                }
+                
+                if (!FSOUND_SetLoopMode(mChannelID, mCurrentSourcep->isLoop() ? FSOUND_LOOP_NORMAL : FSOUND_LOOP_OFF))
+                {
+                        llwarns << "Channel " << mChannelID << llendl;
+                        llwarns << "Source ID: " << mCurrentSourcep->getID() << " at " << mCurrentSourcep->getPositionGlobal() << llendl;
+                        llwarns << "LLAudioChannelFMOD::updateBuffer error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                }
+        }
+
+        return TRUE;
+}
+
+
+void LLAudioChannelFMOD::update3DPosition()
+{
+        if (!mChannelID)
+        {
+                // We're not actually a live channel (i.e., we're not playing back anything)
+                return;
+        }
+
+        LLAudioBufferFMOD *bufferp = (LLAudioBufferFMOD *)mCurrentBufferp;
+        if (!bufferp)
+        {
+                // We don't have a buffer associated with us (should really have been picked up
+                // by the above if.
+                return;
+        }
+
+        if (mCurrentSourcep->isAmbient())
+        {
+                // Ambient sound, don't need to do any positional updates.
+                bufferp->set3DMode(FALSE);
+        }
+        else
+        {
+                // Localized sound.  Update the position and velocity of the sound.
+                bufferp->set3DMode(TRUE);
+
+                LLVector3 float_pos;
+                float_pos.setVec(mCurrentSourcep->getPositionGlobal());
+                if (!FSOUND_3D_SetAttributes(mChannelID, float_pos.mV, mCurrentSourcep->getVelocity().mV))
+                {
+                        llwarns << "LLAudioChannelFMOD::update3DPosition error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                }
+        }
+}
+
+
+void LLAudioChannelFMOD::updateLoop()
+{
+        if (!mChannelID)
+        {
+                // May want to clear up the loop/sample counters.
+                return;
+        }
+
+        //
+        // Hack:  We keep track of whether we looped or not by seeing when the sign of the last sample
+        // flips.  This is pretty crappy.
+        //
+        U32 cur_pos = FSOUND_GetCurrentPosition(mChannelID);
+        if (cur_pos < (U32)mLastSamplePos)
+        {
+                mLoopedThisFrame = TRUE;
+        }
+        mLastSamplePos = cur_pos;
+}
+
+
+void LLAudioChannelFMOD::cleanup()
+{
+        if (!mChannelID)
+        {
+                //llinfos << "Aborting cleanup with no channelID." << llendl;
+                return;
+        }
+
+        //llinfos << "Cleaning up channel: " << mChannelID << llendl;
+        if (!FSOUND_StopSound(mChannelID))
+        {
+                llwarns << "LLAudioChannelFMOD::cleanup error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+        }
+
+        mCurrentBufferp = NULL;
+        mChannelID = 0;
+}
+
+
+void LLAudioChannelFMOD::play()
+{
+        if (!mChannelID)
+        {
+                llwarns << "Playing without a channelID, aborting" << llendl;
+                return;
+        }
+
+        if (!FSOUND_SetPaused(mChannelID, FALSE))
+        {
+                llwarns << "LLAudioChannelFMOD::play error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+        }
+        getSource()->setPlayedOnce(TRUE);
+}
+
+
+void LLAudioChannelFMOD::playSynced(LLAudioChannel *channelp)
+{
+        LLAudioChannelFMOD *fmod_channelp = (LLAudioChannelFMOD*)channelp;
+        if (!(fmod_channelp->mChannelID && mChannelID))
+        {
+                // Don't have channels allocated to both the master and the slave
+                return;
+        }
+
+        U32 position = FSOUND_GetCurrentPosition(fmod_channelp->mChannelID) % mCurrentBufferp->getLength();
+        // Try to match the position of our sync master
+        if (!FSOUND_SetCurrentPosition(mChannelID, position))
+        {
+                llwarns << "LLAudioChannelFMOD::playSynced unable to set current position" << llendl;
+        }
+
+        // Start us playing
+        play();
+}
+
+
+BOOL LLAudioChannelFMOD::isPlaying()
+{
+        if (!mChannelID)
+        {
+                return FALSE;
+        }
+
+        return FSOUND_IsPlaying(mChannelID) && (!FSOUND_GetPaused(mChannelID));
+}
+
+
+
+//
+// LLAudioBufferFMOD implementation
+//
+
+
+LLAudioBufferFMOD::LLAudioBufferFMOD()
+{
+        mSamplep = NULL;
+}
+
+
+LLAudioBufferFMOD::~LLAudioBufferFMOD()
+{
+        if (mSamplep)
+        {
+                // Clean up the associated FMOD sample if it exists.
+                FSOUND_Sample_Free(mSamplep);
+                mSamplep = NULL;
+        }
+}
+
+
+BOOL LLAudioBufferFMOD::loadWAV(const char *filename)
+{
+        // Try to open a wav file from disk.  This will eventually go away, as we don't
+        // really want to block doing this.
+        if (filename == NULL)
+        {
+                // invalid filename, abort.
+                return FALSE;
+        }
+
+        S32 file_size = 0;
+        apr_file_t* apr_file = ll_apr_file_open(filename, LL_APR_RPB, &file_size);
+        if (!apr_file)
+        {
+                // File not found, abort.
+                return FALSE;
+        }
+        apr_file_close(apr_file);
+
+        if (mSamplep)
+        {
+                // If there's already something loaded in this buffer, clean it up.
+                FSOUND_Sample_Free(mSamplep);
+                mSamplep = NULL;
+        }
+
+        // Load up the wav file into an fmod sample
+#if LL_WINDOWS
+        // MikeS. - Loading the sound file manually and then handing it over to FMOD,
+        //      since FMOD uses posix IO internally,
+        // which doesn't work with unicode file paths.
+        FILE*   sound_file = LLFile::fopen(filename,"rb");
+        if (sound_file)
+        {
+                fseek(sound_file,0,SEEK_END);
+                U32     file_length = ftell(sound_file);        //Find the length of the file by seeking to the end and getting the offset
+                size_t  read_count;
+                fseek(sound_file,0,SEEK_SET);   //Seek back to the beginning
+                char*   buffer = new char[file_length];
+                llassert(buffer);
+                read_count = fread((void*)buffer,file_length,1,sound_file);//Load it..
+                if(ferror(sound_file)==0 && (read_count == 1)){//No read error, and we got 1 chunk of our size...
+                        unsigned int mode_flags = FSOUND_LOOP_NORMAL | FSOUND_LOADMEMORY;
+                                                                        //FSOUND_16BITS | FSOUND_MONO | FSOUND_LOADMEMORY | FSOUND_LOOP_NORMAL;
+                        mSamplep = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, mode_flags , 0, file_length);
+                }
+                delete[] buffer;
+                fclose(sound_file);
+        }
+#else
+        mSamplep = FSOUND_Sample_Load(FSOUND_UNMANAGED, filename, FSOUND_LOOP_NORMAL, 0, 0);
+#endif
+
+        if (!mSamplep)
+        {
+                // We failed to load the file for some reason.
+                llwarns << "Could not load data '" << filename << "': "
+                                << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+
+                //
+                // If we EVER want to load wav files provided by end users, we need
+                // to rethink this!
+                //
+                // file is probably corrupt - remove it.
+                LLFile::remove(filename);
+                return FALSE;
+        }
+
+        // Everything went well, return TRUE
+        return TRUE;
+}
+
+
+U32 LLAudioBufferFMOD::getLength()
+{
+        if (!mSamplep)
+        {
+                return 0;
+        }
+
+        return FSOUND_Sample_GetLength(mSamplep);
+}
+
+
+void LLAudioBufferFMOD::set3DMode(BOOL use3d)
+{
+        U16 current_mode = FSOUND_Sample_GetMode(mSamplep);
+        
+        if (use3d)
+        {
+                if (!FSOUND_Sample_SetMode(mSamplep, (current_mode & (~FSOUND_2D))))
+                {
+                        llwarns << "LLAudioBufferFMOD::set3DMode error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                }
+        }
+        else
+        {
+                if (!FSOUND_Sample_SetMode(mSamplep, current_mode | FSOUND_2D))
+                {
+                        llwarns << "LLAudioBufferFMOD::set3DMode error: " << FMOD_ErrorString(FSOUND_GetError()) << llendl;
+                }
+        }
+}
+
+
+
+//---------------------------------------------------------------------------
+// Internet Streaming
+//---------------------------------------------------------------------------
+void LLAudioEngine_FMOD::initInternetStream()
+{
+        // Number of milliseconds of audio to buffer for the audio card.
+        // Must be larger than the usual Second Life frame stutter time.
+    FSOUND_Stream_SetBufferSize(200);
+
+        // Here's where we set the size of the network buffer and some buffering 
+        // parameters.  In this case we want a network buffer of 16k, we want it 
+        // to prebuffer 40% of that when we first connect, and we want it 
+        // to rebuffer 80% of that whenever we encounter a buffer underrun.
+
+        // Leave the net buffer properties at the default.
+        //FSOUND_Stream_Net_SetBufferProperties(20000, 40, 80);
+        mInternetStreamURL[0] = 0;
+}
+
+
+void LLAudioEngine_FMOD::startInternetStream(const char* url)
+{
+        if (!mInited)
+        {
+                llwarns << "startInternetStream before audio initialized" << llendl;
+                return;
+        }
+
+        // "stop" stream but don't clear url, etc. in calse url == mInternetStreamURL
+        stopInternetStream();
+        if (url)
+        {
+                llinfos << "Starting internet stream: " << url << llendl;
+                mCurrentInternetStreamp = new LLAudioStreamFMOD(url);
+                strlcpy(mInternetStreamURL, url, 1024);
+        }
+        else
+        {
+                llinfos << "Set internet stream to null" << llendl;
+                mInternetStreamURL[0] = 0;
+        }
+}
+
+
+signed char F_CALLBACKAPI LLAudioEngine_FMOD::callbackMetaData(char *name, char *value, void *userdata)
+{
+        /*
+        LLAudioEngine_FMOD* self = (LLAudioEngine_FMOD*)userdata;
+
+    if (!strcmp("ARTIST", name))
+    {
+        strlcpy(self->mInternetStreamArtist, value, 256);
+        self->mInternetStreamNewMetaData = TRUE;
+        return TRUE;
+    }
+
+    if (!strcmp("TITLE", name))
+    {
+        strlcpy(self->mInternetStreamTitle, value, 256);
+        self->mInternetStreamNewMetaData = TRUE;
+        return TRUE;
+    }
+        */
+
+    return TRUE;
+}
+
+
+void LLAudioEngine_FMOD::updateInternetStream()
+{
+        // Kill dead internet streams, if possible
+        std::list<LLAudioStreamFMOD *>::iterator iter;
+        for (iter = mDeadStreams.begin(); iter != mDeadStreams.end();)
+        {
+                LLAudioStreamFMOD *streamp = *iter;
+                if (streamp->stopStream())
+                {
+                        llinfos << "Closed dead stream" << llendl;
+                        delete streamp;
+                        mDeadStreams.erase(iter++);
+                }
+                else
+                {
+                        iter++;
+                }
+        }
+
+        // Don't do anything if there are no streams playing
+        if (!mCurrentInternetStreamp)
+        {
+                return;
+        }
+
+    int open_state = mCurrentInternetStreamp->getOpenState();
+
+        if (!open_state)
+        {
+                // Stream is live
+
+
+                // start the stream if it's ready
+                if (mInternetStreamChannel < 0)
+                {
+                        mInternetStreamChannel = mCurrentInternetStreamp->startStream();
+
+                        if (mInternetStreamChannel != -1)
+                        {
+                                // Reset volume to previously set volume
+                                setInternetStreamGain(mInternetStreamGain);
+                                FSOUND_SetPaused(mInternetStreamChannel, FALSE);
+                                //FSOUND_Stream_Net_SetMetadataCallback(mInternetStream, callbackMetaData, this);
+                        }
+                }
+        }
+                
+        switch(open_state)
+        {
+        default:
+        case 0:
+                // success
+                break;
+        case -1:
+                // stream handle is invalid
+                llwarns << "InternetStream - invalid handle" << llendl;
+                stopInternetStream();
+                return;
+        case -2:
+                // opening
+                //strlcpy(mInternetStreamArtist, "Opening", 256);
+                break;
+        case -3:
+                // failed to open, file not found, perhaps
+                llwarns << "InternetSteam - failed to open" << llendl;
+                stopInternetStream();
+                return;
+        case -4:
+                // connecting
+                //strlcpy(mInternetStreamArtist, "Connecting", 256);
+                break;
+        case -5:
+                // buffering
+                //strlcpy(mInternetStreamArtist, "Buffering", 256);
+                break;
+        }
+
+}
+
+void LLAudioEngine_FMOD::stopInternetStream()
+{
+        if (mInternetStreamChannel != -1)
+        {
+                FSOUND_SetPaused(mInternetStreamChannel, TRUE);
+                FSOUND_SetPriority(mInternetStreamChannel, 0);
+                mInternetStreamChannel = -1;
+        }
+
+        if (mCurrentInternetStreamp)
+        {
+                llinfos << "Stopping internet stream: " << mCurrentInternetStreamp->getURL() << llendl;
+                if (mCurrentInternetStreamp->stopStream())
+                {
+                        delete mCurrentInternetStreamp;
+                }
+                else
+                {
+                        llwarns << "Pushing stream to dead list: " << mCurrentInternetStreamp->getURL() << llendl;
+                        mDeadStreams.push_back(mCurrentInternetStreamp);
+                }
+                mCurrentInternetStreamp = NULL;
+                //mInternetStreamURL[0] = 0;
+        }
+}
+
+void LLAudioEngine_FMOD::pauseInternetStream(int pause)
+{
+        if (pause < 0)
+        {
+                pause = mCurrentInternetStreamp ? 1 : 0;
+        }
+
+        if (pause)
+        {
+                if (mCurrentInternetStreamp)
+                {
+                        stopInternetStream();
+                }
+        }
+        else if (mInternetStreamURL)
+        {
+                startInternetStream(mInternetStreamURL);
+        }
+}
+
+
+// A stream is "playing" if it has been requested to start.  That
+// doesn't necessarily mean audio is coming out of the speakers.
+int LLAudioEngine_FMOD::isInternetStreamPlaying()
+{
+        if (mCurrentInternetStreamp)
+        {
+                return 1; // Active and playing
+        }
+        else if (mInternetStreamURL[0])
+        {
+                return 2; // "Paused"
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+
+void LLAudioEngine_FMOD::getInternetStreamInfo(char* artist_out, char* title_out)
+{
+        //strlcpy(artist_out, mInternetStreamArtist, 256);
+        //strlcpy(title_out, mInternetStreamTitle, 256);
+}
+
+
+void LLAudioEngine_FMOD::setInternetStreamGain(F32 vol)
+{
+        LLAudioEngine::setInternetStreamGain(vol);
+        if (mInternetStreamChannel != -1)
+        {
+                vol = llclamp(vol, 0.f, 1.f);
+                int vol_int = llround(vol * 255.f);
+                FSOUND_SetVolumeAbsolute(mInternetStreamChannel, vol_int);
+        }
+}
+
+
+const char* LLAudioEngine_FMOD::getInternetStreamURL()
+{
+        return mInternetStreamURL;
+}
+
+
+LLAudioStreamFMOD::LLAudioStreamFMOD(const char *url) :
+        mInternetStream(NULL),
+        mReady(FALSE)
+{
+        mInternetStreamURL[0] = 0;
+        strlcpy(mInternetStreamURL, url, 1024);
+        mInternetStream = FSOUND_Stream_Open(url, FSOUND_NORMAL | FSOUND_NONBLOCKING, 0, 0);
+        if (!mInternetStream)
+        {
+                llwarns << "Couldn't open fmod stream, error "
+                        << FMOD_ErrorString(FSOUND_GetError())
+                        << llendl;
+                mReady = FALSE;
+                return;
+        }
+
+        mReady = TRUE;
+}
+
+int LLAudioStreamFMOD::startStream()
+{
+        // We need a live and opened stream before we try and play it.
+        if (!mInternetStream || getOpenState())
+        {
+                llwarns << "No internet stream to start playing!" << llendl;
+                return -1;
+        }
+
+        // Make sure the stream is set to 2D mode.
+        FSOUND_Stream_SetMode(mInternetStream, FSOUND_2D);
+
+        return FSOUND_Stream_PlayEx(FSOUND_FREE, mInternetStream, NULL, TRUE);
+}
+
+BOOL LLAudioStreamFMOD::stopStream()
+{
+        if (mInternetStream)
+        {
+                int read_percent = 0;
+                int status = 0;
+                int bitrate = 0;
+                unsigned int flags = 0x0;
+                FSOUND_Stream_Net_GetStatus(mInternetStream, &status, &read_percent, &bitrate, &flags);
+
+                BOOL close = TRUE;
+                switch (status)
+                {
+                case FSOUND_STREAM_NET_CONNECTING:
+                        close = FALSE;
+                        break;
+                case FSOUND_STREAM_NET_NOTCONNECTED:
+                case FSOUND_STREAM_NET_BUFFERING:
+                case FSOUND_STREAM_NET_READY:
+                case FSOUND_STREAM_NET_ERROR:
+                default:
+                        close = TRUE;
+                }
+
+                if (close)
+                {
+                        FSOUND_Stream_Close(mInternetStream);
+                        mInternetStream = NULL;
+                        return TRUE;
+                }
+                else
+                {
+                        return FALSE;
+                }
+        }
+        else
+        {
+                return TRUE;
+        }
+}
+
+int LLAudioStreamFMOD::getOpenState()
+{
+        int open_state = FSOUND_Stream_GetOpenState(mInternetStream);
+        return open_state;
+}
+
+/* This determines the format of the mixbuffer being passed in. change if you want to support int32 or float32 */
+#if LL_DARWIN
+        #define MIXBUFFERFORMAT S32
+#else
+        #define MIXBUFFERFORMAT S16
+#endif
+
+inline MIXBUFFERFORMAT clipSample(MIXBUFFERFORMAT sample, MIXBUFFERFORMAT min, MIXBUFFERFORMAT max)
+{
+        if (sample > max)
+                sample = max;
+        else if (sample < min)
+                sample = min;
+        
+        return sample;
+}
+
+void * F_CALLBACKAPI windCallback(void *originalbuffer, void *newbuffer, int length, void*)
+{
+// originalbuffer = fsounds original mixbuffer.
+// newbuffer = the buffer passed from the previous DSP unit.
+// length = length in samples at this mix time.
+// param = user parameter passed through in FSOUND_DSP_Create.
+//
+// modify the buffer in some fashion
+
+        U8 *cursamplep = (U8*)newbuffer;
+        U8   wordsize = 2;
+
+#if LL_DARWIN
+        wordsize = sizeof(MIXBUFFERFORMAT);
+#else
+    int         mixertype = FSOUND_GetMixer();
+    if (mixertype == FSOUND_MIXER_BLENDMODE || mixertype == FSOUND_MIXER_QUALITY_FPU)
+    {
+                wordsize = 4;
+    }
+#endif
+
+    double bandwidth = 50;
+    double inputSamplingRate = 44100;
+        double a0,b1,b2;
+ 
+        // calculate resonant filter coeffs
+    b2 = exp(-(F_TWO_PI) * (bandwidth / inputSamplingRate));
+
+        while (length--)
+        {
+                gCurrentFreq = (float)((0.999 * gCurrentFreq) + (0.001 * gTargetFreq));
+                gCurrentGain = (float)((0.999 * gCurrentGain) + (0.001 * gTargetGain));
+                gCurrentPanGainR = (float)((0.999 * gCurrentPanGainR) + (0.001 * gTargetPanGainR));
+                b1 = (-4.0 * b2) / (1.0 + b2) * cos(F_TWO_PI * (gCurrentFreq / inputSamplingRate));
+            a0 = (1.0 - b2) * sqrt(1.0 - (b1 * b1) / (4.0 * b2));
+                double nextSample;
+
+            // start with white noise
+                nextSample = frand(2.0f) - 1.0f;
+                                                                         
+#if 1 // LLAE_WIND_PINK apply pinking filter
+                gbuf0 = 0.997f * gbuf0 + 0.0126502f * nextSample; 
+        gbuf1 = 0.985f * gbuf1 + 0.0139083f * nextSample;
+        gbuf2 = 0.950f * gbuf2 + 0.0205439f * nextSample;
+        gbuf3 = 0.850f * gbuf3 + 0.0387225f * nextSample;
+        gbuf4 = 0.620f * gbuf4 + 0.0465932f * nextSample;
+        gbuf5 = 0.250f * gbuf5 + 0.1093477f * nextSample;
+                          
+        nextSample = gbuf0 + gbuf1 + gbuf2 + gbuf3 + gbuf4 + gbuf5;
+#endif
+                        
+#if 1 //LLAE_WIND_RESONANT // do a resonant filter on the noise
+        nextSample = (double)( a0 * nextSample - b1 * gY0 - b2 * gY1 );
+
+        gY1 = gY0;
+        gY0 = nextSample;
+#endif
+
+            nextSample *= gCurrentGain;
+                
+                MIXBUFFERFORMAT sample;
+
+                sample = llfloor(((F32)nextSample*32768.f*(1.0f - gCurrentPanGainR))+0.5f);
+                *(MIXBUFFERFORMAT*)cursamplep = clipSample((*(MIXBUFFERFORMAT*)cursamplep) + sample, -32768, 32767);
+                cursamplep += wordsize;
+
+                sample = llfloor(((F32)nextSample*32768.f*gCurrentPanGainR)+0.5f);
+                *(MIXBUFFERFORMAT*)cursamplep = clipSample((*(MIXBUFFERFORMAT*)cursamplep) + sample, -32768, 32767);
+                cursamplep += wordsize;
+        }
+
+        return newbuffer;
+}
+
+#endif  // LL_FMOD
+
diff --git a/linden/indra/llaudio/audioengine_fmod.h b/linden/indra/llaudio/audioengine_fmod.h
new file mode 100644
index 0000000..9274b1b
--- /dev/null
+++ b/linden/indra/llaudio/audioengine_fmod.h
@@ -0,0 +1,158 @@
+/** 
+ * @file audioengine_fmod.h
+ * @brief Definition of LLAudioEngine class abstracting the audio
+ * support as a FMOD 3D implementation
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_AUDIOENGINE_FMOD_H
+#define LL_AUDIOENGINE_FMOD_H
+
+#include "audioengine.h"
+
+#if LL_FMOD
+
+#include "listener_fmod.h"
+
+#include "fmod.h"
+
+class LLAudioStreamFMOD;
+
+class LLAudioEngine_FMOD : public LLAudioEngine 
+{
+public:
+        LLAudioEngine_FMOD();
+        virtual ~LLAudioEngine_FMOD();
+
+        // initialization/startup/shutdown
+        virtual BOOL init(const S32 num_channels, void *user_data);
+        virtual void allocateListener();
+
+        virtual void shutdown();
+
+        virtual void idle(F32 max_decode_time = 0.f);
+
+        // Internet stream methods
+        virtual void initInternetStream();
+        virtual void startInternetStream(const char* url);
+        virtual void updateInternetStream();
+        virtual void stopInternetStream();
+        virtual void pauseInternetStream(int pause);
+        virtual int isInternetStreamPlaying();
+        virtual void getInternetStreamInfo(char* artist, char* title);
+        virtual void setInternetStreamGain(F32 vol);
+        virtual const char* getInternetStreamURL();
+
+        /*virtual*/ void initWind();
+        /*virtual*/ void cleanupWind();
+
+        /*virtual*/void updateWind(LLVector3 direction, F32 camera_height_above_water);
+
+protected:
+        /*virtual*/ LLAudioBuffer *createBuffer(); // Get a free buffer, or flush an existing one if you have to.
+        /*virtual*/ LLAudioChannel *createChannel(); // Create a new audio channel.
+
+        /*virtual*/ void setInternalGain(F32 gain);
+protected:
+        static signed char F_CALLBACKAPI callbackMetaData(char* name, char* value, void* userdata);
+
+        LLAudioStreamFMOD *mCurrentInternetStreamp;
+        char mInternetStreamURL[1024];  /*Flawfinder: ignore*/
+        int mInternetStreamChannel;
+
+        std::list<LLAudioStreamFMOD *> mDeadStreams;
+
+        //F32 mMinDistance[MAX_BUFFERS];
+        //F32 mMaxDistance[MAX_BUFFERS];
+
+        S32 mFadeIn;
+        BOOL mInited;
+
+        // On Windows, userdata is the HWND of the application window.
+        void* mUserData;
+
+};
+
+
+class LLAudioChannelFMOD : public LLAudioChannel
+{
+public:
+        LLAudioChannelFMOD();
+        virtual ~LLAudioChannelFMOD();
+
+protected:
+        /*virtual*/ void play();
+        /*virtual*/ void playSynced(LLAudioChannel *channelp);
+        /*virtual*/ void cleanup();
+        /*virtual*/ BOOL isPlaying();
+
+        /*virtual*/ BOOL updateBuffer();
+        /*virtual*/ void update3DPosition();
+        /*virtual*/ void updateLoop();
+
+protected:
+        int mChannelID;
+        S32 mLastSamplePos;
+};
+
+
+class LLAudioBufferFMOD : public LLAudioBuffer
+{
+public:
+        LLAudioBufferFMOD();
+        virtual ~LLAudioBufferFMOD();
+
+        /*virtual*/ BOOL loadWAV(const char *filename);
+        /*virtual*/ U32 getLength();
+        friend class LLAudioChannelFMOD;
+
+        void set3DMode(BOOL use3d);
+protected:
+        FSOUND_SAMPLE *getSample()      { return mSamplep; }
+protected:
+        FSOUND_SAMPLE *mSamplep;
+};
+
+class LLAudioStreamFMOD
+{
+public:
+        LLAudioStreamFMOD(const char *url);
+        int     startStream();
+        BOOL stopStream(); // Returns true if the stream was successfully stopped.
+        BOOL ready();
+
+        char *getURL()  { return mInternetStreamURL; }
+
+        int getOpenState();
+protected:
+        FSOUND_STREAM* mInternetStream;
+        BOOL mReady;
+
+        char mInternetStreamURL[1024];  /*Flawfinder: ignore*/
+};
+
+#endif
+
+#endif
+
diff --git a/linden/indra/llaudio/files.lst b/linden/indra/llaudio/files.lst
new file mode 100644
index 0000000..abc8710
--- /dev/null
+++ b/linden/indra/llaudio/files.lst
@@ -0,0 +1,7 @@
+llaudio/audioengine.cpp
+llaudio/audioengine_fmod.cpp
+llaudio/listener.cpp
+llaudio/listener_fmod.cpp
+llaudio/llaudiodecodemgr.cpp
+llaudio/vorbisdecode.cpp
+llaudio/vorbisencode.cpp
diff --git a/linden/indra/llaudio/listener.cpp b/linden/indra/llaudio/listener.cpp
new file mode 100644
index 0000000..cff8e79
--- /dev/null
+++ b/linden/indra/llaudio/listener.cpp
@@ -0,0 +1,153 @@
+/** 
+ * @file listener.cpp
+ * @brief Implementation of LISTENER class abstracting the audio support
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+
+#include "listener.h"
+
+#define DEFAULT_AT  0.0f,0.0f,-1.0f
+#define DEFAULT_UP  0.0f,1.0f,0.0f
+
+//-----------------------------------------------------------------------
+// constructor
+//-----------------------------------------------------------------------
+LLListener::LLListener()
+{
+        init();
+}
+
+//-----------------------------------------------------------------------
+LLListener::~LLListener()
+{
+}
+
+//-----------------------------------------------------------------------
+void LLListener::init(void)
+{
+        mPosition.zeroVec();
+        mListenAt.setVec(DEFAULT_AT);
+        mListenUp.setVec(DEFAULT_UP);
+        mVelocity.zeroVec();
+}
+
+//-----------------------------------------------------------------------
+void LLListener::free(void)
+{
+}
+
+//-----------------------------------------------------------------------
+void LLListener::translate(LLVector3 offset)
+{
+        mPosition += offset;
+}
+
+//-----------------------------------------------------------------------
+void LLListener::setPosition(LLVector3 pos)
+{
+        mPosition = pos;
+}
+
+//-----------------------------------------------------------------------
+LLVector3 LLListener::getPosition(void)
+{
+        return(mPosition);
+}
+
+//-----------------------------------------------------------------------
+LLVector3 LLListener::getAt(void)
+{
+        return(mListenAt);
+}
+
+//-----------------------------------------------------------------------
+LLVector3 LLListener::getUp(void)
+{
+        return(mListenUp);
+}
+
+//-----------------------------------------------------------------------
+void LLListener::setVelocity(LLVector3 vel)
+{
+        mVelocity = vel;
+}
+
+//-----------------------------------------------------------------------
+void LLListener::orient(LLVector3 up, LLVector3 at)
+{
+        mListenUp = up;
+        mListenAt = at;
+}
+
+//-----------------------------------------------------------------------
+void LLListener::set(LLVector3 pos, LLVector3 vel, LLVector3 up, LLVector3 at)
+{
+        mPosition = pos;
+        mVelocity = vel;
+
+        setPosition(pos);
+        setVelocity(vel);
+        orient(up,at);
+}
+
+//-----------------------------------------------------------------------
+void LLListener::setDopplerFactor(F32 factor)
+{
+}
+
+//-----------------------------------------------------------------------
+F32 LLListener::getDopplerFactor()
+{
+        return (1.f);
+}
+
+//-----------------------------------------------------------------------
+void LLListener::setDistanceFactor(F32 factor)
+{
+}
+
+//-----------------------------------------------------------------------
+F32 LLListener::getDistanceFactor()
+{
+        return (1.f);
+}
+
+//-----------------------------------------------------------------------
+void LLListener::setRolloffFactor(F32 factor)
+{
+}
+
+//-----------------------------------------------------------------------
+F32 LLListener::getRolloffFactor()
+{
+        return (1.f);
+}
+
+//-----------------------------------------------------------------------
+void LLListener::commitDeferredChanges()
+{
+}
+
diff --git a/linden/indra/llaudio/listener.h b/linden/indra/llaudio/listener.h
new file mode 100644
index 0000000..bdc3ba2
--- /dev/null
+++ b/linden/indra/llaudio/listener.h
@@ -0,0 +1,78 @@
+/** 
+ * @file listener.h
+ * @brief Description of LISTENER base class abstracting the audio support.
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_LISTENER_H
+#define LL_LISTENER_H
+
+#include <string.h>
+
+#include "v3math.h"
+
+class LLListener 
+{
+ private:
+ protected:
+        LLVector3 mPosition;
+        LLVector3 mVelocity;
+        LLVector3 mListenAt;
+        LLVector3 mListenUp;
+
+ public:
+
+ private:
+ protected:
+ public:  
+        LLListener();
+        virtual ~LLListener();
+        virtual void init();  
+        virtual void free();
+
+        virtual void set(LLVector3 pos, LLVector3 vel, LLVector3 up, LLVector3 at);
+
+        virtual void setPosition(LLVector3 pos);
+        virtual void setVelocity(LLVector3 vel);
+
+        virtual void orient(LLVector3 up, LLVector3 at);
+        virtual void translate(LLVector3 offset);
+
+        virtual void setDopplerFactor(F32 factor);
+        virtual void setDistanceFactor(F32 factor);
+        virtual void setRolloffFactor(F32 factor);
+
+        virtual LLVector3 getPosition();
+        virtual LLVector3 getAt();
+        virtual LLVector3 getUp();
+
+        virtual F32 getDopplerFactor();
+        virtual F32 getDistanceFactor();
+        virtual F32 getRolloffFactor();
+
+        virtual void commitDeferredChanges();
+};
+
+#endif
+
diff --git a/linden/indra/llaudio/listener_ds3d.h b/linden/indra/llaudio/listener_ds3d.h
new file mode 100644
index 0000000..e62040c
--- /dev/null
+++ b/linden/indra/llaudio/listener_ds3d.h
@@ -0,0 +1,71 @@
+/** 
+ * @file listener_ds3d.h
+ * @brief Description of LISTENER class abstracting the audio support
+ * as a DirectSound 3D implementation (windows only)
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_LISTENER_DS3D_H
+#define LL_LISTENER_DS3D_H
+
+#include "listener.h"
+
+#include <dmusici.h>
+#include <dsound.h>
+#include <ks.h>
+
+class LLListener_DS3D : public LLListener
+{
+ private:
+ protected:
+        IDirectSound3DListener8 *m3DListener;
+ public:
+
+ private:
+ protected:
+ public:  
+        LLListener_DS3D();
+        virtual ~LLListener_DS3D();
+        virtual void init();  
+
+        virtual void setDS3DLPtr (IDirectSound3DListener8 *listener_p);
+
+        virtual void translate(LLVector3 offset);
+        virtual void setPosition(LLVector3 pos);
+        virtual void setVelocity(LLVector3 vel);
+        virtual void orient(LLVector3 up, LLVector3 at);
+
+        virtual void setDopplerFactor(F32 factor);
+        virtual F32 getDopplerFactor();
+        virtual void setDistanceFactor(F32 factor);
+        virtual F32 getDistanceFactor();
+        virtual void setRolloffFactor(F32 factor);
+        virtual F32 getRolloffFactor();
+
+        virtual void commitDeferredChanges();
+};
+
+#endif
+
+
diff --git a/linden/indra/llaudio/listener_fmod.cpp b/linden/indra/llaudio/listener_fmod.cpp
new file mode 100644
index 0000000..d4f57c0
--- /dev/null
+++ b/linden/indra/llaudio/listener_fmod.cpp
@@ -0,0 +1,145 @@
+/** 
+ * @file listener_fmod.cpp
+ * @brief implementation of LISTENER class abstracting the audio
+ * support as a FMOD 3D implementation (windows only)
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+#include "audioengine.h"
+
+#if LL_FMOD
+
+#include "listener_fmod.h"
+#include "fmod.h"
+
+//-----------------------------------------------------------------------
+// constructor
+//-----------------------------------------------------------------------
+LLListener_FMOD::LLListener_FMOD()
+{
+        init();
+}
+
+//-----------------------------------------------------------------------
+LLListener_FMOD::~LLListener_FMOD()
+{
+}
+
+//-----------------------------------------------------------------------
+void LLListener_FMOD::init(void)
+{
+        // do inherited
+        LLListener::init();
+        mDopplerFactor = 1.0f;
+        mDistanceFactor = 1.0f;
+        mRolloffFactor = 1.0f;
+}
+
+//-----------------------------------------------------------------------
+void LLListener_FMOD::translate(LLVector3 offset)
+{
+        LLListener::translate(offset);
+
+        FSOUND_3D_Listener_SetAttributes(mPosition.mV, NULL, mListenAt.mV[0],mListenAt.mV[1],mListenAt.mV[2], mListenUp.mV[0],mListenUp.mV[1],mListenUp.mV[2]);
+}
+
+//-----------------------------------------------------------------------
+void LLListener_FMOD::setPosition(LLVector3 pos)
+{
+        LLListener::setPosition(pos);
+
+        FSOUND_3D_Listener_SetAttributes(pos.mV, NULL, mListenAt.mV[0],mListenAt.mV[1],mListenAt.mV[2], mListenUp.mV[0],mListenUp.mV[1],mListenUp.mV[2]);
+}
+
+//-----------------------------------------------------------------------
+void LLListener_FMOD::setVelocity(LLVector3 vel)
+{
+        LLListener::setVelocity(vel);
+
+        FSOUND_3D_Listener_SetAttributes(NULL, vel.mV, mListenAt.mV[0],mListenAt.mV[1],mListenAt.mV[2], mListenUp.mV[0],mListenUp.mV[1],mListenUp.mV[2]);
+}
+
+//-----------------------------------------------------------------------
+void LLListener_FMOD::orient(LLVector3 up, LLVector3 at)
+{
+        LLListener::orient(up, at);
+
+        // Welcome to the transition between right and left
+        // (coordinate systems, that is)
+        // Leaving the at vector alone results in a L/R reversal
+        // since DX is left-handed and we (LL, OpenGL, OpenAL) are right-handed
+        at = -at;
+
+        FSOUND_3D_Listener_SetAttributes(NULL, NULL, at.mV[0],at.mV[1],at.mV[2], up.mV[0],up.mV[1],up.mV[2]);
+}
+
+//-----------------------------------------------------------------------
+void LLListener_FMOD::commitDeferredChanges()
+{
+        FSOUND_Update();
+}
+
+
+void LLListener_FMOD::setRolloffFactor(F32 factor)
+{
+        mRolloffFactor = factor;
+        FSOUND_3D_SetRolloffFactor(factor);
+}
+
+
+F32 LLListener_FMOD::getRolloffFactor()
+{
+        return mRolloffFactor;
+}
+
+
+void LLListener_FMOD::setDopplerFactor(F32 factor)
+{
+        mDopplerFactor = factor;
+        FSOUND_3D_SetDopplerFactor(factor);
+}
+
+
+F32 LLListener_FMOD::getDopplerFactor()
+{
+        return mDopplerFactor;
+}
+
+
+void LLListener_FMOD::setDistanceFactor(F32 factor)
+{
+        mDistanceFactor = factor;
+        FSOUND_3D_SetDistanceFactor(factor);
+}
+
+
+F32 LLListener_FMOD::getDistanceFactor()
+{
+        return mDistanceFactor;
+}
+
+#endif  // LL_FMOD
+
+
diff --git a/linden/indra/llaudio/listener_fmod.h b/linden/indra/llaudio/listener_fmod.h
new file mode 100644
index 0000000..521cc16
--- /dev/null
+++ b/linden/indra/llaudio/listener_fmod.h
@@ -0,0 +1,66 @@
+/** 
+ * @file listener_fmod.h
+ * @brief Description of LISTENER class abstracting the audio support
+ * as an FMOD 3D implementation (windows and Linux)
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_LISTENER_FMOD_H
+#define LL_LISTENER_FMOD_H
+
+#include "listener.h"
+
+class LLListener_FMOD : public LLListener
+{
+ private:
+ protected:
+         F32 mDopplerFactor;
+         F32 mDistanceFactor;
+         F32 mRolloffFactor;
+ public:
+
+ private:
+ protected:
+ public:  
+        LLListener_FMOD();
+        virtual ~LLListener_FMOD();
+        virtual void init();  
+
+        virtual void translate(LLVector3 offset);
+        virtual void setPosition(LLVector3 pos);
+        virtual void setVelocity(LLVector3 vel);
+        virtual void orient(LLVector3 up, LLVector3 at);
+        virtual void commitDeferredChanges();
+
+        virtual void setDopplerFactor(F32 factor);
+        virtual F32 getDopplerFactor();
+        virtual void setDistanceFactor(F32 factor);
+        virtual F32 getDistanceFactor();
+        virtual void setRolloffFactor(F32 factor);
+        virtual F32 getRolloffFactor();
+};
+
+#endif
+
+
diff --git a/linden/indra/llaudio/listener_openal.h b/linden/indra/llaudio/listener_openal.h
new file mode 100644
index 0000000..e87c504
--- /dev/null
+++ b/linden/indra/llaudio/listener_openal.h
@@ -0,0 +1,56 @@
+/** 
+ * @file listener_openal.h
+ * @brief Description of LISTENER class abstracting the audio support
+ * as an OpenAL implementation
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_LISTENER_OPENAL_H
+#define LL_LISTENER_OPENAL_H
+
+#include "listener.h"
+
+#include "AL/al.h"
+#include "AL/alut.h"
+
+class LLListener_OpenAL  : public LLListener
+{
+ private:
+ protected:
+ public:
+
+ private:
+ protected:
+ public:  
+        LLListener_OpenAL();
+        virtual ~LLListener_OpenAL();
+
+        virtual void translate(LLVector3 offset);
+        virtual void setPosition(LLVector3 pos);
+        virtual void setVelocity(LLVector3 vel);
+        virtual void orient(LLVector3 up, LLVector3 at);
+};
+
+#endif
+
diff --git a/linden/indra/llaudio/llaudio.vcproj b/linden/indra/llaudio/llaudio.vcproj
new file mode 100644
index 0000000..7073b88
--- /dev/null
+++ b/linden/indra/llaudio/llaudio.vcproj
@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+        ProjectType="Visual C++"
+        Version="7.10"
+        Name="llaudio"
+        ProjectGUID="{93B2BA29-FBE9-4376-92C1-6108DCFE09D3}"
+        RootNamespace="llaudio"
+        Keyword="Win32Proj">
+        <Platforms>
+                <Platform
+                        Name="Win32"/>
+        </Platforms>
+        <Configurations>
+                <Configuration
+                        Name="Debug|Win32"
+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
+                        IntermediateDirectory="Debug"
+                        ConfigurationType="4"
+                        CharacterSet="1">
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="0"
+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\..\libraries\i686-win32\include;..\..\libraries\include\;"
+                                PreprocessorDefinitions="WIN32;_DEBUG;_LIB;LL_WINDOWS;LL_DEBUG"
+                                MinimalRebuild="TRUE"
+                                BasicRuntimeChecks="3"
+                                RuntimeLibrary="1"
+                                StructMemberAlignment="4"
+                                ForceConformanceInForLoopScope="TRUE"
+                                UsePrecompiledHeader="0"
+                                WarningLevel="3"
+                                WarnAsError="TRUE"
+                                Detect64BitPortabilityProblems="FALSE"
+                                DebugInformationFormat="4"/>
+                        <Tool
+                                Name="VCCustomBuildTool"/>
+                        <Tool
+                                Name="VCLibrarianTool"
+                                OutputFile="$(OutDir)/llaudio.lib"/>
+                        <Tool
+                                Name="VCMIDLTool"/>
+                        <Tool
+                                Name="VCPostBuildEventTool"/>
+                        <Tool
+                                Name="VCPreBuildEventTool"/>
+                        <Tool
+                                Name="VCPreLinkEventTool"/>
+                        <Tool
+                                Name="VCResourceCompilerTool"/>
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"/>
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"/>
+                        <Tool
+                                Name="VCManagedWrapperGeneratorTool"/>
+                        <Tool
+                                Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+                </Configuration>
+                <Configuration
+                        Name="Release|Win32"
+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
+                        IntermediateDirectory="Release"
+                        ConfigurationType="4"
+                        CharacterSet="1">
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\..\libraries\i686-win32\include;..\..\libraries\include\"
+                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;LL_RELEASE"
+                                RuntimeLibrary="0"
+                                StructMemberAlignment="0"
+                                ForceConformanceInForLoopScope="TRUE"
+                                UsePrecompiledHeader="0"
+                                WarningLevel="3"
+                                WarnAsError="TRUE"
+                                Detect64BitPortabilityProblems="FALSE"
+                                DebugInformationFormat="3"/>
+                        <Tool
+                                Name="VCCustomBuildTool"/>
+                        <Tool
+                                Name="VCLibrarianTool"
+                                OutputFile="$(OutDir)/llaudio.lib"/>
+                        <Tool
+                                Name="VCMIDLTool"/>
+                        <Tool
+                                Name="VCPostBuildEventTool"/>
+                        <Tool
+                                Name="VCPreBuildEventTool"/>
+                        <Tool
+                                Name="VCPreLinkEventTool"/>
+                        <Tool
+                                Name="VCResourceCompilerTool"/>
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"/>
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"/>
+                        <Tool
+                                Name="VCManagedWrapperGeneratorTool"/>
+                        <Tool
+                                Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+                </Configuration>
+                <Configuration
+                        Name="ReleaseNoOpt|Win32"
+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
+                        IntermediateDirectory="$(ConfigurationName)"
+                        ConfigurationType="4"
+                        CharacterSet="1">
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="0"
+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\..\libraries\i686-win32\include;..\..\libraries\include\"
+                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;LL_RELEASE"
+                                RuntimeLibrary="0"
+                                StructMemberAlignment="0"
+                                ForceConformanceInForLoopScope="TRUE"
+                                UsePrecompiledHeader="0"
+                                WarningLevel="3"
+                                WarnAsError="TRUE"
+                                Detect64BitPortabilityProblems="FALSE"
+                                DebugInformationFormat="3"/>
+                        <Tool
+                                Name="VCCustomBuildTool"/>
+                        <Tool
+                                Name="VCLibrarianTool"
+                                OutputFile="$(OutDir)/llaudio.lib"/>
+                        <Tool
+                                Name="VCMIDLTool"/>
+                        <Tool
+                                Name="VCPostBuildEventTool"/>
+                        <Tool
+                                Name="VCPreBuildEventTool"/>
+                        <Tool
+                                Name="VCPreLinkEventTool"/>
+                        <Tool
+                                Name="VCResourceCompilerTool"/>
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"/>
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"/>
+                        <Tool
+                                Name="VCManagedWrapperGeneratorTool"/>
+                        <Tool
+                                Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+                </Configuration>
+        </Configurations>
+        <References>
+        </References>
+        <Files>
+                <Filter
+                        Name="Source Files"
+                        Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+                        UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+                        <File
+                                RelativePath=".\audioengine.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\audioengine_fmod.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\listener.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\listener_fmod.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llaudiodecodemgr.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\vorbisdecode.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\vorbisencode.cpp">
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Header Files"
+                        Filter="h;hpp;hxx;hm;inl;inc;xsd"
+                        UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+                        <File
+                                RelativePath=".\audioengine.h">
+                        </File>
+                        <File
+                                RelativePath=".\audioengine_fmod.h">
+                        </File>
+                        <File
+                                RelativePath=".\fmod.h">
+                        </File>
+                        <File
+                                RelativePath=".\fmod_errors.h">
+                        </File>
+                        <File
+                                RelativePath=".\listener.h">
+                        </File>
+                        <File
+                                RelativePath=".\listener_ds3d.h">
+                        </File>
+                        <File
+                                RelativePath=".\listener_fmod.h">
+                        </File>
+                        <File
+                                RelativePath=".\listener_openal.h">
+                        </File>
+                        <File
+                                RelativePath=".\llaudiodecodemgr.h">
+                        </File>
+                        <File
+                                RelativePath=".\vorbisdecode.h">
+                        </File>
+                        <File
+                                RelativePath=".\vorbisencode.h">
+                        </File>
+                        <File
+                                RelativePath=".\wavefile.h">
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Resource Files"
+                        Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+                        UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
+                </Filter>
+        </Files>
+        <Globals>
+        </Globals>
+</VisualStudioProject>
diff --git a/linden/indra/llaudio/llaudiodecodemgr.cpp b/linden/indra/llaudio/llaudiodecodemgr.cpp
new file mode 100644
index 0000000..d98ff5d
--- /dev/null
+++ b/linden/indra/llaudio/llaudiodecodemgr.cpp
@@ -0,0 +1,635 @@
+/** 
+ * @file llaudiodecodemgr.cpp
+ *
+ * Copyright (c) 2003-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+
+#include <vector>
+#include <iterator>
+#include <algorithm>
+#include <stdio.h>
+
+#include "llaudiodecodemgr.h"
+
+#include "vorbisdecode.h"
+#include "audioengine.h"
+#include "lllfsthread.h"
+#include "llvfile.h"
+#include "llstring.h"
+#include "lldir.h"
+#include "llendianswizzle.h"
+#include "audioengine.h"
+#include "llassetstorage.h"
+
+#include "vorbis/codec.h"
+#include "vorbis/vorbisfile.h"
+
+extern LLAudioEngine *gAudiop;
+
+LLAudioDecodeMgr *gAudioDecodeMgrp = NULL;
+
+static const S32 WAV_HEADER_SIZE = 44;
+
+class LLVorbisDecodeState
+{
+public:
+        LLVorbisDecodeState(const LLUUID &uuid, const LLString &out_filename);
+        virtual ~LLVorbisDecodeState();
+
+        BOOL initDecode();
+        BOOL decodeSection(); // Return TRUE if done.
+        BOOL finishDecode();
+
+        void flushBadFile();
+
+        BOOL isValid() const                            { return mValid; }
+        BOOL isDone() const                                     { return mDone; }
+        const LLUUID &getUUID() const           { return mUUID; }
+protected:
+        BOOL mValid;
+        BOOL mDone;
+        LLUUID mUUID;
+
+        std::vector<U8> mWAVBuffer;
+#if !defined(USE_WAV_VFILE)
+        LLString mOutFilename;
+        LLLFSThread::handle_t mFileHandle;
+#endif
+        
+        LLVFile *mInFilep;
+        OggVorbis_File mVF;
+        S32 mCurrentSection;
+};
+
+void LLVorbisDecodeState::flushBadFile()
+{
+        if (mInFilep)
+        {
+                llwarns << "Flushing bad vorbis file from VFS for " << mUUID << llendl;
+                mInFilep->remove();
+        }
+}
+
+
+LLAudioDecodeMgr::LLAudioDecodeMgr()
+{
+        mCurrentDecodep = NULL;
+}
+
+LLAudioDecodeMgr::~LLAudioDecodeMgr()
+{
+        delete mCurrentDecodep;
+        mCurrentDecodep = NULL;
+}
+
+
+void LLAudioDecodeMgr::processQueue(const F32 num_secs)
+{
+        LLUUID uuid;
+
+        LLTimer decode_timer;
+
+        BOOL done = FALSE;
+        while (!done)
+        {
+                if (mCurrentDecodep)
+                {
+                        BOOL res;
+
+                        // Decode in a loop until we're done or have run out of time.
+                        while(!(res = mCurrentDecodep->decodeSection()) && (decode_timer.getElapsedTimeF32() < num_secs))
+                        {
+                                // decodeSection does all of the work above
+                        }
+
+                        if (mCurrentDecodep->isDone() && !mCurrentDecodep->isValid())
+                        {
+                                // We had an error when decoding, abort.
+                                llwarns << mCurrentDecodep->getUUID() << " has invalid vorbis data, aborting decode" << llendl;
+                                mCurrentDecodep->flushBadFile();
+                                LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
+                                adp->setHasValidData(FALSE);
+                                delete mCurrentDecodep;
+                                mCurrentDecodep = NULL;
+                                done = TRUE;
+                        }
+
+                        if (!res)
+                        {
+                                // We've used up out time slice, bail...
+                                done = TRUE;
+                        }
+                        else if (mCurrentDecodep)
+                        {
+                                if (mCurrentDecodep->finishDecode())
+                                {
+                                        // We finished!
+                                        if (mCurrentDecodep->isValid() && mCurrentDecodep->isDone())
+                                        {
+                                                LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
+                                                adp->setHasDecodedData(TRUE);
+                                                adp->setHasValidData(TRUE);
+
+                                                // At this point, we could see if anyone needs this sound immediately, but
+                                                // I'm not sure that there's a reason to - we need to poll all of the playing
+                                                // sounds anyway.
+                                                //llinfos << "Finished the vorbis decode, now what?" << llendl;
+                                        }
+                                        else
+                                        {
+                                                llinfos << "Vorbis decode failed!!!" << llendl;
+                                        }
+                                        delete mCurrentDecodep;
+                                        mCurrentDecodep = NULL;
+                                }
+                                done = TRUE; // done for now
+                        }
+                }
+
+                if (!done)
+                {
+                        if (!mDecodeQueue.getLength())
+                        {
+                                // Nothing else on the queue.
+                                done = TRUE;
+                        }
+                        else
+                        {
+                                LLUUID uuid;
+                                mDecodeQueue.pop(uuid);
+                                if (gAudiop->hasDecodedFile(uuid))
+                                {
+                                        // This file has already been decoded, don't decode it again.
+                                        continue;
+                                }
+
+                                lldebugs << "Decoding " << uuid << " from audio queue!" << llendl;
+
+                                char uuid_str[64];                      /*Flawfinder: ignore*/
+                                char d_path[LL_MAX_PATH];       /*Flawfinder: ignore*/
+
+                                LLTimer timer;
+                                timer.reset();
+
+                                uuid.toString(uuid_str);
+                                snprintf(d_path, LL_MAX_PATH, "%s.dsf", gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str).c_str()); /*Flawfinder: ignore*/
+
+                                mCurrentDecodep = new LLVorbisDecodeState(uuid, d_path);
+                                if (!mCurrentDecodep->initDecode())
+                                {
+                                        delete mCurrentDecodep;
+                                        mCurrentDecodep = NULL;
+                                }
+                        }
+                }
+        }
+}
+
+
+BOOL LLAudioDecodeMgr::addDecodeRequest(const LLUUID &uuid)
+{
+        if (gAudiop->hasDecodedFile(uuid))
+        {
+                // Already have a decoded version, don't need to decode it.
+                return TRUE;
+        }
+
+        if (gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
+        {
+                // Just put it on the decode queue.
+                gAudioDecodeMgrp->mDecodeQueue.push(uuid);
+                return TRUE;
+        }
+
+        return FALSE;
+}
+
+
+S32 LLAudioDecodeMgr::getRequestCount()
+{
+        /*
+        S32 count = 0;
+        if (mCurrentTransfer.notNull())
+        {
+                count++;
+        }
+
+        count += mRequestQueue.getLength();
+        return count;
+        */
+        return 0;
+}
+
+
+
+
+
+
+
+
+size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        if (file->read((U8*)ptr, (S32)(size * nmemb)))  /*Flawfinder: ignore*/
+        {
+                S32 read = file->getLastBytesRead();
+                return  read / size;    /*Flawfinder: ignore*/
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+int vfs_seek(void *datasource, ogg_int64_t offset, int whence)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        // vfs has 31-bit files
+        if (offset > S32_MAX)
+        {
+                return -1;
+        }
+
+        S32 origin;
+        switch (whence) {
+        case SEEK_SET:
+                origin = 0;
+                break;
+        case SEEK_END:
+                origin = file->getSize();
+                break;
+        case SEEK_CUR:
+                origin = -1;
+                break;
+        default:
+                llerrs << "Invalid whence argument to vfs_seek" << llendl;
+                return -1;
+        }
+
+        if (file->seek((S32)offset, origin))
+        {
+                return 0;
+        }
+        else
+        {
+                return -1;
+        }
+}
+
+int vfs_close (void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        delete file;
+
+        return 0;
+}
+
+long vfs_tell (void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        return file->tell();
+}
+
+
+
+
+LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const LLString &out_filename)
+{
+        mDone = FALSE;
+        mValid = FALSE;
+        mUUID = uuid;
+        mInFilep = NULL;
+        mCurrentSection = 0;
+#if !defined(USE_WAV_VFILE)
+        mOutFilename = out_filename;
+        mFileHandle = LLLFSThread::nullHandle();
+#endif
+        // No default value for mVF, it's an ogg structure?
+}
+
+LLVorbisDecodeState::~LLVorbisDecodeState()
+{
+        if (!mDone)
+        {
+                delete mInFilep;
+                mInFilep = NULL;
+        }
+}
+
+
+BOOL LLVorbisDecodeState::initDecode()
+{
+        ov_callbacks vfs_callbacks;
+        vfs_callbacks.read_func = vfs_read;
+        vfs_callbacks.seek_func = vfs_seek;
+        vfs_callbacks.close_func = vfs_close;
+        vfs_callbacks.tell_func = vfs_tell;
+
+        //llinfos << "Initing decode from vfile: " << mUUID << llendl;
+
+        mInFilep = new LLVFile(gVFS, mUUID, LLAssetType::AT_SOUND);
+        if (!mInFilep || !mInFilep->getSize())
+        {
+                llwarns << "unable to open vorbis source vfile for reading" << llendl;
+                delete mInFilep;
+                mInFilep = NULL;
+                return FALSE;
+        }
+
+        int r = ov_open_callbacks(mInFilep, &mVF, NULL, 0, vfs_callbacks);
+        if(r < 0) 
+        {
+                llwarns << r << " Input to vorbis decode does not appear to be an Ogg bitstream: " << mUUID << llendl;
+                return(FALSE);
+        }
+        
+        size_t size_guess = (size_t)ov_pcm_total(&mVF, -1);
+        vorbis_info* vi = ov_info(&mVF, -1);
+        size_guess *= vi->channels;
+        size_guess *= 2;
+        size_guess += 2048;
+        mWAVBuffer.reserve(size_guess);
+        mWAVBuffer.resize(WAV_HEADER_SIZE);
+
+        {
+                // write the .wav format header
+                //"RIFF"
+                mWAVBuffer[0] = 0x52;
+                mWAVBuffer[1] = 0x49;
+                mWAVBuffer[2] = 0x46;
+                mWAVBuffer[3] = 0x46;
+
+                // length = datalen + 36 (to be filled in later)
+                mWAVBuffer[4] = 0x00;
+                mWAVBuffer[5] = 0x00;
+                mWAVBuffer[6] = 0x00;
+                mWAVBuffer[7] = 0x00;
+
+                //"WAVE"
+                mWAVBuffer[8] = 0x57;
+                mWAVBuffer[9] = 0x41;
+                mWAVBuffer[10] = 0x56;
+                mWAVBuffer[11] = 0x45;
+
+                // "fmt "
+                mWAVBuffer[12] = 0x66;
+                mWAVBuffer[13] = 0x6D;
+                mWAVBuffer[14] = 0x74;
+                mWAVBuffer[15] = 0x20;
+
+                // chunk size = 16
+                mWAVBuffer[16] = 0x10;
+                mWAVBuffer[17] = 0x00;
+                mWAVBuffer[18] = 0x00;
+                mWAVBuffer[19] = 0x00;
+
+                // format (1 = PCM)
+                mWAVBuffer[20] = 0x01;
+                mWAVBuffer[21] = 0x00;
+
+                // number of channels
+                mWAVBuffer[22] = 0x01;
+                mWAVBuffer[23] = 0x00;
+
+                // samples per second
+                mWAVBuffer[24] = 0x44;
+                mWAVBuffer[25] = 0xAC;
+                mWAVBuffer[26] = 0x00;
+                mWAVBuffer[27] = 0x00;
+
+                // average bytes per second
+                mWAVBuffer[28] = 0x88;
+                mWAVBuffer[29] = 0x58;
+                mWAVBuffer[30] = 0x01;
+                mWAVBuffer[31] = 0x00;
+
+                // bytes to output at a single time
+                mWAVBuffer[32] = 0x02;
+                mWAVBuffer[33] = 0x00;
+                 
+                // 16 bits per sample
+                mWAVBuffer[34] = 0x10;
+                mWAVBuffer[35] = 0x00;
+
+                // "data"
+                mWAVBuffer[36] = 0x64;
+                mWAVBuffer[37] = 0x61;
+                mWAVBuffer[38] = 0x74;
+                mWAVBuffer[39] = 0x61;
+
+                // these are the length of the data chunk, to be filled in later
+                mWAVBuffer[40] = 0x00;
+                mWAVBuffer[41] = 0x00;
+                mWAVBuffer[42] = 0x00;
+                mWAVBuffer[43] = 0x00;
+        }
+        
+        //{
+                //char **ptr=ov_comment(&mVF,-1)->user_comments;
+//              vorbis_info *vi=ov_info(&vf,-1);
+                //while(*ptr){
+                //      fprintf(stderr,"%s\n",*ptr);
+                //      ++ptr;
+                //}
+//    fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate);
+//    fprintf(stderr,"\nDecoded length: %ld samples\n", (long)ov_pcm_total(&vf,-1));
+//    fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor);
+        //}
+        return TRUE;
+}
+
+BOOL LLVorbisDecodeState::decodeSection()
+{
+        if (!mInFilep)
+        {
+                llwarns << "No VFS file to decode in vorbis!" << llendl;
+                return TRUE;
+        }
+        if (mDone)
+        {
+//              llwarns << "Already done with decode, aborting!" << llendl;
+                return TRUE;
+        }
+        char pcmout[4096];      /*Flawfinder: ignore*/
+
+        BOOL eof = FALSE;
+        long ret=ov_read(&mVF, pcmout, sizeof(pcmout), 0, 2, 1, &mCurrentSection);
+        if (ret == 0)
+        {
+                /* EOF */
+                eof = TRUE;
+                mDone = TRUE;
+                mValid = TRUE;
+//                      llinfos << "Vorbis EOF" << llendl;
+        }
+        else if (ret < 0)
+        {
+                /* error in the stream.  Not a problem, just reporting it in
+                   case we (the app) cares.  In this case, we don't. */
+
+                llwarns << "BAD vorbis decode in decodeSection." << llendl;
+
+                mValid = FALSE;
+                mDone = TRUE;
+                // We're done, return TRUE.
+                return TRUE;
+        }
+        else
+        {
+//                      llinfos << "Vorbis read " << ret << "bytes" << llendl;
+                /* we don't bother dealing with sample rate changes, etc, but.
+                   you'll have to*/
+                std::copy(pcmout, pcmout+ret, std::back_inserter(mWAVBuffer));
+        }
+        return eof;
+}
+
+BOOL LLVorbisDecodeState::finishDecode()
+{
+        if (!isValid())
+        {
+                llwarns << "Bogus vorbis decode state for " << getUUID() << ", aborting!" << llendl;
+                return TRUE; // We've finished
+        }
+
+#if !defined(USE_WAV_VFILE)     
+        if (mFileHandle == LLLFSThread::nullHandle())
+#endif
+        {
+                ov_clear(&mVF);
+  
+                // write "data" chunk length, in little-endian format
+                S32 data_length = mWAVBuffer.size() - WAV_HEADER_SIZE;
+                mWAVBuffer[40] = (data_length) & 0x000000FF;
+                mWAVBuffer[41] = (data_length >> 8) & 0x000000FF;
+                mWAVBuffer[42] = (data_length >> 16) & 0x000000FF;
+                mWAVBuffer[43] = (data_length >> 24) & 0x000000FF;
+                // write overall "RIFF" length, in little-endian format
+                data_length += 36;
+                mWAVBuffer[4] = (data_length) & 0x000000FF;
+                mWAVBuffer[5] = (data_length >> 8) & 0x000000FF;
+                mWAVBuffer[6] = (data_length >> 16) & 0x000000FF;
+                mWAVBuffer[7] = (data_length >> 24) & 0x000000FF;
+
+                //
+                // FUCK!!! Vorbis encode/decode messes up loop point transitions (pop)
+                // do a cheap-and-cheesy crossfade 
+                //
+                {
+                        S16 *samplep;
+                        S32 i;
+                        S32 fade_length;
+                        char pcmout[4096];              /*Flawfinder: ignore*/  
+
+                        fade_length = llmin((S32)128,(S32)(data_length-36)/8);                  
+                        if((S32)mWAVBuffer.size() >= (WAV_HEADER_SIZE + 2* fade_length))
+                        {
+                                memcpy(pcmout, &mWAVBuffer[WAV_HEADER_SIZE], (2 * fade_length));        /*Flawfinder: ignore*/
+                        }
+                        llendianswizzle(&pcmout, 2, fade_length);
+        
+                        samplep = (S16 *)pcmout;
+                        for (i = 0 ;i < fade_length; i++)
+                        {
+                                *samplep = llfloor((F32)*samplep * ((F32)i/(F32)fade_length));
+                                samplep++;
+                        }
+
+                        llendianswizzle(&pcmout, 2, fade_length);                       
+                        if((WAV_HEADER_SIZE+(2 * fade_length)) < (S32)mWAVBuffer.size())
+                        {
+                                memcpy(&mWAVBuffer[WAV_HEADER_SIZE], pcmout, (2 * fade_length));        /*Flawfinder: ignore*/
+                    }
+                        S32 near_end = mWAVBuffer.size() - (2 * fade_length);
+                        if ((S32)mWAVBuffer.size() >= ( near_end + 2* fade_length))
+                        {
+                                memcpy(pcmout, &mWAVBuffer[near_end], (2 * fade_length));       /*Flawfinder: ignore*/
+                    }
+                        llendianswizzle(&pcmout, 2, fade_length);
+
+                        samplep = (S16 *)pcmout;
+                        for (i = fade_length-1 ; i >=  0; i--)
+                        {
+                                *samplep = llfloor((F32)*samplep * ((F32)i/(F32)fade_length));
+                                samplep++;
+                        }
+        
+                        llendianswizzle(&pcmout, 2, fade_length);                       
+                        if (near_end + (2 * fade_length) < (S32)mWAVBuffer.size())
+                        {
+                                memcpy(&mWAVBuffer[near_end], pcmout, (2 * fade_length));/*Flawfinder: ignore*/
+                        }
+                }
+
+                if (36 == data_length)
+                {
+                        llwarns << "BAD Vorbis decode in finishDecode!" << llendl;
+                        mValid = FALSE;
+                        return TRUE; // we've finished
+                }
+#if !defined(USE_WAV_VFILE)
+                mFileHandle = LLLFSThread::sLocal->write(mOutFilename, &mWAVBuffer[0], 0, data_length);
+#endif
+        }
+
+        if (mFileHandle != LLLFSThread::nullHandle())
+        {
+                LLLFSThread::status_t s = LLLFSThread::sLocal->getRequestStatus(mFileHandle);
+                if (s != LLLFSThread::STATUS_COMPLETE)
+                {
+                        if (s != LLLFSThread::STATUS_QUEUED && s != LLLFSThread::STATUS_INPROGRESS)
+                        {
+                                llerrs << "Bad file status in LLVorbisDecodeState::finishDecode: " << s << llendl;
+                        }
+                        return FALSE; // not finished
+                }
+                else
+                {
+                        LLLFSThread::Request* req = (LLLFSThread::Request*)LLLFSThread::sLocal->getRequest(mFileHandle);
+                        if (req->getBytesRead() == 0) //!= req->getBytes() // should be safe, but needs testing
+                        {
+                                llwarns << "Unable to write file in LLVorbisDecodeState::finishDecode" << llendl;
+                                mValid = FALSE;
+                                return TRUE; // we've finished
+                        }
+                }
+                LLLFSThread::sLocal->completeRequest(mFileHandle);
+        }
+        
+        mDone = TRUE;
+
+#if defined(USE_WAV_VFILE)
+        // write the data.
+        LLVFile output(gVFS, mUUID, LLAssetType::AT_SOUND_WAV);
+        output.write(&mWAVBuffer[0], mWAVBuffer.size());
+#endif
+        //llinfos << "Finished decode for " << getUUID() << llendl;
+
+        return TRUE;
+}
diff --git a/linden/indra/llaudio/llaudiodecodemgr.h b/linden/indra/llaudio/llaudiodecodemgr.h
new file mode 100644
index 0000000..3480004
--- /dev/null
+++ b/linden/indra/llaudio/llaudiodecodemgr.h
@@ -0,0 +1,66 @@
+/** 
+ * @file llaudiodecodemgr.h
+ *
+ * Copyright (c) 2003-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_LLAUDIODECODEMGR_H
+#define LL_LLAUDIODECODEMG_H
+
+#include "stdtypes.h"
+
+#include "lllinkedqueue.h"
+#include "lluuid.h"
+
+#include "llassettype.h"
+#include "llframetimer.h"
+
+class LLVFS;
+class LLVorbisDecodeState;
+
+
+class LLAudioDecodeMgr
+{
+public:
+        LLAudioDecodeMgr();
+        ~LLAudioDecodeMgr();
+
+        void processQueue(const F32 num_secs = 0.005);
+
+        LLLinkedQueue<LLUUID> mDecodeQueue;
+
+        LLVorbisDecodeState *mCurrentDecodep;
+
+        BOOL addDecodeRequest(const LLUUID &uuid);
+        void addAudioRequest(const LLUUID &uuid);
+
+        S32 getRequestCount();
+        
+protected:
+        LLLinkedQueue<LLUUID> mDownloadQueue;
+        LLFrameTimer mCurrentTransferAge;
+};
+
+extern LLAudioDecodeMgr *gAudioDecodeMgrp;
+
+#endif
diff --git a/linden/indra/llaudio/vorbisdecode.cpp b/linden/indra/llaudio/vorbisdecode.cpp
new file mode 100644
index 0000000..4308b71
--- /dev/null
+++ b/linden/indra/llaudio/vorbisdecode.cpp
@@ -0,0 +1,321 @@
+/** 
+ * @file vorbisdecode.cpp
+ * @brief Vorbis decoding routine routine for Indra.
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "vorbis/codec.h"
+#include "vorbis/vorbisfile.h"
+#include "llerror.h"
+#include "llmath.h"
+#include "llvfile.h"
+
+#if 0
+
+size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        if (size > 0 && file->read((U8*)ptr, size * nmemb))     /*Flawfinder: ignore*/
+        {
+                S32 read = file->getLastBytesRead();
+                return  read / size;    /*Flawfinder: ignore*/
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+int vfs_seek(void *datasource, ogg_int64_t offset, int whence)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        // vfs has 31-bit files
+        if (offset > S32_MAX)
+        {
+                return -1;
+        }
+
+        S32 origin;
+        switch (whence) {
+        case SEEK_SET:
+                origin = 0;
+                break;
+        case SEEK_END:
+                origin = file->getSize();
+                break;
+        case SEEK_CUR:
+                origin = -1;
+                break;
+        default:
+                llerrs << "Invalid whence argument to vfs_seek" << llendl;
+                return -1;
+        }
+
+        if (file->seek((S32)offset, origin))
+        {
+                return 0;
+        }
+        else
+        {
+                return -1;
+        }
+}
+
+int vfs_close (void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        delete file;
+
+        return 0;
+}
+
+long vfs_tell (void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        return file->tell();
+}
+
+
+BOOL decode_vorbis_file(LLVFS *vfs, const LLUUID &in_uuid, char *out_fname)
+{
+        ov_callbacks vfs_callbacks;
+        vfs_callbacks.read_func = vfs_read;
+        vfs_callbacks.seek_func = vfs_seek;
+        vfs_callbacks.close_func = vfs_close;
+        vfs_callbacks.tell_func = vfs_tell;
+
+        char pcmout[4096]; /*Flawfinder: ignore*/
+
+        unsigned char temp[64]; /*Flawfinder: ignore*/
+
+        LLVFile *in_vfile;
+
+        U32 data_length = 0;
+
+        llinfos << "Vorbis decode from vfile: " << in_uuid << llendl;
+
+        in_vfile = new LLVFile(vfs, in_uuid, LLAssetType::AT_SOUND);
+        if (! in_vfile->getSize())
+        {
+                llwarning("unable to open vorbis source vfile for reading",0);
+                return(FALSE);
+        }
+        apr_file_t* outfp = ll_apr_file_open(out_fname,LL_APR_WPB);
+        if (!outfp)
+        {
+                llwarning("unable to open vorbis destination file for writing",0);
+                return(FALSE);          
+        }
+        else
+        {
+                // write the .wav format header
+                //"RIFF"
+                temp[0] = 0x52;
+                temp[1] = 0x49;
+                temp[2] = 0x46;
+                temp[3] = 0x46;
+                
+                // length = datalen + 36 (to be filled in later)
+                temp[4] = 0x00;
+                temp[5] = 0x00;
+                temp[6] = 0x00;
+                temp[7] = 0x00;
+                
+                //"WAVE"
+                temp[8] = 0x57;
+                temp[9] = 0x41;
+                temp[10] = 0x56;
+                temp[11] = 0x45;
+
+                // "fmt "
+                temp[12] = 0x66;
+                temp[13] = 0x6D;
+                temp[14] = 0x74;
+                temp[15] = 0x20;
+
+                // chunk size = 16
+                temp[16] = 0x10;
+                temp[17] = 0x00;
+                temp[18] = 0x00;
+                temp[19] = 0x00;
+
+                // format (1 = PCM)
+                temp[20] = 0x01;
+                temp[21] = 0x00;
+
+                // number of channels
+                temp[22] = 0x01;
+                temp[23] = 0x00;
+
+                // samples per second
+                temp[24] = 0x44;
+                temp[25] = 0xAC;
+                temp[26] = 0x00;
+                temp[27] = 0x00;
+
+                // average bytes per second
+                temp[28] = 0x88;
+                temp[29] = 0x58;
+                temp[30] = 0x01;
+                temp[31] = 0x00;
+
+                // bytes to output at a single time
+                temp[32] = 0x02;
+                temp[33] = 0x00;
+                 
+                // 16 bits per sample
+                temp[34] = 0x10;
+                temp[35] = 0x00;
+
+                // "data"
+                temp[36] = 0x64;
+                temp[37] = 0x61;
+                temp[38] = 0x74;
+                temp[39] = 0x61;
+
+
+                // these are the length of the data chunk, to be filled in later
+                temp[40] = 0x00;
+                temp[41] = 0x00;
+                temp[42] = 0x00;
+                temp[43] = 0x00;
+
+
+                ll_apr_file_write(outfp, temp, 44);
+        }
+
+        OggVorbis_File vf;
+        int eof=0;
+        int current_section;
+ 
+        int r = ov_open_callbacks(in_vfile, &vf, NULL, 0, vfs_callbacks);
+        if(r < 0) 
+        {
+                llwarns << r << " Input to vorbis decode does not appear to be an Ogg bitstream: " << in_uuid << llendl;
+                return(FALSE);
+        }
+
+        {
+                char **ptr=ov_comment(&vf,-1)->user_comments;
+//              vorbis_info *vi=ov_info(&vf,-1);
+                while(*ptr){
+                        fprintf(stderr,"%s\n",*ptr);
+                        ++ptr;
+                }
+//    fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate);
+//    fprintf(stderr,"\nDecoded length: %ld samples\n", (long)ov_pcm_total(&vf,-1));
+//    fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor);
+        }
+  
+        while(!eof){
+                long ret=ov_read(&vf,pcmout,sizeof(pcmout),0,2,1,&current_section);
+                if (ret == 0) {
+                        /* EOF */
+                        eof=1;
+//                      llinfos << "Vorbis EOF" << llendl;
+                } else if (ret < 0) {
+                        /* error in the stream.  Not a problem, just reporting it in
+                           case we (the app) cares.  In this case, we don't. */
+                        llwarning("Error in vorbis stream",0); 
+                        break;
+
+                } else {
+//                      llinfos << "Vorbis read " << ret << "bytes" << llendl;
+                        /* we don't bother dealing with sample rate changes, etc, but.
+                           you'll have to*/
+                        data_length += ll_apr_file_write(outfp, pcmout, ret);
+                }
+        }
+
+        ov_clear(&vf);
+  
+        // write "data" chunk length
+        ll_apr_file_seek(outfp,APR_SET,40);
+        ll_apr_file_write(outfp,&data_length,4);
+ 
+        // write overall "RIFF" length
+        data_length += 36;
+        ll_apr_file_seek(outfp,APR_SET,4);
+        ll_apr_file_write(outfp,&data_length,1*4);
+
+        // FUCK!!! Vorbis encode/decode messes up loop point transitions (pop)
+        // do a cheap-and-cheesy crossfade 
+        
+
+        S16 *samplep;
+        S32 i;
+        S32 fade_length;
+
+        fade_length = llmin((S32)128,(S32)(data_length-36)/8);
+        
+        ll_apr_file_seek(outfp,APR_SET,44);
+        ll_apr_file_read(outfp, pcmout,2*fade_length);  //read first 16 samples
+
+        samplep = (S16 *)pcmout;
+
+        for (i = 0 ;i < fade_length; i++)
+        {
+                *samplep++ = ((F32)*samplep * ((F32)i/(F32)fade_length));          
+        }
+        
+        ll_apr_file_seek(outfp,APR_SET,44);
+        ll_apr_file_write(outfp,pcmout,2*fade_length);  //write back xfaded first 16 samples
+
+        ll_apr_file_seek(outfp,APR_END,-fade_length*2); 
+        ll_apr_file_read(outfp, pcmout,2*fade_length);  //read last 16 samples
+
+        samplep = (S16 *)pcmout;
+
+        for (i = fade_length-1 ; i >=  0; i--)
+        {
+                *samplep++ = ((F32)*samplep * ((F32)i/(F32)fade_length));          
+        }
+        
+        ll_apr_file_seek(outfp,SEEK_END,-fade_length*2); 
+        ll_apr_file_write(outfp,pcmout,2*fade_length);  //write back xfaded last 16 samples
+
+        apr_file_close(outfp);
+
+        if ((36 == data_length) || (!(eof)))
+        {
+                llwarning("BAD Vorbis DECODE!, removing .wav!",0); 
+                LLFile::remove(out_fname);
+                return (FALSE);
+        }
+    
+//      fprintf(stderr,"Done.\n");
+
+        return(TRUE);
+}
+#endif
diff --git a/linden/indra/llaudio/vorbisdecode.h b/linden/indra/llaudio/vorbisdecode.h
new file mode 100644
index 0000000..e5f1b26
--- /dev/null
+++ b/linden/indra/llaudio/vorbisdecode.h
@@ -0,0 +1,37 @@
+/** 
+ * @file vorbisdecode.h
+ * @brief Vorbis decoding routine routine for Indra.
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_VORBISDECODE_H
+#define LL_VORBISDECODE_H
+
+class LLVFS;
+class LLUUID;
+
+BOOL decode_vorbis_file(LLVFS *vfs, const LLUUID &in_uuid, char *out_fname);
+
+#endif
+
diff --git a/linden/indra/llaudio/vorbisencode.cpp b/linden/indra/llaudio/vorbisencode.cpp
new file mode 100644
index 0000000..6007940
--- /dev/null
+++ b/linden/indra/llaudio/vorbisencode.cpp
@@ -0,0 +1,506 @@
+/** 
+ * @file vorbisencode.cpp
+ * @brief Vorbis encoding routine routine for Indra.
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "vorbisencode.h"
+#include "vorbis/vorbisenc.h"
+#include "llerror.h"
+#include "llrand.h"
+#include "llmath.h"
+#include "llapr.h"
+
+//#if LL_DARWIN
+// MBW -- XXX -- Getting rid of SecondLifeVorbis for now -- no fmod means no name collisions.
+#if 0
+#include "VorbisFramework.h"
+
+#define vorbis_analysis                         mac_vorbis_analysis
+#define vorbis_analysis_headerout       mac_vorbis_analysis_headerout
+#define vorbis_analysis_init            mac_vorbis_analysis_init
+#define vorbis_encode_ctl                       mac_vorbis_encode_ctl
+#define vorbis_encode_setup_init        mac_vorbis_encode_setup_init
+#define vorbis_encode_setup_managed     mac_vorbis_encode_setup_managed
+
+#define vorbis_info_init                        mac_vorbis_info_init
+#define vorbis_info_clear                       mac_vorbis_info_clear
+#define vorbis_comment_init                     mac_vorbis_comment_init
+#define vorbis_comment_clear            mac_vorbis_comment_clear
+#define vorbis_block_init                       mac_vorbis_block_init
+#define vorbis_block_clear                      mac_vorbis_block_clear
+#define vorbis_dsp_clear                        mac_vorbis_dsp_clear
+#define vorbis_analysis_buffer          mac_vorbis_analysis_buffer
+#define vorbis_analysis_wrote           mac_vorbis_analysis_wrote
+#define vorbis_analysis_blockout        mac_vorbis_analysis_blockout
+
+#define ogg_stream_packetin                     mac_ogg_stream_packetin
+#define ogg_stream_init                         mac_ogg_stream_init
+#define ogg_stream_flush                        mac_ogg_stream_flush
+#define ogg_stream_pageout                      mac_ogg_stream_pageout
+#define ogg_page_eos                            mac_ogg_page_eos
+#define ogg_stream_clear                        mac_ogg_stream_clear
+
+#endif
+
+S32 check_for_invalid_wav_formats(const char *in_fname, char *error_msg)
+{
+        U16 num_channels = 0;
+        U32 sample_rate = 0;
+        U32 bits_per_sample = 0;
+        U32 physical_file_size = 0;
+        U32 chunk_length = 0;
+        U32 raw_data_length = 0;
+        U32 bytes_per_sec = 0;
+        BOOL uncompressed_pcm = FALSE;
+
+        unsigned char wav_header[44];           /*Flawfinder: ignore*/
+
+        error_msg[0] = '\0';
+
+    apr_file_t* infp = ll_apr_file_open(in_fname,LL_APR_RB);
+        if (!infp)
+        {
+                strcpy(error_msg, "CannotUploadSoundFile");     /*Flawfinder: ignore*/
+                return(LLVORBISENC_SOURCE_OPEN_ERR);
+        }
+
+        ll_apr_file_read(infp, wav_header, 44);
+        physical_file_size = ll_apr_file_seek(infp,APR_END,0);
+
+        if (strncmp((char *)&(wav_header[0]),"RIFF",4))
+        {
+                strcpy(error_msg, "SoundFileNotRIFF");  /*Flawfinder: ignore*/
+                apr_file_close(infp);
+            return(LLVORBISENC_WAV_FORMAT_ERR);
+        }
+
+        if (strncmp((char *)&(wav_header[8]),"WAVE",4))
+        {
+                strcpy(error_msg, "SoundFileNotRIFF");  /*Flawfinder: ignore*/
+                apr_file_close(infp);
+            return(LLVORBISENC_WAV_FORMAT_ERR);
+        }
+        
+        // parse the chunks
+        
+        U32 file_pos = 12;  // start at the first chunk (usually fmt but not always)
+        
+        while ((file_pos + 8)< physical_file_size)
+        {
+                ll_apr_file_seek(infp,APR_SET,file_pos);
+                ll_apr_file_read(infp, wav_header, 44);
+
+                chunk_length = ((U32) wav_header[7] << 24) 
+                        + ((U32) wav_header[6] << 16) 
+                        + ((U32) wav_header[5] << 8) 
+                        + wav_header[4];
+
+//              llinfos << "chunk found: '" << wav_header[0] << wav_header[1] << wav_header[2] << wav_header[3] << "'" << llendl;
+
+                if (!(strncmp((char *)&(wav_header[0]),"fmt ",4)))
+                {
+                        if ((wav_header[8] == 0x01) && (wav_header[9] == 0x00))
+                        {
+                                uncompressed_pcm = TRUE;
+                        }
+                        num_channels = ((U16) wav_header[11] << 8) + wav_header[10];
+                        sample_rate = ((U32) wav_header[15] << 24) 
+                                + ((U32) wav_header[14] << 16) 
+                                + ((U32) wav_header[13] << 8) 
+                                + wav_header[12];
+                        bits_per_sample = ((U16) wav_header[23] << 8) + wav_header[22];
+                        bytes_per_sec = ((U32) wav_header[19] << 24) 
+                                + ((U32) wav_header[18] << 16) 
+                                + ((U32) wav_header[17] << 8) 
+                                + wav_header[16];
+                }
+                else if (!(strncmp((char *)&(wav_header[0]),"data",4)))
+                {
+                        raw_data_length = chunk_length;                 
+                }
+                file_pos += (chunk_length + 8);
+                chunk_length = 0;
+        } 
+
+        apr_file_close(infp);   
+
+        if (!uncompressed_pcm)
+        {       
+                 strcpy(error_msg, "SoundFileNotPCM");          /*Flawfinder: ignore*/
+                  return(LLVORBISENC_PCM_FORMAT_ERR);
+        }
+        
+        if ((num_channels < 1) || (num_channels > 2))
+        {       
+                strcpy(error_msg, "SoundFileInvalidChannelCount");      /*Flawfinder: ignore*/
+                return(LLVORBISENC_MULTICHANNEL_ERR);
+        }
+
+        if (sample_rate != 44100)
+        {       
+                strcpy(error_msg, "SoundFileInvalidSampleRate");                /*Flawfinder: ignore*/
+                return(LLVORBISENC_UNSUPPORTED_SAMPLE_RATE);
+        }
+        
+        if ((bits_per_sample != 16) && (bits_per_sample != 8))
+        {                
+                strcpy(error_msg, "SoundFileInvalidWordSize");          /*Flawfinder: ignore*/
+                return(LLVORBISENC_UNSUPPORTED_WORD_SIZE);
+        }
+
+        if (!raw_data_length)
+        {
+                strcpy(error_msg, "SoundFileInvalidHeader");                    /*Flawfinder: ignore*/
+                return(LLVORBISENC_CLIP_TOO_LONG);               
+        }
+
+        F32 clip_length = (F32)raw_data_length/(F32)bytes_per_sec;
+                
+        if (clip_length > 10.0f)
+        {
+                strcpy(error_msg, "SoundFileInvalidTooLong");                   /*Flawfinder: ignore*/
+                return(LLVORBISENC_CLIP_TOO_LONG);               
+        }
+
+    return(LLVORBISENC_NOERR);
+}
+
+S32 encode_vorbis_file(const char *in_fname, const char *out_fname)
+{
+        return(encode_vorbis_file_at(in_fname,out_fname, 128000));
+}
+
+S32 encode_vorbis_file_at(const char *in_fname, const char *out_fname, S32 bitrate)
+{
+#define READ_BUFFER 1024
+        unsigned char readbuffer[READ_BUFFER*4+44];   /* out of the data segment, not the stack */      /*Flawfinder: ignore*/
+
+        ogg_stream_state os; /* take physical pages, weld into a logical stream of packets */
+        ogg_page         og; /* one Ogg bitstream page.  Vorbis packets are inside */
+        ogg_packet       op; /* one raw packet of data for decode */
+        
+        vorbis_info      vi; /* struct that stores all the static vorbis bitstream settings */
+        vorbis_comment   vc; /* struct that stores all the user comments */
+        
+        vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
+        vorbis_block     vb; /* local working space for packet->PCM decode */
+        
+        int eos=0;
+        int result;
+
+        U16 num_channels = 0;
+        U32 sample_rate = 0;
+        U32 bits_per_sample = 0;
+
+        S32 format_error = 0;
+        char error_msg[MAX_STRING];     /*Flawfinder: ignore*/
+        if ((format_error = check_for_invalid_wav_formats(in_fname, error_msg)))
+        {
+                llwarns << error_msg << ": " << in_fname << llendl;
+                return(format_error);
+        }
+
+#if 1
+        unsigned char wav_header[44];   /*Flawfinder: ignore*/
+
+        S32 data_left = 0;
+
+        apr_file_t* infp = ll_apr_file_open(in_fname,LL_APR_RB);
+        if (!infp)
+        {
+                llwarns << "Couldn't open temporary ogg file for writing: " << in_fname
+                        << llendl;
+                return(LLVORBISENC_SOURCE_OPEN_ERR);
+        }
+        apr_file_t* outfp = ll_apr_file_open(out_fname,LL_APR_WPB);
+        if (!outfp)
+        {
+                llwarns << "Couldn't open upload sound file for reading: " << in_fname
+                        << llendl;
+                apr_file_close (infp);
+                return(LLVORBISENC_DEST_OPEN_ERR);
+        }
+        
+         // parse the chunks
+         U32 chunk_length = 0;
+         U32 file_pos = 12;  // start at the first chunk (usually fmt but not always)
+         
+         while (apr_file_eof(infp) != APR_EOF)
+         {
+                 ll_apr_file_seek(infp,APR_SET,file_pos);
+                 ll_apr_file_read(infp, wav_header, 44);
+                 
+                 chunk_length = ((U32) wav_header[7] << 24) 
+                         + ((U32) wav_header[6] << 16) 
+                         + ((U32) wav_header[5] << 8) 
+                         + wav_header[4];
+                 
+//               llinfos << "chunk found: '" << wav_header[0] << wav_header[1] << wav_header[2] << wav_header[3] << "'" << llendl;
+                 
+                 if (!(strncmp((char *)&(wav_header[0]),"fmt ",4)))
+                 {
+                         num_channels = ((U16) wav_header[11] << 8) + wav_header[10];
+                         sample_rate = ((U32) wav_header[15] << 24) 
+                                 + ((U32) wav_header[14] << 16) 
+                                 + ((U32) wav_header[13] << 8) 
+                                 + wav_header[12];
+                         bits_per_sample = ((U16) wav_header[23] << 8) + wav_header[22];
+                 }
+                 else if (!(strncmp((char *)&(wav_header[0]),"data",4)))
+                 {
+                         ll_apr_file_seek(infp,APR_SET,file_pos+8);
+                         // leave the file pointer at the beginning of the data chunk data
+                         data_left = chunk_length;                      
+                         break;
+                 }
+                 file_pos += (chunk_length + 8);
+                 chunk_length = 0;
+         } 
+         
+//       apr_file_close(infp);  
+
+         /********** Encode setup ************/
+         
+         /* choose an encoding mode */
+         /* (mode 0: 44kHz stereo uncoupled, roughly 128kbps VBR) */
+         vorbis_info_init(&vi);
+
+         // always encode to mono
+//       vorbis_encode_init(&vi, /* num_channels */ 1 ,sample_rate, -1, bitrate, -1);
+//       if (vorbis_encode_init(&vi, /* num_channels */ 1 ,sample_rate, -1, bitrate, -1))
+
+//       F32 quality = 0;
+//       quality = (bitrate==128000 ? 0.4f : 0.1);
+
+         if (vorbis_encode_init(&vi, /* num_channels */ 1 ,sample_rate, -1, bitrate, -1))
+//       if (vorbis_encode_init_vbr(&vi, /* num_channels */ 1 ,sample_rate, quality))
+//       if (vorbis_encode_setup_managed(&vi,1,sample_rate,-1,bitrate,-1) ||
+//              vorbis_encode_ctl(&vi,OV_ECTL_RATEMANAGE_AVG,NULL) ||
+//              vorbis_encode_setup_init(&vi))
+        {
+//              llwarns << "unable to initialize vorbis codec at quality " << quality << llendl;
+                llwarns << "unable to initialize vorbis codec at bitrate " << bitrate << llendl;
+                return(LLVORBISENC_DEST_OPEN_ERR);
+        }
+         
+         /* add a comment */
+         vorbis_comment_init(&vc);
+//       vorbis_comment_add(&vc,"Linden");
+         
+         /* set up the analysis state and auxiliary encoding storage */
+         vorbis_analysis_init(&vd,&vi);
+         vorbis_block_init(&vd,&vb);
+         
+         /* set up our packet->stream encoder */
+         /* pick a random serial number; that way we can more likely build
+                chained streams just by concatenation */
+         ogg_stream_init(&os,(int)frand(0xFFFFFF));
+         
+         /* Vorbis streams begin with three headers; the initial header (with
+                most of the codec setup parameters) which is mandated by the Ogg
+                bitstream spec.  The second header holds any comment fields.  The
+                third header holds the bitstream codebook.  We merely need to
+                make the headers, then pass them to libvorbis one at a time;
+                libvorbis handles the additional Ogg bitstream constraints */
+         
+         {
+                 ogg_packet header;
+                 ogg_packet header_comm;
+                 ogg_packet header_code;
+                 
+                 vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code);
+                 ogg_stream_packetin(&os,&header); /* automatically placed in its own
+                                                                                          page */
+                 ogg_stream_packetin(&os,&header_comm);
+                 ogg_stream_packetin(&os,&header_code);
+                 
+                 /* We don't have to write out here, but doing so makes streaming 
+                  * much easier, so we do, flushing ALL pages. This ensures the actual
+                  * audio data will start on a new page
+                  */
+                 while(!eos){
+                         int result=ogg_stream_flush(&os,&og);
+                         if(result==0)break;
+                         ll_apr_file_write(outfp, og.header, og.header_len);
+                         ll_apr_file_write(outfp, og.body, og.body_len);
+                 }
+                 
+         }
+         
+         
+         while(!eos)
+         {
+                 long bytes_per_sample = bits_per_sample/8;
+
+                 long bytes=(long)ll_apr_file_read(infp, readbuffer,llclamp((S32)(READ_BUFFER*num_channels*bytes_per_sample),0,data_left)); /* stereo hardwired here */
+                 
+                 if (bytes==0)
+                 {
+                         /* end of file.  this can be done implicitly in the mainline,
+                                but it's easier to see here in non-clever fashion.
+                                Tell the library we're at end of stream so that it can handle
+                                the last frame and mark end of stream in the output properly */
+
+                         vorbis_analysis_wrote(&vd,0);
+//                       eos = 1;
+                         
+                 }
+                 else
+                 {
+                         long i;
+                         long samples;
+                         int temp;
+
+                         data_left -= bytes;
+             /* data to encode */
+                         
+                         /* expose the buffer to submit data */
+                         float **buffer=vorbis_analysis_buffer(&vd,READ_BUFFER);
+                        
+                         i = 0;
+                         samples = bytes / (num_channels * bytes_per_sample);
+
+                         if (num_channels == 2)
+                         {
+                                 if (bytes_per_sample == 2)
+                                 {
+                                         /* uninterleave samples */
+                                         for(i=0; i<samples ;i++)
+                                         {
+                                                 temp =  ((signed char *)readbuffer)[i*4+1];    /*Flawfinder: ignore*/
+                                                 temp += ((signed char *)readbuffer)[i*4+3];    /*Flawfinder: ignore*/
+                                                 temp <<= 8;
+                                                 temp += readbuffer[i*4];
+                                                 temp += readbuffer[i*4+2];
+
+                                                 buffer[0][i] = ((float)temp) / 65536.f;
+                                         }
+                                 }
+                                 else // presume it's 1 byte per which is unsigned (F#@%ing wav "standard")
+                                 {
+                                         /* uninterleave samples */
+                                         for(i=0; i<samples ;i++)
+                                         {
+                                                 temp  = readbuffer[i*2+0];
+                                                 temp += readbuffer[i*2+1];
+                                                 temp -= 256;
+                                                 buffer[0][i] = ((float)temp) / 256.f;
+                                         }
+                                 } 
+                         }
+                         else if (num_channels == 1)
+                         {
+                                 if (bytes_per_sample == 2)
+                                 {
+                                         for(i=0; i < samples ;i++)
+                                         {
+                                                 temp = ((signed char*)readbuffer)[i*2+1];
+                                                 temp <<= 8;
+                                                 temp += readbuffer[i*2];
+                                                 buffer[0][i] = ((float)temp) / 32768.f;
+                                         }
+                                 }
+                                 else // presume it's 1 byte per which is unsigned (F#@%ing wav "standard")
+                                 {
+                                         for(i=0; i < samples ;i++)
+                                         {
+                                                 temp = readbuffer[i];
+                                                 temp -= 128;
+                                                 buffer[0][i] = ((float)temp) / 128.f;
+                                         }
+                                 }
+                         }
+                                
+                         /* tell the library how much we actually submitted */
+                         vorbis_analysis_wrote(&vd,i);
+                 }
+                         
+                 /* vorbis does some data preanalysis, then divvies up blocks for
+                        more involved (potentially parallel) processing.  Get a single
+                        block for encoding now */
+                 while(vorbis_analysis_blockout(&vd,&vb)==1)
+                 {
+                         
+                         /* analysis */
+                        /* Do the main analysis, creating a packet */
+                        vorbis_analysis(&vb, NULL);
+                        vorbis_bitrate_addblock(&vb);
+
+                        while(vorbis_bitrate_flushpacket(&vd, &op)) 
+                        {
+                         
+                         /* weld the packet into the bitstream */
+                         ogg_stream_packetin(&os,&op);
+                         
+                         /* write out pages (if any) */
+                         while(!eos)
+                         {
+                                 result = ogg_stream_pageout(&os,&og);
+
+                                 if(result==0)
+                                        break;
+
+                                 ll_apr_file_write(outfp, og.header, og.header_len);
+                                 ll_apr_file_write(outfp, og.body, og.body_len);
+                                 
+                                 /* this could be set above, but for illustrative purposes, I do
+                                        it here (to show that vorbis does know where the stream ends) */
+                                 
+                                 if(ogg_page_eos(&og))
+                                        eos=1;
+                                 
+                         }
+                        }
+                 }
+         }
+         
+         
+         
+         /* clean up and exit.  vorbis_info_clear() must be called last */
+         
+         ogg_stream_clear(&os);
+         vorbis_block_clear(&vb);
+         vorbis_dsp_clear(&vd);
+         vorbis_comment_clear(&vc);
+         vorbis_info_clear(&vi);
+         
+         /* ogg_page and ogg_packet structs always point to storage in
+                libvorbis.  They're never freed or manipulated directly */
+         
+//       fprintf(stderr,"Vorbis encoding: Done.\n");
+         llinfos << "Vorbis encoding: Done." << llendl;
+         apr_file_close(outfp);
+         apr_file_close(infp);
+         
+#endif
+         return(LLVORBISENC_NOERR);
+         
+}
diff --git a/linden/indra/llaudio/vorbisencode.h b/linden/indra/llaudio/vorbisencode.h
new file mode 100644
index 0000000..3813c50
--- /dev/null
+++ b/linden/indra/llaudio/vorbisencode.h
@@ -0,0 +1,49 @@
+/** 
+ * @file vorbisencode.h
+ * @brief Vorbis encoding routine routine for Indra.
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_VORBISENCODE_H
+#define LL_VORBISENCODE_H
+
+const S32 LLVORBISENC_NOERR                        = 0; // no error
+const S32 LLVORBISENC_SOURCE_OPEN_ERR              = 1; // error opening source
+const S32 LLVORBISENC_DEST_OPEN_ERR                = 2; // error opening destination
+const S32 LLVORBISENC_WAV_FORMAT_ERR               = 3; // not a WAV
+const S32 LLVORBISENC_PCM_FORMAT_ERR               = 4; // not a PCM
+const S32 LLVORBISENC_MONO_ERR                     = 5; // can't do mono
+const S32 LLVORBISENC_STEREO_ERR                   = 6; // can't do stereo
+const S32 LLVORBISENC_MULTICHANNEL_ERR             = 7; // can't do stereo
+const S32 LLVORBISENC_UNSUPPORTED_SAMPLE_RATE      = 8; // unsupported sample rate
+const S32 LLVORBISENC_UNSUPPORTED_WORD_SIZE        = 9; // unsupported word size
+const S32 LLVORBISENC_CLIP_TOO_LONG                = 10; // source file is too long
+
+
+S32 check_for_invalid_wav_formats(const char *in_fname, char *error_msg);
+S32 encode_vorbis_file(const char *in_fname, const char *out_fname);
+S32 encode_vorbis_file_at(const char *in_fname, const char *out_fname, S32 bitrate);
+
+#endif
+