28 files changed, 1719 insertions, 1227 deletions

diff --git a/linden/indra/llaudio/CMakeLists.txt b/linden/indra/llaudio/CMakeLists.txt
index 0a668f9..1a0527c 100644
--- a/linden/indra/llaudio/CMakeLists.txt
+++ b/linden/indra/llaudio/CMakeLists.txt
@@ -4,6 +4,7 @@ project(llaudio)
 
 # Current starting point for CMake. Seems rather arbitrary - MC
 include(00-Common)
+include(LLAudio)
 include(Audio)
 include(OPENAL)
 include(FMOD)
@@ -12,9 +13,9 @@ include(LLCommon)
 include(LLMath)
 include(LLMessage)
 include(LLVFS)
-include(LLMedia)
 
 include_directories(
+    ${LLAUDIO_INCLUDE_DIRS}
     ${FMOD_INCLUDE_DIR}
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
@@ -26,43 +27,43 @@ include_directories(
     ${VORBIS_INCLUDE_DIRS}
     ${OPENAL_LIB_INCLUDE_DIRS}
     ${FREEAULT_LIB_INCLUDE_DIRS}
-    ${LLMEDIA_INCLUDE_DIRS}
-    ${GSTREAMER_INCLUDE_DIRS}
     )
 
 set(llaudio_SOURCE_FILES
-    audioengine.cpp
-    listener.cpp
+    llaudioengine.cpp
+    lllistener.cpp
     llaudiodecodemgr.cpp
-    vorbisdecode.cpp
-    vorbisencode.cpp
+    llvorbisdecode.cpp
+    llvorbisencode.cpp
     )
 
 set(llaudio_HEADER_FILES
     CMakeLists.txt
 
-    audioengine.h
-    listener.h
+    llaudioengine.h
+    lllistener.h
     llaudiodecodemgr.h
-    vorbisdecode.h
-    vorbisencode.h
-    windgen.h
+    llvorbisdecode.h
+    llvorbisencode.h
+    llwindgen.h
     )
 
 if (FMOD)
     list(APPEND llaudio_SOURCE_FILES
-         audioengine_fmod.cpp
-         listener_fmod.cpp
+         llaudioengine_fmod.cpp
+         lllistener_fmod.cpp
+         llstreamingaudio_fmod.cpp
          )
 
     list(APPEND llaudio_HEADER_FILES
-         audioengine_fmod.h
-         listener_fmod.h
+         llaudioengine_fmod.h
+         lllistener_fmod.h
+         llstreamingaudio_fmod.h
          )
 
     if (LINUX)
       if (${CXX_VERSION} MATCHES "4.[23]")
-        set_source_files_properties(audioengine_fmod.cpp
+        set_source_files_properties(llaudioengine_fmod.cpp
                                     COMPILE_FLAGS -Wno-error=write-strings)
       endif (${CXX_VERSION} MATCHES "4.[23]")
     endif (LINUX)
@@ -70,13 +71,13 @@ endif (FMOD)
 
 if (OPENAL)
   list(APPEND llaudio_SOURCE_FILES
-    audioengine_openal.cpp
-    listener_openal.cpp
+    llaudioengine_openal.cpp
+    lllistener_openal.cpp
     )
   
   list(APPEND llaudio_HEADER_FILES
-    audioengine_openal.h
-    listener_openal.h
+    llaudioengine_openal.h
+    lllistener_openal.h
     )
 endif (OPENAL)
 
diff --git a/linden/indra/llaudio/listener.cpp b/linden/indra/llaudio/listener.cpp
index e2dc30e..e69de29 100644
--- a/linden/indra/llaudio/listener.cpp
+++ b/linden/indra/llaudio/listener.cpp
@@ -1,153 +0,0 @@
-/** 
- * @file listener.cpp
- * @brief Implementation of LISTENER class abstracting the audio support
- *
- * $LicenseInfo:firstyear=2000&license=viewergpl$
- * 
- * Copyright (c) 2000-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#include "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::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
index 4137304..e69de29 100644
--- a/linden/indra/llaudio/listener.h
+++ b/linden/indra/llaudio/listener.h
@@ -1,80 +0,0 @@
-/** 
- * @file listener.h
- * @brief Description of LISTENER base class abstracting the audio support.
- *
- * $LicenseInfo:firstyear=2000&license=viewergpl$
- * 
- * Copyright (c) 2000-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LL_LISTENER_H
-#define LL_LISTENER_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 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
index 3121e12..e69de29 100644
--- a/linden/indra/llaudio/listener_ds3d.h
+++ b/linden/indra/llaudio/listener_ds3d.h
@@ -1,76 +0,0 @@
-/** 
- * @file listener_ds3d.h
- * @brief Description of LISTENER class abstracting the audio support
- * as a DirectSound 3D implementation (windows only)
- *
- * $LicenseInfo:firstyear=2000&license=viewergpl$
- * 
- * Copyright (c) 2000-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#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
index 4bbb3d9..e69de29 100644
--- a/linden/indra/llaudio/listener_fmod.cpp
+++ b/linden/indra/llaudio/listener_fmod.cpp
@@ -1,143 +0,0 @@
-/** 
- * @file listener_fmod.cpp
- * @brief implementation of LISTENER class abstracting the audio
- * support as a FMOD 3D implementation (windows only)
- *
- * $LicenseInfo:firstyear=2002&license=viewergpl$
- * 
- * Copyright (c) 2002-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "audioengine.h"
-#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;
-}
diff --git a/linden/indra/llaudio/listener_fmod.h b/linden/indra/llaudio/listener_fmod.h
index 5f372ab..e69de29 100644
--- a/linden/indra/llaudio/listener_fmod.h
+++ b/linden/indra/llaudio/listener_fmod.h
@@ -1,67 +0,0 @@
-/** 
- * @file listener_fmod.h
- * @brief Description of LISTENER class abstracting the audio support
- * as an FMOD 3D implementation (windows and Linux)
- *
- * $LicenseInfo:firstyear=2002&license=viewergpl$
- * 
- * Copyright (c) 2002-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LL_LISTENER_FMOD_H
-#define LL_LISTENER_FMOD_H
-
-#include "listener.h"
-
-class LLListener_FMOD : public LLListener
-{
- 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();
-
- protected:
-         F32 mDopplerFactor;
-         F32 mDistanceFactor;
-         F32 mRolloffFactor;
-};
-
-#endif
-
-
diff --git a/linden/indra/llaudio/llaudiodecodemgr.cpp b/linden/indra/llaudio/llaudiodecodemgr.cpp
index afb3c33..a14d4ec 100644
--- a/linden/indra/llaudio/llaudiodecodemgr.cpp
+++ b/linden/indra/llaudio/llaudiodecodemgr.cpp
@@ -33,18 +33,18 @@
 
 #include "llaudiodecodemgr.h"
 
-#include "vorbisdecode.h"
-#include "audioengine.h"
+#include "llvorbisdecode.h"
+#include "llaudioengine.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"
+#include "llvorbisencode.h"
 
 extern LLAudioEngine *gAudiop;
 
@@ -218,11 +218,42 @@ BOOL LLVorbisDecodeState::initDecode()
                 return(FALSE);
         }
         
-        size_t size_guess = (size_t)ov_pcm_total(&mVF, -1);
+        S32 sample_count = ov_pcm_total(&mVF, -1);
+        size_t size_guess = (size_t)sample_count;
         vorbis_info* vi = ov_info(&mVF, -1);
         size_guess *= vi->channels;
         size_guess *= 2;
         size_guess += 2048;
+        
+        bool abort_decode = false;
+        
+        if( vi->channels < 1 || vi->channels > LLVORBIS_CLIP_MAX_CHANNELS )
+        {
+                abort_decode = true;
+                llwarns << "Bad channel count: " << vi->channels << llendl;
+        }
+        
+        if( (size_t)sample_count > LLVORBIS_CLIP_REJECT_SAMPLES )
+        {
+                abort_decode = true;
+                llwarns << "Illegal sample count: " << sample_count << llendl;
+        }
+        
+        if( size_guess > LLVORBIS_CLIP_REJECT_SIZE )
+        {
+                abort_decode = true;
+                llwarns << "Illegal sample size: " << size_guess << llendl;
+        }
+        
+        if( abort_decode )
+        {
+                llwarns << "Canceling initDecode. Bad asset: " << mUUID << llendl;
+                llwarns << "Bad asset encoded by: " << ov_comment(&mVF,-1)->vendor << llendl;
+                delete mInFilep;
+                mInFilep = NULL;
+                return FALSE;
+        }
+        
         mWAVBuffer.reserve(size_guess);
         mWAVBuffer.resize(WAV_HEADER_SIZE);
 
@@ -375,16 +406,16 @@ BOOL LLVorbisDecodeState::finishDecode()
   
                 // write "data" chunk length, in little-endian format
                 S32 data_length = mWAVBuffer.size() - WAV_HEADER_SIZE;
-                mWAVBuffer[40] = (data_length - 8) & 0x000000FF;
-                mWAVBuffer[41] = ((data_length - 8)>> 8) & 0x000000FF;
-                mWAVBuffer[42] = ((data_length - 8)>> 16) & 0x000000FF;
-                mWAVBuffer[43] = ((data_length - 8)>> 24) & 0x000000FF;
-
+                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
-                mWAVBuffer[4] = (data_length + 28) & 0x000000FF;
-                mWAVBuffer[5] = ((data_length + 28) >> 8) & 0x000000FF;
-                mWAVBuffer[6] = ((data_length + 28) >> 16) & 0x000000FF;
-                mWAVBuffer[7] = ((data_length + 28) >> 24) & 0x000000FF;
+                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;
 
                 //
                 // FUDGECAKES!!! Vorbis encode/decode messes up loop point transitions (pop)
@@ -396,8 +427,7 @@ BOOL LLVorbisDecodeState::finishDecode()
                         S32 fade_length;
                         char pcmout[4096];              /*Flawfinder: ignore*/  
 
-                        fade_length = llmin((S32)128,(S32)(data_length)/8);                     
-
+                        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*/
@@ -437,7 +467,7 @@ BOOL LLVorbisDecodeState::finishDecode()
                         }
                 }
 
-                if (0 == data_length)
+                if (36 == data_length)
                 {
                         llwarns << "BAD Vorbis decode in finishDecode!" << llendl;
                         mValid = FALSE;
diff --git a/linden/indra/llaudio/audioengine.cpp b/linden/indra/llaudio/llaudioengine.cpp
index 1900c38..bed791a 100644
--- a/linden/indra/llaudio/audioengine.cpp
+++ b/linden/indra/llaudio/llaudioengine.cpp
@@ -35,7 +35,8 @@
 
 #include "linden_common.h"
 
-#include "audioengine.h"
+#include "llaudioengine.h"
+#include "llstreamingaudio.h"
 
 #include "llerror.h"
 #include "llmath.h"
@@ -47,9 +48,6 @@
 #include "llaudiodecodemgr.h"
 #include "llassetstorage.h"
 
-#include "llmediamanager.h"
-#include "llmediabase.h"
-#include "llmediaimplcommon.h"
 
 // necessary for grabbing sounds from sim (implemented in viewer)       
 extern void request_sound(const LLUUID &sound_guid);
@@ -72,6 +70,15 @@ LLAudioEngine::~LLAudioEngine()
 {
 }
 
+LLStreamingAudioInterface* LLAudioEngine::getStreamingAudioImpl()
+{
+        return mStreamingAudioImpl;
+}
+
+void LLAudioEngine::setStreamingAudioImpl(LLStreamingAudioInterface *impl)
+{
+        mStreamingAudioImpl = impl;
+}
 
 void LLAudioEngine::setDefaults()
 {
@@ -98,13 +105,10 @@ void LLAudioEngine::setDefaults()
         }
 
         mMasterGain = 1.f;
-        mInternetStreamGain = 0.125f;
+        mInternalGain = 0.f;
         mNextWindUpdate = 0.f;
 
-        mInternetStreamMedia = NULL;
-        mInternetStreamURL.clear();
-
-        mStatus = LLMediaBase::STATUS_UNKNOWN;
+        mStreamingAudioImpl = NULL;
 
         for (U32 i = 0; i < LLAudioEngine::AUDIO_TYPE_COUNT; i++)
                 mSecondaryGain[i] = 1.0f;
@@ -168,163 +172,61 @@ void LLAudioEngine::shutdown()
                 delete mBuffers[i];
                 mBuffers[i] = NULL;
         }
-
-        delete mInternetStreamMedia;
-        mInternetStreamMedia = NULL;
-        mInternetStreamURL.clear();
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// virtual (derives from LLMediaBase)
-LLMediaBase::EStatus LLAudioEngine::getStatus()
-{
-        return mStatus;
 }
 
 
 // virtual
 void LLAudioEngine::startInternetStream(const std::string& url)
 {
-        llinfos << "entered startInternetStream()" << llendl;
-
-        if (!mInternetStreamMedia)
-        {
-                LLMediaManager* mgr = LLMediaManager::getInstance();
-                if (mgr)
-                {
-                        mInternetStreamMedia = mgr->createSourceFromMimeType(LLURI(url).scheme(), "audio/mpeg"); // assumes that whatever media implementation supports mp3 also supports vorbis.
-                        llinfos << "mInternetStreamMedia is now " << mInternetStreamMedia << llendl;
-                }
-        }
-
-        if(!mInternetStreamMedia)
-        {
-                return;
-        }
-        // Check for a dead stream from gstreamer, just in case
-        else if(getStatus() == LLMediaBase::STATUS_DEAD)
-        {
-                llinfos << "don't play dead stream urls"<< llendl;
-                mInternetStreamURL.clear();
-                mInternetStreamMedia->addCommand(LLMediaBase::COMMAND_STOP);
-                mInternetStreamMedia->updateMedia();
-                stopInternetStream();
-        }
-        else if (url.empty())
-        {
-                llinfos << "url is emptly. Setting stream to NULL"<< llendl;
-                mInternetStreamURL.clear();
-                mInternetStreamMedia->addCommand(LLMediaBase::COMMAND_STOP);
-                mInternetStreamMedia->updateMedia();
-        }
-        // Stream appears to be good, attempting to play
-        else
-        {
-                // stop any other stream first
-                stopInternetStream();
-
-                llinfos << "Starting internet stream: " << url << llendl;
-                mInternetStreamURL = url;
-                mInternetStreamMedia->navigateTo(url);
-                //llinfos << "Playing....." << llendl;          
-                mInternetStreamMedia->addCommand(LLMediaBase::COMMAND_START);
-                mInternetStreamMedia->updateMedia();
-                mStatus = LLMediaBase::STATUS_STARTED;
-        }
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->start(url);
 }
 
+
 // virtual
 void LLAudioEngine::stopInternetStream()
 {
-        llinfos << "entered stopInternetStream()" << llendl;
-        mInternetStreamURL.clear();
-
-    if(mInternetStreamMedia)
-        {
-                if(!mInternetStreamMedia->addCommand(LLMediaBase::COMMAND_STOP))
-                {
-                        llinfos << "attempting to stop stream failed!" << llendl;
-                }
-                mInternetStreamMedia->updateMedia();
-        }
-
-        mInternetStreamURL.clear();
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->stop();
 }
 
 // virtual
 void LLAudioEngine::pauseInternetStream(int pause)
 {
-        llinfos << "entered pauseInternetStream()" << llendl;
-
-        if(!mInternetStreamMedia)
-                return;
-        
-        if(pause)
-        {
-                if(! mInternetStreamMedia->addCommand(LLMediaBase::COMMAND_PAUSE))
-                {
-                        llinfos << "attempting to pause stream failed!" << llendl;
-                }
-        } else {
-                if(! mInternetStreamMedia->addCommand(LLMediaBase::COMMAND_START))
-                {
-                        llinfos << "attempting to unpause stream failed!" << llendl;
-                }
-        }
-        mInternetStreamMedia->updateMedia();
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->pause(pause);
 }
 
 // virtual
 void LLAudioEngine::updateInternetStream()
 {
-        if (mInternetStreamMedia)
-                mInternetStreamMedia->updateMedia();
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->update();
 }
 
 // virtual
 int LLAudioEngine::isInternetStreamPlaying()
 {
-        if (!mInternetStreamMedia)
-                return 0;
-        
-        if (mInternetStreamMedia->getStatus() == LLMediaBase::STATUS_STARTED)
-        {
-                return 1; // Active and playing
-        }       
-
-        if (mInternetStreamMedia->getStatus() == LLMediaBase::STATUS_PAUSED)
-        {
-                return 2; // paused
-        }
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->isPlaying();
 
         return 0; // Stopped
 }
 
-// virtual
-void LLAudioEngine::getInternetStreamInfo(char* artist, char* title)
-{
-        artist[0] = 0;
-        title[0] = 0;
-}
 
 // virtual
 void LLAudioEngine::setInternetStreamGain(F32 vol)
 {
-        mInternetStreamGain = vol;
-
-        if(!mInternetStreamMedia)
-                return;
-
-        vol = llclamp(vol, 0.f, 1.f);
-        mInternetStreamMedia->setVolume(vol);
-        mInternetStreamMedia->updateMedia();
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->setGain(vol);
 }
 
 // virtual
-const std::string& LLAudioEngine::getInternetStreamURL()
+std::string LLAudioEngine::getInternetStreamURL()
 {
-        return mInternetStreamURL;
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->getURL();
+        else return std::string();
 }
 
 
@@ -335,13 +237,6 @@ void LLAudioEngine::updateChannels()
         {
                 if (mChannels[i])
                 {
-                        // set secondary gain if type is available
-                        LLAudioSource* source = mChannels[i]->getSource();
-                        if (source)
-                        {
-                                mChannels[i]->setSecondaryGain(mSecondaryGain[source->getType()]);
-                        }
-                        
                         mChannels[i]->updateBuffer();
                         mChannels[i]->update3DPosition();
                         mChannels[i]->updateLoop();
@@ -361,15 +256,6 @@ void LLAudioEngine::idle(F32 max_decode_time)
         // 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++)
         {
@@ -398,6 +284,12 @@ void LLAudioEngine::idle(F32 max_decode_time)
                         continue;
                 }
 
+                if (sourcep->isMuted())
+                {
+                        ++iter;
+                        continue;
+                }
+
                 if (!sourcep->getChannel() && sourcep->getCurrentBuffer())
                 {
                         // We could potentially play this sound if its priority is high enough.
@@ -420,7 +312,7 @@ void LLAudioEngine::idle(F32 max_decode_time)
                 LLAudioChannel *channelp = getFreeChannel(max_priority);
                 if (channelp)
                 {
-                        //LL_INFOS("AudioEngine") << "Replacing source in channel due to priority!" << llendl;
+                        //llinfos << "Replacing source in channel due to priority!" << llendl;
                         max_sourcep->setChannel(channelp);
                         channelp->setSource(max_sourcep);
                         if (max_sourcep->isSyncSlave())
@@ -453,9 +345,9 @@ void LLAudioEngine::idle(F32 max_decode_time)
                 // 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)
+                if (!sourcep->mQueuedDatap || sourcep->isMuted())
                 {
-                        // Nothing queued, so we don't care.
+                        // Muted, or nothing queued, so we don't care.
                         continue;
                 }
 
@@ -535,6 +427,10 @@ void LLAudioEngine::idle(F32 max_decode_time)
         for (iter = mAllSources.begin(); iter != mAllSources.end(); ++iter)
         {
                 LLAudioSource *sourcep = iter->second;
+                if (sourcep->isMuted())
+                {
+                        continue;
+                }
                 if (sourcep->isSyncMaster())
                 {
                         if (sourcep->getPriority() > max_sm_priority)
@@ -590,7 +486,7 @@ void LLAudioEngine::idle(F32 max_decode_time)
                 {
                         if (!mBuffers[i]->mInUse && mBuffers[i]->mLastUseTimer.getElapsedTimeF32() > 30.f)
                         {
-                                //LL_INFOS("AudioEngine") << "Flushing unused buffer!" << llendl;
+                                //llinfos << "Flushing unused buffer!" << llendl;
                                 mBuffers[i]->mAudioDatap->mBufferp = NULL;
                                 delete mBuffers[i];
                                 mBuffers[i] = NULL;
@@ -670,7 +566,7 @@ void LLAudioEngine::enableWind(bool enable)
 }
 
 
-LLAudioBuffer *LLAudioEngine::getFreeBuffer()
+LLAudioBuffer * LLAudioEngine::getFreeBuffer()
 {
         static clock_t last_info = 0;
         static bool spamming = FALSE;
@@ -822,15 +718,23 @@ bool LLAudioEngine::isWindEnabled()
 
 void LLAudioEngine::setMuted(bool muted)
 {
-        mMuted = muted;
+        if (muted != mMuted)
+        {
+                mMuted = muted;
+                setMasterGain(mMasterGain);
+        }
         enableWind(!mMuted);
 }
 
-
 void LLAudioEngine::setMasterGain(const F32 gain)
 {
         mMasterGain = gain;
-        setInternalGain(gain);
+        F32 internal_gain = getMuted() ? 0.f : gain;
+        if (internal_gain != mInternalGain)
+        {
+                mInternalGain = internal_gain;
+                setInternalGain(mInternalGain);
+        }
 }
 
 F32 LLAudioEngine::getMasterGain()
@@ -852,7 +756,10 @@ F32 LLAudioEngine::getSecondaryGain(S32 type)
 
 F32 LLAudioEngine::getInternetStreamGain()
 {
-        return mInternetStreamGain;
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->getGain();
+        else
+                return 1.0f;
 }
 
 void LLAudioEngine::setMaxWindGain(F32 gain)
@@ -929,10 +836,9 @@ void LLAudioEngine::triggerSound(const LLUUID &audio_uuid, const LLUUID& owner_i
                                                                  const S32 type, const LLVector3d &pos_global)
 {
         // Create a new source (since this can't be associated with an existing source.
-        //LL_INFOS("AudioEngine") << "Localized: " << audio_uuid << llendl;
+        //llinfos << "Localized: " << audio_uuid << llendl;
 
-        //If we cannot hear it, dont even try to load the sound.
-        if (mMuted || gain == 0.0)
+        if (mMuted)
         {
                 return;
         }
@@ -1020,28 +926,6 @@ F32 LLAudioEngine::getDopplerFactor()
 }
 
 
-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)
@@ -1070,7 +954,7 @@ void LLAudioEngine::commitDeferredChanges()
 }
 
 
-LLAudioSource *LLAudioEngine::findAudioSource(const LLUUID &source_id)
+LLAudioSource * LLAudioEngine::findAudioSource(const LLUUID &source_id)
 {
         source_map::iterator iter;
         iter = mAllSources.find(source_id);
@@ -1086,7 +970,7 @@ LLAudioSource *LLAudioEngine::findAudioSource(const LLUUID &source_id)
 }
 
 
-LLAudioData *LLAudioEngine::getAudioData(const LLUUID &audio_uuid)
+LLAudioData * LLAudioEngine::getAudioData(const LLUUID &audio_uuid)
 {
         data_map::iterator iter;
         iter = mAllData.find(audio_uuid);
@@ -1152,10 +1036,10 @@ bool LLAudioEngine::hasLocalFile(const LLUUID &uuid)
 
 void LLAudioEngine::startNextTransfer()
 {
-        //LL_INFOS("AudioEngine") << "LLAudioEngine::startNextTransfer()" << llendl;
+        //llinfos << "LLAudioEngine::startNextTransfer()" << llendl;
         if (mCurrentTransfer.notNull() || getMuted())
         {
-                //LL_INFOS("AudioEngine") << "Transfer in progress, aborting" << llendl;
+                //llinfos << "Transfer in progress, aborting" << llendl;
                 return;
         }
 
@@ -1336,7 +1220,7 @@ void LLAudioEngine::startNextTransfer()
 
         if (asset_id.notNull())
         {
-                LL_INFOS("AudioEngine") << "Getting asset data for: " << asset_id << llendl;
+                llinfos << "Getting asset data for: " << asset_id << llendl;
                 gAudiop->mCurrentTransfer = asset_id;
                 gAudiop->mCurrentTransferTimer.reset();
                 gAssetStorage->getAssetData(asset_id, LLAssetType::AT_SOUND,
@@ -1344,7 +1228,7 @@ void LLAudioEngine::startNextTransfer()
         }
         else
         {
-                //LL_INFOS("AudioEngine") << "No pending transfers?" << llendl;
+                //llinfos << "No pending transfers?" << llendl;
         }
 }
 
@@ -1354,7 +1238,7 @@ void LLAudioEngine::assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::E
 {
         if (result_code)
         {
-                LL_INFOS("AudioEngine") << "Boom, error in audio file transfer: " << LLAssetStorage::getErrorString( result_code ) << " (" << result_code << ")" << llendl;
+                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)
@@ -1394,13 +1278,14 @@ LLAudioSource::LLAudioSource(const LLUUID& id, const LLUUID& owner_id, const F32
         mOwnerID(owner_id),
         mPriority(0.f),
         mGain(gain),
-        mType(type),
+        mSourceMuted(false),
         mAmbient(false),
         mLoop(false),
         mSyncMaster(false),
         mSyncSlave(false),
         mQueueSounds(false),
         mPlayedOnce(false),
+        mType(type),
         mChannelp(NULL),
         mCurrentDatap(NULL),
         mQueuedDatap(NULL)
@@ -1452,6 +1337,10 @@ void LLAudioSource::updatePriority()
         {
                 mPriority = 1.f;
         }
+        else if (isMuted())
+        {
+                mPriority = 0.f;
+        }
         else
         {
                 // Priority is based on distance
@@ -1500,25 +1389,33 @@ bool LLAudioSource::setupChannel()
 
 bool LLAudioSource::play(const LLUUID &audio_uuid)
 {
+        // Special abuse of play(); don't play a sound, but kill it.
         if (audio_uuid.isNull())
         {
                 if (getChannel())
                 {
                         getChannel()->setSource(NULL);
                         setChannel(NULL);
-                        addAudioData(NULL, true);
+                        if (!isMuted())
+                        {
+                                mCurrentDatap = NULL;
+                        }
                 }
+                return false;
         }
+
         // Reset our age timeout if someone attempts to play the source.
         mAgeTimer.reset();
 
         LLAudioData *adp = gAudiop->getAudioData(audio_uuid);
-
-        bool has_buffer = gAudiop->updateBufferForData(adp, audio_uuid);
-
-
         addAudioData(adp);
 
+        if (isMuted())
+        {
+                return false;
+        }
+
+        bool has_buffer = gAudiop->updateBufferForData(adp, audio_uuid);
         if (!has_buffer)
         {
                 // Don't bother trying to set up a channel or anything, we don't have an audio buffer.
@@ -1543,10 +1440,11 @@ bool LLAudioSource::play(const LLUUID &audio_uuid)
 }
 
 
-bool LLAudioSource::isDone()
+bool LLAudioSource::isDone() const
 {
         const F32 MAX_AGE = 60.f;
         const F32 MAX_UNPLAYED_AGE = 15.f;
+        const F32 MAX_MUTED_AGE = 11.f;
 
         if (isLoop())
         {
@@ -1554,7 +1452,6 @@ bool LLAudioSource::isDone()
                 return false;
         }
 
-
         if (hasPendingPreloads())
         {
                 return false;
@@ -1571,10 +1468,10 @@ bool LLAudioSource::isDone()
         // This is a single-play source
         if (!mChannelp)
         {
-                if ((elapsed > MAX_UNPLAYED_AGE) || mPlayedOnce)
+                if ((elapsed > (mSourceMuted ? MAX_MUTED_AGE : 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.
+                        // over 15 seconds since we tried to play it.  Don't bother.
                         //llinfos << "No channel assigned, source is done" << llendl;
                         return true;
                 }
@@ -1600,7 +1497,7 @@ bool LLAudioSource::isDone()
 
         if ((elapsed > MAX_UNPLAYED_AGE) || mPlayedOnce)
         {
-                // The sound isn't playing back after 5 seconds or we're already done playing it, kill it.
+                // The sound isn't playing back after 15 seconds or we're already done playing it, kill it.
                 return true;
         }
 
@@ -1696,17 +1593,17 @@ bool LLAudioSource::hasPendingPreloads() const
 }
 
 
-LLAudioData *LLAudioSource::getCurrentData()
+LLAudioData * LLAudioSource::getCurrentData()
 {
         return mCurrentDatap;
 }
 
-LLAudioData *LLAudioSource::getQueuedData()
+LLAudioData * LLAudioSource::getQueuedData()
 {
         return mQueuedDatap;
 }
 
-LLAudioBuffer *LLAudioSource::getCurrentBuffer()
+LLAudioBuffer * LLAudioSource::getCurrentBuffer()
 {
         if (!mCurrentDatap)
         {
@@ -1737,7 +1634,7 @@ LLAudioChannel::LLAudioChannel() :
 LLAudioChannel::~LLAudioChannel()
 {
         // Need to disconnect any sources which are using this channel.
-        //LL_INFOS("AudioEngine") << "Cleaning up audio channel" << llendl;
+        //llinfos << "Cleaning up audio channel" << llendl;
         if (mCurrentSourcep)
         {
                 mCurrentSourcep->setChannel(NULL);
@@ -1748,12 +1645,12 @@ LLAudioChannel::~LLAudioChannel()
 
 void LLAudioChannel::setSource(LLAudioSource *sourcep)
 {
-        //LL_INFOS("AudioEngine") << this << ": setSource(" << sourcep << ")" << llendl;
+        //llinfos << this << ": setSource(" << sourcep << ")" << llendl;
 
         if (!sourcep)
         {
                 // Clearing the source for this channel, don't need to do anything.
-                //LL_INFOS("AudioEngine") << "Clearing source for channel" << llendl;
+                //llinfos << "Clearing source for channel" << llendl;
                 cleanup();
                 mCurrentSourcep = NULL;
                 mWaiting = false;
@@ -1763,7 +1660,7 @@ void LLAudioChannel::setSource(LLAudioSource *sourcep)
         if (sourcep == mCurrentSourcep)
         {
                 // Don't reallocate the channel, this will make FMOD goofy.
-                //LL_INFOS("AudioEngine") << "Calling setSource with same source!" << llendl;
+                //llinfos << "Calling setSource with same source!" << llendl;
         }
 
         mCurrentSourcep = sourcep;
diff --git a/linden/indra/llaudio/audioengine.h b/linden/indra/llaudio/llaudioengine.h
index e46091c..a1b240e 100644
--- a/linden/indra/llaudio/audioengine.h
+++ b/linden/indra/llaudio/llaudioengine.h
@@ -37,18 +37,14 @@
 #include <list>
 #include <map>
 
-#include "listener.h"
 #include "v3math.h"
 #include "v3dmath.h"
-#include "listener.h"
 #include "lltimer.h"
 #include "lluuid.h"
 #include "llframetimer.h"
 #include "llassettype.h"
 
-#include "llmediabase.h"
-
-class LLMediaBase;
+#include "lllistener.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
@@ -75,7 +71,7 @@ class LLAudioData;
 class LLAudioChannel;
 class LLAudioChannelOpenAL;
 class LLAudioBuffer;
-
+class LLStreamingAudioInterface;
 
 
 //
@@ -121,9 +117,11 @@ public:
         // 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; }
-
+        void setMuted(bool muted);
+        bool getMuted() const { return mMuted; }
+#ifdef USE_PLUGIN_MEDIA
+        LLPluginClassMedia* initializeMedia(const std::string& media_type);
+#endif
         F32 getMasterGain();
         void setMasterGain(F32 gain);
 
@@ -134,8 +132,6 @@ public:
 
         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);
@@ -154,19 +150,19 @@ public:
         LLAudioSource *findAudioSource(const LLUUID &source_id);
         LLAudioData *getAudioData(const LLUUID &audio_uuid);
 
-
-        // Internet stream methods
-        virtual void startInternetStream(const std::string& url);
-        virtual void stopInternetStream();
-        virtual void pauseInternetStream(int pause);
-        virtual void updateInternetStream();
-        virtual int isInternetStreamPlaying();
-        virtual void getInternetStreamInfo(char* artist, char* title);
+        // Internet stream implementation manipulation
+        LLStreamingAudioInterface *getStreamingAudioImpl();
+        void setStreamingAudioImpl(LLStreamingAudioInterface *impl);
+        // Internet stream methods - these will call down into the *mStreamingAudioImpl if it exists
+        void startInternetStream(const std::string& url);
+        void stopInternetStream();
+        void pauseInternetStream(int pause);
+        void updateInternetStream(); // expected to be called often
+        int isInternetStreamPlaying();
         // use a value from 0.0 to 1.0, inclusive
-        virtual void setInternetStreamGain(F32 vol);
-        virtual const std::string& getInternetStreamURL();
-        virtual LLMediaBase::EStatus getStatus();
-
+        void setInternetStreamGain(F32 vol);
+        std::string getInternetStreamURL();
+        
         // For debugging usage
         virtual LLVector3 getListenerPos();
 
@@ -185,8 +181,6 @@ public:
         static void assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status);
 
         friend class LLPipeline; // For debugging
-
-        LLMediaBase * getStreamMedia() { return mInternetStreamMedia; }
 public:
         F32 mMaxWindGain; // Hack.  Public to set before fade in?
 
@@ -244,21 +238,16 @@ protected:
         LLAudioBuffer *mBuffers[MAX_BUFFERS];
         
         F32 mMasterGain;
+        F32 mInternalGain;                      // Actual gain set; either mMasterGain or 0 when mMuted is true.
         F32 mSecondaryGain[AUDIO_TYPE_COUNT];
 
-        // Hack!  Internet streams are treated differently from other sources!
-        F32 mInternetStreamGain;
-        std::string mInternetStreamURL;
-
         F32 mNextWindUpdate;
 
         LLFrameTimer mWindUpdateTimer;
 
-        LLMediaBase::EStatus mStatus;
-
 private:
         void setDefaults();
-        LLMediaBase *mInternetStreamMedia;
+        LLStreamingAudioInterface *mStreamingAudioImpl;
 };
 
 
@@ -314,7 +303,8 @@ public:
         virtual void setGain(const F32 gain)                                                    { mGain = llclamp(gain, 0.f, 1.f); }
 
         const LLUUID &getID() const             { return mID; }
-        bool isDone();
+        bool isDone() const;
+        bool isMuted() const { return mSourceMuted; }
 
         LLAudioData *getCurrentData();
         LLAudioData *getQueuedData();
@@ -336,6 +326,7 @@ protected:
         LLUUID                  mOwnerID;       // owner of the object playing the sound
         F32                             mPriority;
         F32                             mGain;
+        bool                    mSourceMuted;
         bool                    mAmbient;
         bool                    mLoop;
         bool                    mSyncMaster;
diff --git a/linden/indra/llaudio/audioengine_fmod.cpp b/linden/indra/llaudio/llaudioengine_fmod.cpp
index 938c2aa..85ae863 100644
--- a/linden/indra/llaudio/audioengine_fmod.cpp
+++ b/linden/indra/llaudio/llaudioengine_fmod.cpp
@@ -32,8 +32,11 @@
 
 #include "linden_common.h"
 
-#include "audioengine_fmod.h"
-#include "listener_fmod.h"
+#include "llstreamingaudio.h"
+#include "llstreamingaudio_fmod.h"
+
+#include "llaudioengine_fmod.h"
+#include "lllistener_fmod.h"
 
 #include "llerror.h"
 #include "llmath.h"
@@ -46,6 +49,7 @@
 
 #include "sound_ids.h"
 
+
 extern "C" {
         void * F_CALLBACKAPI windCallback(void *originalbuffer, void *newbuffer, int length, void* userdata);
 }
@@ -53,35 +57,9 @@ extern "C" {
 FSOUND_DSPUNIT *gWindDSP = NULL;
 
 
-// Safe strcpy
-#if 0 //(unused)  //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;
         mWindGen = NULL;
 }
 
@@ -93,8 +71,6 @@ 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.
@@ -241,7 +217,9 @@ bool LLAudioEngine_FMOD::init(const S32 num_channels, void* userdata)
         
 #endif
 
-        initInternetStream();
+        // set up our favourite FMOD-native streaming audio implementation if none has already been added
+        if (!getStreamingAudioImpl()) // no existing implementation added
+                setStreamingAudioImpl(new LLStreamingAudio_FMOD());
 
         LL_DEBUGS("AppInit") << "LLAudioEngine_FMOD::init() FMOD initialized correctly" << LL_ENDL;
 
@@ -296,13 +274,13 @@ void LLAudioEngine_FMOD::shutdown()
 }
 
 
-LLAudioBuffer *LLAudioEngine_FMOD::createBuffer()
+LLAudioBuffer * LLAudioEngine_FMOD::createBuffer()
 {
         return new LLAudioBufferFMOD();
 }
 
 
-LLAudioChannel *LLAudioEngine_FMOD::createChannel()
+LLAudioChannel * LLAudioEngine_FMOD::createChannel()
 {
         return new LLAudioChannelFMOD();
 }
@@ -432,10 +410,12 @@ void LLAudioEngine_FMOD::setInternalGain(F32 gain)
         gain = llclamp( gain, 0.0f, 1.0f );
         FSOUND_SetSFXMasterVolume( llround( 255.0f * gain ) );
 
-        if ( mInternetStreamChannel != -1 )
+        LLStreamingAudioInterface *saimpl = getStreamingAudioImpl();
+        if ( saimpl )
         {
-                F32 clamp_internet_stream_gain = llclamp( mInternetStreamGain, 0.0f, 1.0f );
-                FSOUND_SetVolumeAbsolute( mInternetStreamChannel, llround( 255.0f * clamp_internet_stream_gain ) );
+                // fmod likes its streaming audio channel gain re-asserted after
+                // master volume change.
+                saimpl->setGain(saimpl->getGain());
         }
 }
 
@@ -660,7 +640,7 @@ bool LLAudioBufferFMOD::loadWAV(const std::string& filename)
                 return false;
         }
 
-        if (!LLAPRFile::isExist(filename, NULL, LL_APR_RPB))
+        if (!LLAPRFile::isExist(filename, LL_APR_RPB))
         {
                 // File not found, abort.
                 return false;
@@ -752,313 +732,6 @@ void LLAudioBufferFMOD::set3DMode(bool use3d)
 }
 
 
-
-//---------------------------------------------------------------------------
-// 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.clear();
-}
-
-
-void LLAudioEngine_FMOD::startInternetStream(const std::string& 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.empty())
-        {
-                llinfos << "Starting internet stream: " << url << llendl;
-                mCurrentInternetStreamp = new LLAudioStreamFMOD(url);
-                mInternetStreamURL = url;
-        }
-        else
-        {
-                llinfos << "Set internet stream to null" << llendl;
-                mInternetStreamURL.clear();
-        }
-}
-
-
-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.clear();
-        }
-}
-
-void LLAudioEngine_FMOD::pauseInternetStream(int pause)
-{
-        if (pause < 0)
-        {
-                pause = mCurrentInternetStreamp ? 1 : 0;
-        }
-
-        if (pause)
-        {
-                if (mCurrentInternetStreamp)
-                {
-                        stopInternetStream();
-                }
-        }
-        else
-        {
-                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.empty())
-        {
-                return 2; // "Paused"
-        }
-        else
-        {
-                return 0;
-        }
-}
-
-
-void LLAudioEngine_FMOD::setInternetStreamGain(F32 vol)
-{
-        mInternetStreamGain = vol;
-
-        if (mInternetStreamChannel != -1)
-        {
-                vol = llclamp(vol, 0.f, 1.f);
-                int vol_int = llround(vol * 255.f);
-                FSOUND_SetVolumeAbsolute(mInternetStreamChannel, vol_int);
-        }
-}
-
-
-LLAudioStreamFMOD::LLAudioStreamFMOD(const std::string& url) :
-        mInternetStream(NULL),
-        mReady(false)
-{
-        mInternetStreamURL = url;
-        mInternetStream = FSOUND_Stream_Open(url.c_str(), 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;
-}
-
 void * F_CALLBACKAPI windCallback(void *originalbuffer, void *newbuffer, int length, void* userdata)
 {
         // originalbuffer = fmod's original mixbuffer.
diff --git a/linden/indra/llaudio/audioengine_fmod.h b/linden/indra/llaudio/llaudioengine_fmod.h
index d0d2e1b..3968657 100644
--- a/linden/indra/llaudio/audioengine_fmod.h
+++ b/linden/indra/llaudio/llaudioengine_fmod.h
@@ -34,13 +34,13 @@
 #ifndef LL_AUDIOENGINE_FMOD_H
 #define LL_AUDIOENGINE_FMOD_H
 
-#include "audioengine.h"
-#include "listener_fmod.h"
-#include "windgen.h"
+#include "llaudioengine.h"
+#include "lllistener_fmod.h"
+#include "llwindgen.h"
 
 #include "fmod.h"
 
-class LLAudioStreamFMOD;
+class LLAudioStreamManagerFMOD;
 
 class LLAudioEngine_FMOD : public LLAudioEngine 
 {
@@ -50,20 +50,11 @@ public:
 
         // initialization/startup/shutdown
         virtual bool init(const S32 num_channels, void *user_data);
-        virtual std::string getDriverName(bool verbose);
+        virtual std::string getDriverName(bool verbose);
         virtual void allocateListener();
 
         virtual void shutdown();
 
-        // Internet stream methods
-        virtual void initInternetStream();
-        virtual void startInternetStream(const std::string& url);
-        virtual void updateInternetStream();
-        virtual void stopInternetStream();
-        virtual void pauseInternetStream(int pause);
-        virtual int isInternetStreamPlaying();
-        virtual void setInternetStreamGain(F32 vol);
-
         /*virtual*/ void initWind();
         /*virtual*/ void cleanupWind();
 
@@ -83,15 +74,9 @@ protected:
 protected:
         static signed char F_CALLBACKAPI callbackMetaData(char* name, char* value, void* userdata);
 
-        LLAudioStreamFMOD *mCurrentInternetStreamp;
-        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.
@@ -140,22 +125,5 @@ protected:
         FSOUND_SAMPLE *mSamplep;
 };
 
-class LLAudioStreamFMOD
-{
-public:
-        LLAudioStreamFMOD(const std::string& url);
-        int     startStream();
-        bool stopStream(); // Returns true if the stream was successfully stopped.
-        bool ready();
-
-        const std::string& getURL()     { return mInternetStreamURL; }
-
-        int getOpenState();
-protected:
-        FSOUND_STREAM* mInternetStream;
-        bool mReady;
-
-        std::string mInternetStreamURL;
-};
 
 #endif // LL_AUDIOENGINE_FMOD_H
diff --git a/linden/indra/llaudio/audioengine_openal.cpp b/linden/indra/llaudio/llaudioengine_openal.cpp
index 84305f0..93bc42b 100644
--- a/linden/indra/llaudio/audioengine_openal.cpp
+++ b/linden/indra/llaudio/llaudioengine_openal.cpp
@@ -34,10 +34,12 @@
 #include "linden_common.h"
 #include "lldir.h"
 
-#include "audioengine_openal.h"
-#include "listener_openal.h"
+#include "llaudioengine_openal.h"
+#include "lllistener_openal.h"
 
 
+static const float WIND_BUFFER_SIZE_SEC = 0.05f; // 1/20th sec
+
 LLAudioEngine_OpenAL::LLAudioEngine_OpenAL()
         :
         mWindGen(NULL),
@@ -55,41 +57,15 @@ LLAudioEngine_OpenAL::~LLAudioEngine_OpenAL()
 {
 }
 
-static ALboolean alutInitHelp(const char **errorstring)
-{
-        ALboolean result = AL_FALSE;
-        ALenum err = AL_NO_ERROR;
-#if LL_WINDOWS
-        __try {
-                result = alutInit(NULL, NULL);
-                err = alutGetError();
-                alGetError(); // hit loading of wrap_oal.dll
-                if(!result) *errorstring = alutGetErrorString(err);
-        } __except( EXCEPTION_EXECUTE_HANDLER ) {
-                *errorstring = "[Exception]";
-                result = AL_FALSE;
-        }
-        return result;
-#else
-        result = alutInit(NULL, NULL);
-        if(!result) {
-                err = alutGetError();
-                *errorstring = alutGetErrorString(err);
-        }
-        return result;
-#endif
-}
-
 // virtual
 bool LLAudioEngine_OpenAL::init(const S32 num_channels, void* userdata)
 {
-        const char *errorstring = "(null)";
         mWindGen = NULL;
         LLAudioEngine::init(num_channels, userdata);
 
-        if(!alutInitHelp(&errorstring))
+        if(!alutInit(NULL, NULL))
         {
-                llwarns << "LLAudioEngine_OpenAL::init() ALUT initialization failed: " << errorstring << llendl;
+                llwarns << "LLAudioEngine_OpenAL::init() ALUT initialization failed: " << alutGetErrorString (alutGetError ()) << llendl;
                 return false;
         }
 
@@ -287,8 +263,6 @@ bool LLAudioChannelOpenAL::updateBuffer()
                           mCurrentSourcep->isLoop() ? AL_TRUE : AL_FALSE);
                 alSourcef(mALSource, AL_ROLLOFF_FACTOR,
                           gAudiop->mListenerp->getRolloffFactor());
-                alSourcef(mALSource, AL_REFERENCE_DISTANCE,
-                          gAudiop->mListenerp->getDistanceFactor());
         }
 
         return true;
@@ -417,7 +391,7 @@ void LLAudioEngine_OpenAL::initWind()
         mWindGen = new LLWindGen<WIND_SAMPLE_T>;
 
         mWindBufFreq = mWindGen->getInputSamplingRate();
-        mWindBufSamples = llceil(mWindBufFreq * 0.05f); // 1/20th sec - WIND_BUFFER_SIZE_SEC
+        mWindBufSamples = llceil(mWindBufFreq * WIND_BUFFER_SIZE_SEC);
         mWindBufBytes = mWindBufSamples * 2 /*stereo*/ * sizeof(WIND_SAMPLE_T);
 
         mWindBuf = new WIND_SAMPLE_T [mWindBufSamples * 2 /*stereo*/];
diff --git a/linden/indra/llaudio/audioengine_openal.h b/linden/indra/llaudio/llaudioengine_openal.h
index 8c8bfd9..900bcb3 100644
--- a/linden/indra/llaudio/audioengine_openal.h
+++ b/linden/indra/llaudio/llaudioengine_openal.h
@@ -36,10 +36,9 @@
 #ifndef LL_AUDIOENGINE_OPENAL_H
 #define LL_AUDIOENGINE_OPENAL_H
 
-#include "audioengine.h"
-#include "listener_openal.h"
-#include "windgen.h"
-
+#include "llaudioengine.h"
+#include "lllistener_openal.h"
+#include "llwindgen.h"
 
 class LLAudioEngine_OpenAL : public LLAudioEngine
 {
diff --git a/linden/indra/llaudio/lllistener.cpp b/linden/indra/llaudio/lllistener.cpp
new file mode 100644
index 0000000..846c6bc
--- /dev/null
+++ b/linden/indra/llaudio/lllistener.cpp
@@ -0,0 +1,142 @@
+/** 
+ * @file listener.cpp
+ * @brief Implementation of LISTENER class abstracting the audio support
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "lllistener.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::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::setRolloffFactor(F32 factor)
+{
+}
+
+//-----------------------------------------------------------------------
+F32 LLListener::getRolloffFactor()
+{
+        return (1.f);
+}
+
+//-----------------------------------------------------------------------
+void LLListener::commitDeferredChanges()
+{
+}
+
diff --git a/linden/indra/llaudio/lllistener.h b/linden/indra/llaudio/lllistener.h
new file mode 100644
index 0000000..e94fbe8
--- /dev/null
+++ b/linden/indra/llaudio/lllistener.h
@@ -0,0 +1,78 @@
+/** 
+ * @file listener.h
+ * @brief Description of LISTENER base class abstracting the audio support.
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LISTENER_H
+#define LL_LISTENER_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 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 setRolloffFactor(F32 factor);
+
+        virtual LLVector3 getPosition();
+        virtual LLVector3 getAt();
+        virtual LLVector3 getUp();
+
+        virtual F32 getDopplerFactor();
+        virtual F32 getRolloffFactor();
+
+        virtual void commitDeferredChanges();
+};
+
+#endif
+
diff --git a/linden/indra/llaudio/lllistener_ds3d.h b/linden/indra/llaudio/lllistener_ds3d.h
new file mode 100644
index 0000000..1ff9c17
--- /dev/null
+++ b/linden/indra/llaudio/lllistener_ds3d.h
@@ -0,0 +1,74 @@
+/** 
+ * @file listener_ds3d.h
+ * @brief Description of LISTENER class abstracting the audio support
+ * as a DirectSound 3D implementation (windows only)
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LISTENER_DS3D_H
+#define LL_LISTENER_DS3D_H
+
+#include "lllistener.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 setRolloffFactor(F32 factor);
+        virtual F32 getRolloffFactor();
+
+        virtual void commitDeferredChanges();
+};
+
+#endif
+
+
diff --git a/linden/indra/llaudio/lllistener_fmod.cpp b/linden/indra/llaudio/lllistener_fmod.cpp
new file mode 100644
index 0000000..57ad461
--- /dev/null
+++ b/linden/indra/llaudio/lllistener_fmod.cpp
@@ -0,0 +1,131 @@
+/** 
+ * @file listener_fmod.cpp
+ * @brief implementation of LISTENER class abstracting the audio
+ * support as a FMOD 3D implementation (windows only)
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llaudioengine.h"
+#include "lllistener_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;
+        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;
+}
+
+
diff --git a/linden/indra/llaudio/lllistener_fmod.h b/linden/indra/llaudio/lllistener_fmod.h
new file mode 100644
index 0000000..5a48ec8
--- /dev/null
+++ b/linden/indra/llaudio/lllistener_fmod.h
@@ -0,0 +1,64 @@
+/** 
+ * @file listener_fmod.h
+ * @brief Description of LISTENER class abstracting the audio support
+ * as an FMOD 3D implementation (windows and Linux)
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LISTENER_FMOD_H
+#define LL_LISTENER_FMOD_H
+
+#include "lllistener.h"
+
+class LLListener_FMOD : public LLListener
+{
+ 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 setRolloffFactor(F32 factor);
+        virtual F32 getRolloffFactor();
+
+ protected:
+         F32 mDopplerFactor;
+         F32 mRolloffFactor;
+};
+
+#endif
+
+
diff --git a/linden/indra/llaudio/listener_openal.cpp b/linden/indra/llaudio/lllistener_openal.cpp
index d0ef9b2..a96ebd5 100644
--- a/linden/indra/llaudio/listener_openal.cpp
+++ b/linden/indra/llaudio/lllistener_openal.cpp
@@ -32,9 +32,9 @@
  */
 
 #include "linden_common.h"
-#include "audioengine.h"
+#include "llaudioengine.h"
 
-#include "listener_openal.h"
+#include "lllistener_openal.h"
 
 LLListener_OpenAL::LLListener_OpenAL()
 {
@@ -114,12 +114,3 @@ F32 LLListener_OpenAL::getRolloffFactor()
 }
 
 
-void LLListener_OpenAL::setDistanceFactor(F32 factor)
-{
-        mDistanceFactor = factor;
-}
-
-F32 LLListener_OpenAL::getDistanceFactor()
-{
-        return mDistanceFactor;
-}
diff --git a/linden/indra/llaudio/listener_openal.h b/linden/indra/llaudio/lllistener_openal.h
index 2b79ada..0dfeea5 100644
--- a/linden/indra/llaudio/listener_openal.h
+++ b/linden/indra/llaudio/lllistener_openal.h
@@ -34,10 +34,9 @@
 #ifndef LL_LISTENER_OPENAL_H
 #define LL_LISTENER_OPENAL_H
 
-#include "listener.h"
+#include "lllistener.h"
 
-
-//#include "AL/al.h"
+#include "AL/al.h"
 #include "AL/alut.h"
 
 class LLListener_OpenAL  : public LLListener
@@ -54,13 +53,10 @@ class LLListener_OpenAL  : public LLListener
 
         virtual void setDopplerFactor(F32 factor);
         virtual F32 getDopplerFactor();
-        virtual void setDistanceFactor(F32 factor);
-        virtual F32 getDistanceFactor();
         virtual void setRolloffFactor(F32 factor);
         virtual F32 getRolloffFactor();
 
  protected:
-        F32 mDistanceFactor;
         F32 mRolloffFactor;
 };
 
diff --git a/linden/indra/llaudio/llstreamingaudio.h b/linden/indra/llaudio/llstreamingaudio.h
new file mode 100644
index 0000000..aa89e6a
--- /dev/null
+++ b/linden/indra/llaudio/llstreamingaudio.h
@@ -0,0 +1,56 @@
+/** 
+ * @file streamingaudio.h
+ * @author Tofu Linden
+ * @brief Definition of LLStreamingAudioInterface base class abstracting the streaming audio interface
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_STREAMINGAUDIO_H
+#define LL_STREAMINGAUDIO_H
+
+#include "stdtypes.h" // from llcommon
+
+// Entirely abstract.  Based exactly on the historic API.
+class LLStreamingAudioInterface
+{
+ public:
+        virtual ~LLStreamingAudioInterface() {}
+
+        virtual void start(const std::string& url) = 0;
+        virtual void stop() = 0;
+        virtual void pause(int pause) = 0;
+        virtual void update() = 0;
+        virtual int isPlaying() = 0;
+        // use a value from 0.0 to 1.0, inclusive
+        virtual void setGain(F32 vol) = 0;
+        virtual F32 getGain() = 0;
+        virtual std::string getURL() = 0;
+};
+
+#endif // LL_STREAMINGAUDIO_H
diff --git a/linden/indra/llaudio/llstreamingaudio_fmod.cpp b/linden/indra/llaudio/llstreamingaudio_fmod.cpp
new file mode 100644
index 0000000..a71a872
--- /dev/null
+++ b/linden/indra/llaudio/llstreamingaudio_fmod.cpp
@@ -0,0 +1,362 @@
+/** 
+ * @file streamingaudio_fmod.cpp
+ * @brief LLStreamingAudio_FMOD implementation
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llmath.h"
+
+#include "fmod.h"
+#include "fmod_errors.h"
+
+#include "llstreamingaudio_fmod.h"
+
+
+class LLAudioStreamManagerFMOD
+{
+public:
+        LLAudioStreamManagerFMOD(const std::string& url);
+        int     startStream();
+        bool stopStream(); // Returns true if the stream was successfully stopped.
+        bool ready();
+
+        const std::string& getURL()     { return mInternetStreamURL; }
+
+        int getOpenState();
+protected:
+        FSOUND_STREAM* mInternetStream;
+        bool mReady;
+
+        std::string mInternetStreamURL;
+};
+
+
+
+//---------------------------------------------------------------------------
+// Internet Streaming
+//---------------------------------------------------------------------------
+LLStreamingAudio_FMOD::LLStreamingAudio_FMOD() :
+        mCurrentInternetStreamp(NULL),
+        mFMODInternetStreamChannel(-1),
+        mGain(1.0f)
+{
+        // 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);
+}
+
+
+LLStreamingAudio_FMOD::~LLStreamingAudio_FMOD()
+{
+        // nothing interesting/safe to do.
+}
+
+
+void LLStreamingAudio_FMOD::start(const std::string& url)
+{
+        //if (!mInited)
+        //{
+        //      llwarns << "startInternetStream before audio initialized" << llendl;
+        //      return;
+        //}
+
+        // "stop" stream but don't clear url, etc. in case url == mInternetStreamURL
+        stop();
+
+        if (!url.empty())
+        {
+                llinfos << "Starting internet stream: " << url << llendl;
+                mCurrentInternetStreamp = new LLAudioStreamManagerFMOD(url);
+                mURL = url;
+        }
+        else
+        {
+                llinfos << "Set internet stream to null" << llendl;
+                mURL.clear();
+        }
+}
+
+
+void LLStreamingAudio_FMOD::update()
+{
+        // Kill dead internet streams, if possible
+        std::list<LLAudioStreamManagerFMOD *>::iterator iter;
+        for (iter = mDeadStreams.begin(); iter != mDeadStreams.end();)
+        {
+                LLAudioStreamManagerFMOD *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 (mFMODInternetStreamChannel < 0)
+                {
+                        mFMODInternetStreamChannel = mCurrentInternetStreamp->startStream();
+
+                        if (mFMODInternetStreamChannel != -1)
+                        {
+                                // Reset volume to previously set volume
+                                setGain(getGain());
+                                FSOUND_SetPaused(mFMODInternetStreamChannel, false);
+                        }
+                }
+        }
+                
+        switch(open_state)
+        {
+        default:
+        case 0:
+                // success
+                break;
+        case -1:
+                // stream handle is invalid
+                llwarns << "InternetStream - invalid handle" << llendl;
+                stop();
+                return;
+        case -2:
+                // opening
+                break;
+        case -3:
+                // failed to open, file not found, perhaps
+                llwarns << "InternetSteam - failed to open" << llendl;
+                stop();
+                return;
+        case -4:
+                // connecting
+                break;
+        case -5:
+                // buffering
+                break;
+        }
+
+}
+
+void LLStreamingAudio_FMOD::stop()
+{
+        if (mFMODInternetStreamChannel != -1)
+        {
+                FSOUND_SetPaused(mFMODInternetStreamChannel, true);
+                FSOUND_SetPriority(mFMODInternetStreamChannel, 0);
+                mFMODInternetStreamChannel = -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;
+                //mURL.clear();
+        }
+}
+
+void LLStreamingAudio_FMOD::pause(int pauseopt)
+{
+        if (pauseopt < 0)
+        {
+                pauseopt = mCurrentInternetStreamp ? 1 : 0;
+        }
+
+        if (pauseopt)
+        {
+                if (mCurrentInternetStreamp)
+                {
+                        stop();
+                }
+        }
+        else
+        {
+                start(getURL());
+        }
+}
+
+
+// A stream is "playing" if it has been requested to start.  That
+// doesn't necessarily mean audio is coming out of the speakers.
+int LLStreamingAudio_FMOD::isPlaying()
+{
+        if (mCurrentInternetStreamp)
+        {
+                return 1; // Active and playing
+        }
+        else if (!mURL.empty())
+        {
+                return 2; // "Paused"
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+
+F32 LLStreamingAudio_FMOD::getGain()
+{
+        return mGain;
+}
+
+
+std::string LLStreamingAudio_FMOD::getURL()
+{
+        return mURL;
+}
+
+
+void LLStreamingAudio_FMOD::setGain(F32 vol)
+{
+        mGain = vol;
+
+        if (mFMODInternetStreamChannel != -1)
+        {
+                vol = llclamp(vol, 0.f, 1.f);
+                int vol_int = llround(vol * 255.f);
+                FSOUND_SetVolumeAbsolute(mFMODInternetStreamChannel, vol_int);
+        }
+}
+
+
+///////////////////////////////////////////////////////
+// manager of possibly-multiple internet audio streams
+
+LLAudioStreamManagerFMOD::LLAudioStreamManagerFMOD(const std::string& url) :
+        mInternetStream(NULL),
+        mReady(false)
+{
+        mInternetStreamURL = url;
+        mInternetStream = FSOUND_Stream_Open(url.c_str(), 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 LLAudioStreamManagerFMOD::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 LLAudioStreamManagerFMOD::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 LLAudioStreamManagerFMOD::getOpenState()
+{
+        int open_state = FSOUND_Stream_GetOpenState(mInternetStream);
+        return open_state;
+}
diff --git a/linden/indra/llaudio/llstreamingaudio_fmod.h b/linden/indra/llaudio/llstreamingaudio_fmod.h
new file mode 100644
index 0000000..968ab53
--- /dev/null
+++ b/linden/indra/llaudio/llstreamingaudio_fmod.h
@@ -0,0 +1,68 @@
+/** 
+ * @file streamingaudio_fmod.h
+ * @author Tofu Linden
+ * @brief Definition of LLStreamingAudio_FMOD implementation
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_STREAMINGAUDIO_FMOD_H
+#define LL_STREAMINGAUDIO_FMOD_H
+
+#include "stdtypes.h" // from llcommon
+
+#include "llstreamingaudio.h"
+
+class LLAudioStreamManagerFMOD;
+
+class LLStreamingAudio_FMOD : public LLStreamingAudioInterface
+{
+ public:
+        LLStreamingAudio_FMOD();
+        /*virtual*/ ~LLStreamingAudio_FMOD();
+
+        /*virtual*/ void start(const std::string& url);
+        /*virtual*/ void stop();
+        /*virtual*/ void pause(int pause);
+        /*virtual*/ void update();
+        /*virtual*/ int isPlaying();
+        /*virtual*/ void setGain(F32 vol);
+        /*virtual*/ F32 getGain();
+        /*virtual*/ std::string getURL();
+
+private:
+        LLAudioStreamManagerFMOD *mCurrentInternetStreamp;
+        int mFMODInternetStreamChannel;
+        std::list<LLAudioStreamManagerFMOD *> mDeadStreams;
+
+        std::string mURL;
+        F32 mGain;
+};
+
+
+#endif // LL_STREAMINGAUDIO_FMOD_H
diff --git a/linden/indra/llaudio/vorbisdecode.cpp b/linden/indra/llaudio/llvorbisdecode.cpp
index 4bf70f4..4bf70f4 100644
--- a/linden/indra/llaudio/vorbisdecode.cpp
+++ b/linden/indra/llaudio/llvorbisdecode.cpp
diff --git a/linden/indra/llaudio/vorbisdecode.h b/linden/indra/llaudio/llvorbisdecode.h
index cb67c99..cb67c99 100644
--- a/linden/indra/llaudio/vorbisdecode.h
+++ b/linden/indra/llaudio/llvorbisdecode.h
diff --git a/linden/indra/llaudio/llvorbisencode.cpp b/linden/indra/llaudio/llvorbisencode.cpp
new file mode 100644
index 0000000..a24394d
--- /dev/null
+++ b/linden/indra/llaudio/llvorbisencode.cpp
@@ -0,0 +1,505 @@
+/** 
+ * @file vorbisencode.cpp
+ * @brief Vorbis encoding routine routine for Indra.
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "vorbis/vorbisenc.h"
+
+#include "llvorbisencode.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 std::string& in_fname, std::string& 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.clear();
+
+        //********************************
+        LLAPRFile infile ;
+    infile.open(in_fname,LL_APR_RB, LLAPRFile::global);
+        //********************************
+        if (!infile.getFileHandle())
+        {
+                error_msg = "CannotUploadSoundFile";
+                return(LLVORBISENC_SOURCE_OPEN_ERR);
+        }
+
+        infile.read(wav_header, 44);
+        physical_file_size = infile.seek(APR_END,0);
+
+        if (strncmp((char *)&(wav_header[0]),"RIFF",4))
+        {
+                error_msg = "SoundFileNotRIFF";
+                return(LLVORBISENC_WAV_FORMAT_ERR);
+        }
+
+        if (strncmp((char *)&(wav_header[8]),"WAVE",4))
+        {
+                error_msg = "SoundFileNotRIFF";
+                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)
+        {
+                infile.seek(APR_SET,file_pos);
+                infile.read(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;
+        } 
+        //****************
+        infile.close();
+        //****************
+
+        if (!uncompressed_pcm)
+        {       
+                 error_msg = "SoundFileNotPCM";
+                  return(LLVORBISENC_PCM_FORMAT_ERR);
+        }
+        
+        if ((num_channels < 1) || (num_channels > LLVORBIS_CLIP_MAX_CHANNELS))
+        {       
+                error_msg = "SoundFileInvalidChannelCount";
+                return(LLVORBISENC_MULTICHANNEL_ERR);
+        }
+
+        if (sample_rate != LLVORBIS_CLIP_SAMPLE_RATE)
+        {       
+                error_msg = "SoundFileInvalidSampleRate";
+                return(LLVORBISENC_UNSUPPORTED_SAMPLE_RATE);
+        }
+        
+        if ((bits_per_sample != 16) && (bits_per_sample != 8))
+        {                
+                error_msg = "SoundFileInvalidWordSize";
+                return(LLVORBISENC_UNSUPPORTED_WORD_SIZE);
+        }
+
+        if (!raw_data_length)
+        {
+                error_msg = "SoundFileInvalidHeader";
+                return(LLVORBISENC_CLIP_TOO_LONG);               
+        }
+
+        F32 clip_length = (F32)raw_data_length/(F32)bytes_per_sec;
+                
+        if (clip_length > LLVORBIS_CLIP_MAX_TIME)
+        {
+                error_msg = "SoundFileInvalidTooLong";
+                return(LLVORBISENC_CLIP_TOO_LONG);               
+        }
+
+    return(LLVORBISENC_NOERR);
+}
+
+S32 encode_vorbis_file(const std::string& in_fname, const std::string& out_fname)
+{
+#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;
+        std::string error_msg;
+        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;
+
+        LLAPRFile infile ;
+        infile.open(in_fname,LL_APR_RB, LLAPRFile::global);
+        if (!infile.getFileHandle())
+        {
+                llwarns << "Couldn't open temporary ogg file for writing: " << in_fname
+                        << llendl;
+                return(LLVORBISENC_SOURCE_OPEN_ERR);
+        }
+
+        LLAPRFile outfile ;
+        outfile.open(out_fname,LL_APR_WPB, LLAPRFile::global);
+        if (!outfile.getFileHandle())
+        {
+                llwarns << "Couldn't open upload sound file for reading: " << in_fname
+                        << llendl;
+                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 (infile.eof() != APR_EOF)
+         {
+                 infile.seek(APR_SET,file_pos);
+                 infile.read(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)))
+                 {
+                         infile.seek(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;
+         } 
+         
+
+         /********** Encode setup ************/
+         
+         /* choose an encoding mode */
+         /* (mode 0: 44kHz stereo uncoupled, roughly 128kbps VBR) */
+         vorbis_info_init(&vi);
+
+         // always encode to mono
+
+         // SL-52913 & SL-53779 determined this quality level to be our 'good
+         // enough' general-purpose quality level with a nice low bitrate.
+         // Equivalent to oggenc -q0.5
+         F32 quality = 0.05f;
+//       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, ll_rand());
+         
+         /* 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;
+                         outfile.write(og.header, og.header_len);
+                         outfile.write(og.body, og.body_len);
+                 }
+                 
+         }
+         
+         
+         while(!eos)
+         {
+                 long bytes_per_sample = bits_per_sample/8;
+
+                 long bytes=(long)infile.read(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;
+
+                                 outfile.write(og.header, og.header_len);
+                                 outfile.write(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;
+         
+#endif
+         return(LLVORBISENC_NOERR);
+         
+}
diff --git a/linden/indra/llaudio/vorbisencode.h b/linden/indra/llaudio/llvorbisencode.h
index ff5ce3a..2825a30 100644
--- a/linden/indra/llaudio/vorbisencode.h
+++ b/linden/indra/llaudio/llvorbisencode.h
@@ -45,6 +45,17 @@ const S32 LLVORBISENC_UNSUPPORTED_SAMPLE_RATE      = 8; // unsupported sample ra
 const S32 LLVORBISENC_UNSUPPORTED_WORD_SIZE        = 9; // unsupported word size
 const S32 LLVORBISENC_CLIP_TOO_LONG                = 10; // source file is too long
 
+const F32 LLVORBIS_CLIP_MAX_TIME                                = 10.0f;
+const U8  LLVORBIS_CLIP_MAX_CHANNELS                    = 2;
+const U32 LLVORBIS_CLIP_SAMPLE_RATE                             = 44100;
+const U32 LLVORBIS_CLIP_MAX_SAMPLES_PER_CHANNEL = (U32)(LLVORBIS_CLIP_MAX_TIME * LLVORBIS_CLIP_SAMPLE_RATE);
+const U32 LLVORBIS_CLIP_MAX_SAMPLES                             = LLVORBIS_CLIP_MAX_SAMPLES_PER_CHANNEL * LLVORBIS_CLIP_MAX_CHANNELS;
+const size_t LLVORBIS_CLIP_MAX_SAMPLE_DATA              = LLVORBIS_CLIP_MAX_SAMPLES * 2; // 2 = 16-bit
+
+// Treat anything this long as a bad asset. A little fudge factor at the end:
+// Make that a lot of fudge factor. We're allowing 30 sec for now - 3x legal upload
+const size_t LLVORBIS_CLIP_REJECT_SAMPLES               = LLVORBIS_CLIP_MAX_SAMPLES * 3;
+const size_t LLVORBIS_CLIP_REJECT_SIZE                  = LLVORBIS_CLIP_MAX_SAMPLE_DATA * 3;
 
 S32 check_for_invalid_wav_formats(const std::string& in_fname, std::string& error_msg);
 S32 encode_vorbis_file(const std::string& in_fname, const std::string& out_fname);
diff --git a/linden/indra/llaudio/windgen.h b/linden/indra/llaudio/llwindgen.h
index 847bfa6..847bfa6 100644
--- a/linden/indra/llaudio/windgen.h
+++ b/linden/indra/llaudio/llwindgen.h