diff --git a/indra/llaudio/llaudioengine.cpp b/indra/llaudio/llaudioengine.cpp
index 4190ee41e7..26a3d2019e 100755
--- a/indra/llaudio/llaudioengine.cpp
+++ b/indra/llaudio/llaudioengine.cpp
@@ -72,8 +72,10 @@ LLStreamingAudioInterface* LLAudioEngine::getStreamingAudioImpl()
 
 void LLAudioEngine::setStreamingAudioImpl(LLStreamingAudioInterface *impl)
 {
+	// <FS> FMOD fixes
 	if (mStreamingAudioImpl)
 		delete mStreamingAudioImpl;
+	// </FS>
 	mStreamingAudioImpl = impl;
 }
 
@@ -136,9 +138,11 @@ bool LLAudioEngine::init(const S32 num_channels, void* userdata)
 
 void LLAudioEngine::shutdown()
 {
+	// <FS> FMOD fixes
 	// Clean up streaming audio
 	delete mStreamingAudioImpl;
 	mStreamingAudioImpl = NULL;
+	// </FS>
 
 	// Clean up decode manager
 	delete gAudioDecodeMgrp;
diff --git a/indra/llaudio/llaudioengine_fmodex.cpp b/indra/llaudio/llaudioengine_fmodex.cpp
index 33e9db39ad..4a16e3e454 100644
--- a/indra/llaudio/llaudioengine_fmodex.cpp
+++ b/indra/llaudio/llaudioengine_fmodex.cpp
@@ -180,6 +180,12 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 	if(mEnableProfiler)
 	{
 		fmod_flags |= FMOD_INIT_ENABLE_PROFILE;
+		// <FS> FMOD fixes
+		//mSystem->createChannelGroup("None", &mChannelGroups[AUDIO_TYPE_NONE]);
+		//mSystem->createChannelGroup("SFX", &mChannelGroups[AUDIO_TYPE_SFX]);
+		//mSystem->createChannelGroup("UI", &mChannelGroups[AUDIO_TYPE_UI]);
+		//mSystem->createChannelGroup("Ambient", &mChannelGroups[AUDIO_TYPE_AMBIENT]);
+		// </FS>
 	}
 
 #if LL_LINUX
@@ -190,7 +196,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		if (NULL == getenv("LL_BAD_FMOD_PULSEAUDIO")) /*Flawfinder: ignore*/
 		{
 			LL_DEBUGS("AppInit") << "Trying PulseAudio audio output..." << LL_ENDL;
+			// <FS> FMOD fixes
+			//if(mSystem->setOutput(FMOD_OUTPUTTYPE_PULSEAUDIO) == FMOD_OK &&
 			if((result = mSystem->setOutput(FMOD_OUTPUTTYPE_PULSEAUDIO)) == FMOD_OK &&
+			// </FS>
 				(result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
 			{
 				LL_DEBUGS("AppInit") << "PulseAudio output initialized OKAY"	<< LL_ENDL;
@@ -211,7 +220,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		if (NULL == getenv("LL_BAD_FMOD_ALSA"))		/*Flawfinder: ignore*/
 		{
 			LL_DEBUGS("AppInit") << "Trying ALSA audio output..." << LL_ENDL;
+			// <FS> FMOD fixes
+			//if(mSystem->setOutput(FMOD_OUTPUTTYPE_ALSA) == FMOD_OK &&
 			if((result = mSystem->setOutput(FMOD_OUTPUTTYPE_ALSA)) == FMOD_OK &&
+			// </FS>
 			    (result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
 			{
 				LL_DEBUGS("AppInit") << "ALSA audio output initialized OKAY" << LL_ENDL;
@@ -232,7 +244,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		if (NULL == getenv("LL_BAD_FMOD_OSS")) 	 /*Flawfinder: ignore*/
 		{
 			LL_DEBUGS("AppInit") << "Trying OSS audio output..." << LL_ENDL;
+			// <FS> FMOD fixes
+			//if(mSystem->setOutput(FMOD_OUTPUTTYPE_OSS) == FMOD_OK &&
 			if((result = mSystem->setOutput(FMOD_OUTPUTTYPE_OSS)) == FMOD_OK &&
+			// </FS>
 			    (result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
 			{
 				LL_DEBUGS("AppInit") << "OSS audio output initialized OKAY" << LL_ENDL;
@@ -257,22 +272,27 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 	// We're interested in logging which output method we
 	// ended up with, for QA purposes.
 	FMOD_OUTPUTTYPE output_type;
+	// <FS> FMOD fixes
+	//mSystem->getOutput(&output_type);
 	if(!Check_FMOD_Error(mSystem->getOutput(&output_type), "FMOD::System::getOutput"))
 	{
-		switch (output_type)
-		{
-			case FMOD_OUTPUTTYPE_NOSOUND: 
-				LL_INFOS("AppInit") << "Audio output: NoSound" << LL_ENDL; break;
-			case FMOD_OUTPUTTYPE_PULSEAUDIO:	
-				LL_INFOS("AppInit") << "Audio output: PulseAudio" << LL_ENDL; break;
-			case FMOD_OUTPUTTYPE_ALSA: 
-				LL_INFOS("AppInit") << "Audio output: ALSA" << LL_ENDL; break;
-			case FMOD_OUTPUTTYPE_OSS:	
-				LL_INFOS("AppInit") << "Audio output: OSS" << LL_ENDL; break;
-			default:
-				LL_INFOS("AppInit") << "Audio output: Unknown!" << LL_ENDL; break;
-		};
+	// </FS>
+	switch (output_type)
+	{
+		case FMOD_OUTPUTTYPE_NOSOUND: 
+			LL_INFOS("AppInit") << "Audio output: NoSound" << LL_ENDL; break;
+		case FMOD_OUTPUTTYPE_PULSEAUDIO:	
+			LL_INFOS("AppInit") << "Audio output: PulseAudio" << LL_ENDL; break;
+		case FMOD_OUTPUTTYPE_ALSA: 
+			LL_INFOS("AppInit") << "Audio output: ALSA" << LL_ENDL; break;
+		case FMOD_OUTPUTTYPE_OSS:	
+			LL_INFOS("AppInit") << "Audio output: OSS" << LL_ENDL; break;
+		default:
+			LL_INFOS("AppInit") << "Audio output: Unknown!" << LL_ENDL; break;
+	};
+	// <FS> FMOD fixes
 	}
+	// </FS>
 #else // LL_LINUX
 
 	// initialize the FMOD engine
@@ -294,6 +314,7 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		return false;
 #endif
 
+	// <FS> FMOD fixes
 	if (mEnableProfiler)
 	{
 		Check_FMOD_Error(mSystem->createChannelGroup("None", &mChannelGroups[AUDIO_TYPE_NONE]), "FMOD::System::createChannelGroup");
@@ -301,6 +322,7 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		Check_FMOD_Error(mSystem->createChannelGroup("UI", &mChannelGroups[AUDIO_TYPE_UI]), "FMOD::System::createChannelGroup");
 		Check_FMOD_Error(mSystem->createChannelGroup("Ambient", &mChannelGroups[AUDIO_TYPE_AMBIENT]), "FMOD::System::createChannelGroup");
 	}
+	// </FS>
 
 	// set up our favourite FMOD-native streaming audio implementation if none has already been added
 	if (!getStreamingAudioImpl()) // no existing implementation added
@@ -364,16 +386,22 @@ void LLAudioEngine_FMODEX::allocateListener(void)
 
 void LLAudioEngine_FMODEX::shutdown()
 {
+	// <FS> FMOD fixes
+	//stopInternetStream();
+
 	LL_INFOS() << "About to LLAudioEngine::shutdown()" << LL_ENDL;
 	LLAudioEngine::shutdown();
 	
 	LL_INFOS() << "LLAudioEngine_FMODEX::shutdown() closing FMOD Ex" << LL_ENDL;
 	if ( mSystem ) // speculative fix for MAINT-2657
 	{
+		// <FS> FMOD fixes
+		//mSystem->close();
+		//mSystem->release();
 		Check_FMOD_Error(mSystem->close(), "FMOD::System::close");
-		// <FS:Ansariel> Additional debug message; viewer might hang somewhere in here
 		LL_INFOS() << "LLAudioEngine_FMODEX::shutdown() FMOD Ex system closed. Now releasing..." << LL_ENDL;
 		Check_FMOD_Error(mSystem->release(), "FMOD::System::release");
+		// </FS>
 	}
 	LL_INFOS() << "LLAudioEngine_FMODEX::shutdown() done closing FMOD Ex" << LL_ENDL;
 
@@ -429,8 +457,12 @@ void LLAudioEngine_FMODEX::cleanupWind()
 {
 	if (mWindDSP)
 	{
+		// <FS> FMOD fixes
+		//mWindDSP->remove();
+		//mWindDSP->release();
 		Check_FMOD_Error(mWindDSP->remove(), "FMOD::DSP::remove");
 		Check_FMOD_Error(mWindDSP->release(), "FMOD::DSP::release");
+		// </FS>
 		mWindDSP = NULL;
 	}
 
@@ -482,8 +514,11 @@ void LLAudioEngine_FMODEX::setInternalGain(F32 gain)
 	gain = llclamp( gain, 0.0f, 1.0f );
 
 	FMOD::ChannelGroup *master_group;
+	// <FS> FMOD fixes
+	//mSystem->getMasterChannelGroup(&master_group);
 	if(Check_FMOD_Error(mSystem->getMasterChannelGroup(&master_group), "FMOD::System::getMasterChannelGroup"))
 		return;
+	// </FS>
 	master_group->setVolume(gain);
 
 	LLStreamingAudioInterface *saimpl = getStreamingAudioImpl();
@@ -611,7 +646,10 @@ void LLAudioChannelFMODEX::updateLoop()
 	// yield false negatives.
 	//
 	U32 cur_pos;
+	// <FS> FMOD fixes
+	//mChannelp->getPosition(&cur_pos,FMOD_TIMEUNIT_PCMBYTES);
 	Check_FMOD_Error(mChannelp->getPosition(&cur_pos,FMOD_TIMEUNIT_PCMBYTES),"FMOD::Channel::getPosition");
+	// </FS>
 
 	if (cur_pos < (U32)mLastSamplePos)
 	{
@@ -645,12 +683,18 @@ void LLAudioChannelFMODEX::play()
 		return;
 	}
 
+	// <FS> FMOD fixes
+	//Check_FMOD_Error(mChannelp->setPaused(false), "FMOD::Channel::pause");
 	Check_FMOD_Error(mChannelp->setPaused(false), "FMOD::Channel::setPaused");
+	// </FS>
 
 	getSource()->setPlayedOnce(true);
 
 	if(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()])
+		// <FS> FMOD fixes
+		//mChannelp->setChannelGroup(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()]);
 		Check_FMOD_Error(mChannelp->setChannelGroup(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()]),"FMOD::Channel::setChannelGroup");
+		// </FS>
 }
 
 
@@ -685,8 +729,12 @@ bool LLAudioChannelFMODEX::isPlaying()
 	}
 
 	bool paused, playing;
+	// <FS> FMOD fixes
+	//mChannelp->getPaused(&paused);
+	//mChannelp->isPlaying(&playing);
 	Check_FMOD_Error(mChannelp->getPaused(&paused),"FMOD::Channel::getPaused");
 	Check_FMOD_Error(mChannelp->isPlaying(&playing),"FMOD::Channel::isPlaying");
+	// </FS>
 	return !paused && playing;
 }
 
@@ -705,7 +753,10 @@ LLAudioBufferFMODEX::~LLAudioBufferFMODEX()
 {
 	if(mSoundp)
 	{
+		// <FS> FMOD fixes
+		//mSoundp->release();
 		Check_FMOD_Error(mSoundp->release(),"FMOD::Sound::Release");
+		// </FS>
 		mSoundp = NULL;
 	}
 }
@@ -721,7 +772,10 @@ bool LLAudioBufferFMODEX::loadWAV(const std::string& filename)
 		return false;
 	}
 
+	// <FS> FMOD fixes
+	//if (!LLAPRFile::isExist(filename, NULL, LL_APR_RPB))
 	if (!gDirUtilp->fileExists(filename))
+	// </FS>
 	{
 		// File not found, abort.
 		return false;
@@ -730,7 +784,10 @@ bool LLAudioBufferFMODEX::loadWAV(const std::string& filename)
 	if (mSoundp)
 	{
 		// If there's already something loaded in this buffer, clean it up.
+		// <FS> FMOD fixes
+		//mSoundp->release();
 		Check_FMOD_Error(mSoundp->release(),"FMOD::Sound::release");
+		// </FS>
 		mSoundp = NULL;
 	}
 
@@ -773,7 +830,10 @@ U32 LLAudioBufferFMODEX::getLength()
 	}
 
 	U32 length;
+	// <FS> FMOD fixes
+	//mSoundp->getLength(&length, FMOD_TIMEUNIT_PCMBYTES);
 	Check_FMOD_Error(mSoundp->getLength(&length, FMOD_TIMEUNIT_PCMBYTES),"FMOD::Sound::getLength");
+	// </FS>
 	return length;
 }
 
@@ -781,7 +841,10 @@ U32 LLAudioBufferFMODEX::getLength()
 void LLAudioChannelFMODEX::set3DMode(bool use3d)
 {
 	FMOD_MODE current_mode;
+	// <FS> FMOD fixes
+	//if(mChannelp->getMode(&current_mode) != FMOD_OK)
 	if(Check_FMOD_Error(mChannelp->getMode(&current_mode),"FMOD::Channel::getMode"))
+	// </FS>
 		return;
 	FMOD_MODE new_mode = current_mode;	
 	new_mode &= ~(use3d ? FMOD_2D : FMOD_3D);
@@ -789,7 +852,10 @@ void LLAudioChannelFMODEX::set3DMode(bool use3d)
 
 	if(current_mode != new_mode)
 	{
+		// <FS> FMOD fixes
+		//mChannelp->setMode(new_mode);
 		Check_FMOD_Error(mChannelp->setMode(new_mode),"FMOD::Channel::setMode");
+		// </FS>
 	}
 }
 
@@ -808,9 +874,14 @@ FMOD_RESULT F_CALLBACK windCallback(FMOD_DSP_STATE *dsp_state, float *originalbu
 	FMOD::DSP *thisdsp = (FMOD::DSP *)dsp_state->instance;
 
 	thisdsp->getUserData((void **)&windgen);
-	
+	// <FS> FMOD fixes
+	//S32 channels, configwidth, configheight;
+	//thisdsp->getInfo(0, 0, &channels, &configwidth, &configheight);
+	//
+	//windgen->windGenerate((LLAudioEngine_FMODEX::MIXBUFFERFORMAT *)newbuffer, length);	
 	if (windgen)
 		windgen->windGenerate((LLAudioEngine_FMODEX::MIXBUFFERFORMAT *)newbuffer, length);
+	// </FS>
 
 	return FMOD_OK;
 }
diff --git a/indra/llaudio/llstreamingaudio_fmodex.cpp b/indra/llaudio/llstreamingaudio_fmodex.cpp
index 9f7a3875d2..b96dbc242c 100644
--- a/indra/llaudio/llstreamingaudio_fmodex.cpp
+++ b/indra/llaudio/llstreamingaudio_fmodex.cpp
@@ -33,6 +33,7 @@
 
 #include "llstreamingaudio_fmodex.h"
 
+// <FS> FMOD fixes
 inline bool Check_FMOD_Error(FMOD_RESULT result, const char *string)
 {
 	if (result == FMOD_OK)
@@ -40,6 +41,7 @@ inline bool Check_FMOD_Error(FMOD_RESULT result, const char *string)
 	LL_WARNS("AudioImpl") << string << " Error: " << FMOD_ErrorString(result) << LL_ENDL;
 	return true;
 }
+// </FS>
 
 class LLAudioStreamManagerFMODEX
 {
@@ -51,7 +53,10 @@ public:
 
 	const std::string& getURL() 	{ return mInternetStreamURL; }
 
+	// <FS> FMOD fixes
+	//FMOD_OPENSTATE getOpenState(unsigned int* percentbuffered=NULL, bool* starving=NULL, bool* diskbusy=NULL);
 	FMOD_RESULT getOpenState(FMOD_OPENSTATE& openstate, unsigned int* percentbuffered = NULL, bool* starving = NULL, bool* diskbusy = NULL);
+	// </FS>
 protected:
 	FMOD::System* mSystem;
 	FMOD::Channel* mStreamChannel;
@@ -72,19 +77,33 @@ LLStreamingAudio_FMODEX::LLStreamingAudio_FMODEX(FMOD::System *system) :
 	mFMODInternetStreamChannelp(NULL),
 	mGain(1.0f)
 {
+	// <FS> FMOD fixes
 	FMOD_RESULT result;
 
 	// Number of milliseconds of audio to buffer for the audio card.
 	// Must be larger than the usual Second Life frame stutter time.
 	const U32 buffer_seconds = 10;		//sec
 	const U32 estimated_bitrate = 128;	//kbit/sec
+	// <FS> FMOD fixes
+	//mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
 	result = mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
 	Check_FMOD_Error(result, "FMOD::System::setStreamBufferSize");
+	// </FS>
+
+	// 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_FMODEX::~LLStreamingAudio_FMODEX()
 {
+	// <FS> FMOD fixes
+	//// nothing interesting/safe to do.
 	LL_INFOS() << "LLStreamingAudio_FMODEX::~LLStreamingAudio_FMODEX() destructing FMOD Ex Streaming" << LL_ENDL;
 	stop();
 	for (U32 i = 0; i < 100; ++i)
@@ -94,6 +113,7 @@ LLStreamingAudio_FMODEX::~LLStreamingAudio_FMODEX()
 		ms_sleep(10);
 	}
 	LL_INFOS() << "LLStreamingAudio_FMODEX::~LLStreamingAudio_FMODEX() finished" << LL_ENDL;
+	// </FS>
 }
 
 void LLStreamingAudio_FMODEX::start(const std::string& url)
@@ -109,6 +129,10 @@ void LLStreamingAudio_FMODEX::start(const std::string& url)
 
 	if (!url.empty())
 	{
+		// <FS> FMOD fixes
+		//LL_INFOS() << "Starting internet stream: " << url << LL_ENDL;
+		//mCurrentInternetStreamp = new LLAudioStreamManagerFMODEX(mSystem,url);
+		//mURL = url;
 		if(mDeadStreams.empty())
 		{
 			LL_INFOS() << "Starting internet stream: " << url << LL_ENDL;
@@ -120,6 +144,7 @@ void LLStreamingAudio_FMODEX::start(const std::string& url)
 			LL_INFOS() << "Deferring stream load until buffer release: " << url << LL_ENDL;
 			mPendingURL = url;
 		}
+		// <FS>
 	}
 	else
 	{
@@ -131,6 +156,23 @@ void LLStreamingAudio_FMODEX::start(const std::string& url)
 
 void LLStreamingAudio_FMODEX::update()
 {
+	// <FS> FMOD fixes
+	//// Kill dead internet streams, if possible
+	//std::list<LLAudioStreamManagerFMODEX *>::iterator iter;
+	//for (iter = mDeadStreams.begin(); iter != mDeadStreams.end();)
+	//{
+	//	LLAudioStreamManagerFMODEX *streamp = *iter;
+	//	if (streamp->stopStream())
+	//	{
+	//		LL_INFOS() << "Closed dead stream" << LL_ENDL;
+	//		delete streamp;
+	//		mDeadStreams.erase(iter++);
+	//	}
+	//	else
+	//	{
+	//		iter++;
+	//	}
+	//}
 	if (!releaseDeadStreams())
 	{
 		llassert_always(mCurrentInternetStreamp == NULL);
@@ -145,6 +187,7 @@ void LLStreamingAudio_FMODEX::update()
 		mURL = mPendingURL;
 		mPendingURL.clear();
 	}
+	// </FS>
 
 	// Don't do anything if there are no streams playing
 	if (!mCurrentInternetStreamp)
@@ -155,6 +198,11 @@ void LLStreamingAudio_FMODEX::update()
 	unsigned int progress;
 	bool starving;
 	bool diskbusy;
+	// <FS> FMOD fixes
+	//FMOD_OPENSTATE open_state = mCurrentInternetStreamp->getOpenState(&progress, &starving, &diskbusy);
+
+	//if (open_state == FMOD_OPENSTATE_READY)
+
 	FMOD_OPENSTATE open_state;
 	FMOD_RESULT result = mCurrentInternetStreamp->getOpenState(open_state, &progress, &starving, &diskbusy);
 
@@ -164,6 +212,7 @@ void LLStreamingAudio_FMODEX::update()
 		return;
 	}
 	else if (open_state == FMOD_OPENSTATE_READY)
+	// </FS>
 	{
 		// Stream is live
 
@@ -173,9 +222,19 @@ void LLStreamingAudio_FMODEX::update()
 		{
 			// Reset volume to previously set volume
 			setGain(getGain());
+			// <FS> FMOD fixes
+			//mFMODInternetStreamChannelp->setPaused(false);
 			Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(false), "FMOD::Channel::setPaused");
+			// </FS>
 		}
 	}
+	// <FS> FMOD fixes
+	//else if(open_state == FMOD_OPENSTATE_ERROR)
+	//{
+	//	stop();
+	//	return;
+	//}
+	// </FS>
 
 	if(mFMODInternetStreamChannelp)
 	{
@@ -288,17 +347,27 @@ void LLStreamingAudio_FMODEX::update()
 			if(starving)
 			{
 				bool paused = false;
+				// <FS> FMOD fixes
+				//mFMODInternetStreamChannelp->getPaused(&paused);
+				//if(!paused)
 				if (mFMODInternetStreamChannelp->getPaused(&paused) == FMOD_OK && !paused)
+				// </FS>
 				{
 					LL_INFOS() << "Stream starvation detected! Pausing stream until buffer nearly full." << LL_ENDL;
 					LL_INFOS() << "  (diskbusy="<<diskbusy<<")" << LL_ENDL;
 					LL_INFOS() << "  (progress="<<progress<<")" << LL_ENDL;
+					// <FS> FMOD fixes
+					//mFMODInternetStreamChannelp->setPaused(true);
 					Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(true), "FMOD::Channel::setPaused");
+					// </FS>
 				}
 			}
 			else if(progress > 80)
 			{
+				// <FS> FMOD fixes
+				//mFMODInternetStreamChannelp->setPaused(false);
 				Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(false), "FMOD::Channel::setPaused");
+				// </FS>
 			}
 		}
 	}
@@ -306,12 +375,17 @@ void LLStreamingAudio_FMODEX::update()
 
 void LLStreamingAudio_FMODEX::stop()
 {
+	// <FS> FMOD fixes
 	mPendingURL.clear();
 
 	if (mFMODInternetStreamChannelp)
 	{
+		// <FS> FMOD fixes
+		//mFMODInternetStreamChannelp->setPaused(true);
+		//mFMODInternetStreamChannelp->setPriority(0);
 		Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(true), "FMOD::Channel::setPaused");
 		Check_FMOD_Error(mFMODInternetStreamChannelp->setPriority(0), "FMOD::Channel::setPriority");
+		// </FS>
 		mFMODInternetStreamChannelp = NULL;
 	}
 
@@ -328,6 +402,7 @@ void LLStreamingAudio_FMODEX::stop()
 			mDeadStreams.push_back(mCurrentInternetStreamp);
 		}
 		mCurrentInternetStreamp = NULL;
+		//mURL.clear();
 	}
 }
 
@@ -360,7 +435,10 @@ int LLStreamingAudio_FMODEX::isPlaying()
 	{
 		return 1; // Active and playing
 	}
+	// <FS> FMOD fixes
+	//else if (!mURL.empty())
 	else if (!mURL.empty() || !mPendingURL.empty())
+	// </FS>
 	{
 		return 2; // "Paused"
 	}
@@ -391,7 +469,10 @@ void LLStreamingAudio_FMODEX::setGain(F32 vol)
 	{
 		vol = llclamp(vol * vol, 0.f, 1.f);	//should vol be squared here?
 
+		// <FS> FMOD fixes
+		//mFMODInternetStreamChannelp->setVolume(vol);
 		Check_FMOD_Error(mFMODInternetStreamChannelp->setVolume(vol), "FMOD::Channel::setVolume");
+		// </FS>
 	}
 }
 
@@ -444,8 +525,11 @@ LLAudioStreamManagerFMODEX::LLAudioStreamManagerFMODEX(FMOD::System *system, con
 FMOD::Channel *LLAudioStreamManagerFMODEX::startStream()
 {
 	// We need a live and opened stream before we try and play it.
+	// <FS> FMOD fixes
+	//if (!mInternetStream || getOpenState() != FMOD_OPENSTATE_READY)
 	FMOD_OPENSTATE open_state;
 	if (getOpenState(open_state) != FMOD_OK || open_state != FMOD_OPENSTATE_READY)
+	// </FS>
 	{
 		LL_WARNS() << "No internet stream to start playing!" << LL_ENDL;
 		return NULL;
@@ -454,7 +538,10 @@ FMOD::Channel *LLAudioStreamManagerFMODEX::startStream()
 	if(mStreamChannel)
 		return mStreamChannel;	//Already have a channel for this stream.
 
+	// <FS> FMOD fixes
+	//mSystem->playSound(FMOD_CHANNEL_FREE, mInternetStream, true, &mStreamChannel);
 	Check_FMOD_Error(mSystem->playSound(FMOD_CHANNEL_FREE, mInternetStream, true, &mStreamChannel), "FMOD::System::playSound");
+	// </FS>
 	return mStreamChannel;
 }
 
@@ -463,21 +550,31 @@ bool LLAudioStreamManagerFMODEX::stopStream()
 	if (mInternetStream)
 	{
 		bool close = true;
+		// <FS> FMOD fixes
+		//switch (getOpenState())
 		FMOD_OPENSTATE open_state;
 		if (getOpenState(open_state) == FMOD_OK)
 		{
 			switch (open_state)
-			{
-			case FMOD_OPENSTATE_CONNECTING:
-				close = false;
-				break;
-			default:
-				close = true;
-			}
+		// </FS>
+		{
+		case FMOD_OPENSTATE_CONNECTING:
+			close = false;
+			break;
+		default:
+			close = true;
 		}
+		// <FS> FMOD fixes
+		}
+		// </FS>
 
+		// <FS> FMOD fixes
+		//if (close)
+		//{
+		//	mInternetStream->release();
 		if (close && mInternetStream->release() == FMOD_OK)
 		{
+		// </FS>
 			mStreamChannel = NULL;
 			mInternetStream = NULL;
 			return true;
@@ -493,6 +590,13 @@ bool LLAudioStreamManagerFMODEX::stopStream()
 	}
 }
 
+// <FS> FMOD fixes
+//FMOD_OPENSTATE LLAudioStreamManagerFMODEX::getOpenState(unsigned int* percentbuffered, bool* starving, bool* diskbusy)
+//{
+//	FMOD_OPENSTATE state;
+//	mInternetStream->getOpenState(&state, percentbuffered, starving, diskbusy);
+//	return state;
+//}
 FMOD_RESULT LLAudioStreamManagerFMODEX::getOpenState(FMOD_OPENSTATE& state, unsigned int* percentbuffered, bool* starving, bool* diskbusy)
 {
 	if (!mInternetStream)
@@ -501,17 +605,25 @@ FMOD_RESULT LLAudioStreamManagerFMODEX::getOpenState(FMOD_OPENSTATE& state, unsi
 	Check_FMOD_Error(result, "FMOD::Sound::getOpenState");
 	return result;
 }
+// </FS>
 
 void LLStreamingAudio_FMODEX::setBufferSizes(U32 streambuffertime, U32 decodebuffertime)
 {
+	// <FS> FMOD fixes
+	//mSystem->setStreamBufferSize(streambuffertime/1000*128*128, FMOD_TIMEUNIT_RAWBYTES);
 	Check_FMOD_Error(mSystem->setStreamBufferSize(streambuffertime / 1000 * 128 * 128, FMOD_TIMEUNIT_RAWBYTES), "FMOD::System::setStreamBufferSize");
+	// </FS>
 	FMOD_ADVANCEDSETTINGS settings;
 	memset(&settings,0,sizeof(settings));
 	settings.cbsize=sizeof(settings);
 	settings.defaultDecodeBufferSize = decodebuffertime;//ms
+	// <FS> FMOD fixes
+	//mSystem->setAdvancedSettings(&settings);
 	Check_FMOD_Error(mSystem->setAdvancedSettings(&settings), "FMOD::System::setAdvancedSettings");
+	// </FS>
 }
 
+// <FS> FMOD fixes
 bool LLStreamingAudio_FMODEX::releaseDeadStreams()
 {
 	// Kill dead internet streams, if possible
@@ -533,3 +645,4 @@ bool LLStreamingAudio_FMODEX::releaseDeadStreams()
 
 	return mDeadStreams.empty();
 }
+// </FS>
diff --git a/indra/llaudio/llstreamingaudio_fmodex.h b/indra/llaudio/llstreamingaudio_fmodex.h
index 47d25a71c7..b197151f86 100644
--- a/indra/llaudio/llstreamingaudio_fmodex.h
+++ b/indra/llaudio/llstreamingaudio_fmodex.h
@@ -64,6 +64,7 @@ class LLStreamingAudio_FMODEX : public LLStreamingAudioInterface
 	// </FS:CR>
 
 private:
+	// <FS> FMOD fixes
 	bool releaseDeadStreams();
 
 	FMOD::System *mSystem;
@@ -73,7 +74,7 @@ private:
 	std::list<LLAudioStreamManagerFMODEX *> mDeadStreams;
 
 	std::string mURL;
-	std::string mPendingURL;
+	std::string mPendingURL; // <FS> FMOD fixes
 	F32 mGain;
 
 	// <FS:CR> Streamtitle display
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index dbc2721749..ac6ff9d59a 100755
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -2135,8 +2135,16 @@ bool LLAppViewer::cleanup()
 
 	if (gAudiop)
 	{
+		// shut down the streaming audio sub-subsystem first, in case it relies on not outliving the general audio subsystem.
+
+		// <FS> FMOD fixes
+		//LLStreamingAudioInterface *sai = gAudiop->getStreamingAudioImpl();
+		//delete sai;
+		//gAudiop->setStreamingAudioImpl(NULL);
+		// </FS>
+
 		// shut down the audio subsystem
-		gAudiop->shutdown();
+        gAudiop->shutdown();
 
 		delete gAudiop;
 		gAudiop = NULL;