Merge branch 'spaces-merge' into roxie/webrtc-voice

1 files changed, 3751 insertions, 3751 deletions

diff --git a/indra/newview/llvoicevivox.cpp b/indra/newview/llvoicevivox.cpp
index fe9df190c1..3554933a52 100644
--- a/indra/newview/llvoicevivox.cpp
+++ b/indra/newview/llvoicevivox.cpp
@@ -43,10 +43,10 @@
 #endif
 #include "llcallbacklist.h"
 #include "llviewerregion.h"
-#include "llviewernetwork.h"		// for gGridChoice
+#include "llviewernetwork.h"        // for gGridChoice
 #include "llbase64.h"
 #include "llviewercontrol.h"
-#include "llappviewer.h"	// for gDisconnected, gDisableVoice
+#include "llappviewer.h"    // for gDisconnected, gDisableVoice
 #include "llprocess.h"
 
 // Viewer includes
@@ -135,16 +135,16 @@ namespace {
 
 static int scale_mic_volume(float volume)
 {
-	// incoming volume has the range [0.0 ... 2.0], with 1.0 as the default.
-	// Map it to Vivox levels as follows: 0.0 -> 30, 1.0 -> 50, 2.0 -> 70
-	return 30 + (int)(volume * 20.0f);
+    // incoming volume has the range [0.0 ... 2.0], with 1.0 as the default.
+    // Map it to Vivox levels as follows: 0.0 -> 30, 1.0 -> 50, 2.0 -> 70
+    return 30 + (int)(volume * 20.0f);
 }
 
 static int scale_speaker_volume(float volume)
 {
-	// incoming volume has the range [0.0 ... 1.0], with 0.5 as the default.
-	// Map it to Vivox levels as follows: 0.0 -> 30, 0.5 -> 50, 1.0 -> 70
-	return 30 + (int)(volume * 40.0f);
+    // incoming volume has the range [0.0 ... 1.0], with 0.5 as the default.
+    // Map it to Vivox levels as follows: 0.0 -> 30, 0.5 -> 50, 1.0 -> 70
+    return 30 + (int)(volume * 40.0f);
 
 }
 
@@ -153,7 +153,7 @@ static int scale_speaker_volume(float volume)
 
 class LLVivoxVoiceClientMuteListObserver : public LLMuteListObserver
 {
-	/* virtual */ void onChange()  { LLVivoxVoiceClient::getInstance()->muteListChanged();}
+    /* virtual */ void onChange()  { LLVivoxVoiceClient::getInstance()->muteListChanged();}
 };
 
 
@@ -256,19 +256,19 @@ static LLEventStream sGatewayPump("VivoxDaemonPump", true);
 
 static bool isGatewayRunning()
 {
-	return sGatewayPtr && sGatewayPtr->isRunning();
+    return sGatewayPtr && sGatewayPtr->isRunning();
 }
 
 static void killGateway()
 {
-	if (sGatewayPtr)
-	{
+    if (sGatewayPtr)
+    {
         LL_DEBUGS("Voice") << "SLVoice " << sGatewayPtr->getStatusString() << LL_ENDL;
 
-		sGatewayPump.stopListening("VivoxDaemonPump");
-		sGatewayPtr->kill(__FUNCTION__);
+        sGatewayPump.stopListening("VivoxDaemonPump");
+        sGatewayPtr->kill(__FUNCTION__);
         sGatewayPtr=NULL;
-	}
+    }
     else
     {
         LL_DEBUGS("Voice") << "no gateway" << LL_ENDL;
@@ -282,117 +282,117 @@ bool LLVivoxVoiceClient::sConnected = false;
 LLPumpIO *LLVivoxVoiceClient::sPump = nullptr;
 
 LLVivoxVoiceClient::LLVivoxVoiceClient() :
-	mSessionTerminateRequested(false),
-	mRelogRequested(false),
-	mTerminateDaemon(false),
-	mSpatialJoiningNum(0),
-
-	mTuningMode(false),
-	mTuningEnergy(0.0f),
-	mTuningMicVolume(0),
-	mTuningMicVolumeDirty(true),
-	mTuningSpeakerVolume(50),     // Set to 50 so the user can hear himself when he sets his mic volume
-	mTuningSpeakerVolumeDirty(true),
-	mDevicesListUpdated(false),
-
-	mAudioSession(), // TBD - should be NULL
-	mAudioSessionChanged(false),
-	mNextAudioSession(),
-
-	mCurrentParcelLocalID(0),
+    mSessionTerminateRequested(false),
+    mRelogRequested(false),
+    mTerminateDaemon(false),
+    mSpatialJoiningNum(0),
+
+    mTuningMode(false),
+    mTuningEnergy(0.0f),
+    mTuningMicVolume(0),
+    mTuningMicVolumeDirty(true),
+    mTuningSpeakerVolume(50),     // Set to 50 so the user can hear himself when he sets his mic volume
+    mTuningSpeakerVolumeDirty(true),
+    mDevicesListUpdated(false),
+
+    mAudioSession(), // TBD - should be NULL
+    mAudioSessionChanged(false),
+    mNextAudioSession(),
+
+    mCurrentParcelLocalID(0),
     mConnectorEstablished(false),
     mAccountLoggedIn(false),
-	mNumberOfAliases(0),
-	mCommandCookie(0),
-	mLoginRetryCount(0),
-
-	mBuddyListMapPopulated(false),
-	mBlockRulesListReceived(false),
-	mAutoAcceptRulesListReceived(false),
-
-	mCaptureDeviceDirty(false),
-	mRenderDeviceDirty(false),
-	mSpatialCoordsDirty(false),
-	mIsInitialized(false),
-
-	mMuteMic(false),
-	mMuteMicDirty(false),
-	mFriendsListDirty(true),
-
-	mEarLocation(0),
-	mSpeakerVolumeDirty(true),
-	mSpeakerMuteDirty(true),
-	mMicVolume(0),
-	mMicVolumeDirty(true),
-
-	mVoiceEnabled(false),
+    mNumberOfAliases(0),
+    mCommandCookie(0),
+    mLoginRetryCount(0),
+
+    mBuddyListMapPopulated(false),
+    mBlockRulesListReceived(false),
+    mAutoAcceptRulesListReceived(false),
+
+    mCaptureDeviceDirty(false),
+    mRenderDeviceDirty(false),
+    mSpatialCoordsDirty(false),
+    mIsInitialized(false),
+
+    mMuteMic(false),
+    mMuteMicDirty(false),
+    mFriendsListDirty(true),
+
+    mEarLocation(0),
+    mSpeakerVolumeDirty(true),
+    mSpeakerMuteDirty(true),
+    mMicVolume(0),
+    mMicVolumeDirty(true),
+
+    mVoiceEnabled(false),
     mProcessChannels(false),
-	mWriteInProgress(false),
-
-	mVoiceFontsReceived(false),
-	mVoiceFontsNew(false),
-	mVoiceFontListDirty(false),
-
-	mCaptureBufferMode(false),
-	mCaptureBufferRecording(false),
-	mCaptureBufferRecorded(false),
-	mCaptureBufferPlaying(false),
-	mShutdownComplete(true),
-	mPlayRequestCount(0),
-
-	mAvatarNameCacheConnection(),
-	mIsInTuningMode(false),
-	mIsInChannel(false),
-	mIsJoiningSession(false),
-	mIsWaitingForFonts(false),
-	mIsLoggingIn(false),
-	mIsLoggedIn(false),
-	mIsProcessingChannels(false),
-	mIsCoroutineActive(false),
-	mVivoxPump("vivoxClientPump")
+    mWriteInProgress(false),
+
+    mVoiceFontsReceived(false),
+    mVoiceFontsNew(false),
+    mVoiceFontListDirty(false),
+
+    mCaptureBufferMode(false),
+    mCaptureBufferRecording(false),
+    mCaptureBufferRecorded(false),
+    mCaptureBufferPlaying(false),
+    mShutdownComplete(true),
+    mPlayRequestCount(0),
+
+    mAvatarNameCacheConnection(),
+    mIsInTuningMode(false),
+    mIsInChannel(false),
+    mIsJoiningSession(false),
+    mIsWaitingForFonts(false),
+    mIsLoggingIn(false),
+    mIsLoggedIn(false),
+    mIsProcessingChannels(false),
+    mIsCoroutineActive(false),
+    mVivoxPump("vivoxClientPump")
 {
     sShuttingDown = false;
     sConnected = false;
     sPump = nullptr;
 
-	mSpeakerVolume = scale_speaker_volume(0);
+    mSpeakerVolume = scale_speaker_volume(0);
 
-	mVoiceVersion.serverVersion = "";
-	mVoiceVersion.voiceServerType = VISIBLE_VOICE_SERVER_TYPE;
+    mVoiceVersion.serverVersion = "";
+    mVoiceVersion.voiceServerType = VISIBLE_VOICE_SERVER_TYPE;
     mVoiceVersion.internalVoiceServerType = VIVOX_VOICE_SERVER_TYPE;
     mVoiceVersion.majorVersion = 1;
     mVoiceVersion.minorVersion = 0;
     mVoiceVersion.mBuildVersion = "";
     mVoiceVersion.serverVersion = "";
 
-	//  gMuteListp isn't set up at this point, so we defer this until later.
-//	gMuteListp->addObserver(&mutelist_listener);
+    //  gMuteListp isn't set up at this point, so we defer this until later.
+//  gMuteListp->addObserver(&mutelist_listener);
 
 
 #if LL_DARWIN || LL_LINUX
-		// HACK: THIS DOES NOT BELONG HERE
-		// When the vivox daemon dies, the next write attempt on our socket generates a SIGPIPE, which kills us.
-		// This should cause us to ignore SIGPIPE and handle the error through proper channels.
-		// This should really be set up elsewhere.  Where should it go?
-		signal(SIGPIPE, SIG_IGN);
-
-		// Since we're now launching the gateway with fork/exec instead of system(), we need to deal with zombie processes.
-		// Ignoring SIGCHLD should prevent zombies from being created.  Alternately, we could use wait(), but I'd rather not do that.
-		signal(SIGCHLD, SIG_IGN);
+        // HACK: THIS DOES NOT BELONG HERE
+        // When the vivox daemon dies, the next write attempt on our socket generates a SIGPIPE, which kills us.
+        // This should cause us to ignore SIGPIPE and handle the error through proper channels.
+        // This should really be set up elsewhere.  Where should it go?
+        signal(SIGPIPE, SIG_IGN);
+
+        // Since we're now launching the gateway with fork/exec instead of system(), we need to deal with zombie processes.
+        // Ignoring SIGCHLD should prevent zombies from being created.  Alternately, we could use wait(), but I'd rather not do that.
+        signal(SIGCHLD, SIG_IGN);
 #endif
 
 
-	gIdleCallbacks.addFunction(idle, this);
+    gIdleCallbacks.addFunction(idle, this);
 }
 
 //---------------------------------------------------
 
 LLVivoxVoiceClient::~LLVivoxVoiceClient()
 {
-	if (mAvatarNameCacheConnection.connected())
-	{
-		mAvatarNameCacheConnection.disconnect();
-	}
+    if (mAvatarNameCacheConnection.connected())
+    {
+        mAvatarNameCacheConnection.disconnect();
+    }
     sShuttingDown = true;
 }
 
@@ -400,8 +400,8 @@ LLVivoxVoiceClient::~LLVivoxVoiceClient()
 
 void LLVivoxVoiceClient::init(LLPumpIO *pump)
 {
-	// constructor will set up LLVoiceClient::getInstance()
-	sPump = pump;
+    // constructor will set up LLVoiceClient::getInstance()
+    sPump = pump;
 
 //     LLCoros::instance().launch("LLVivoxVoiceClient::voiceControlCoro",
 //         boost::bind(&LLVivoxVoiceClient::voiceControlCoro, LLVivoxVoiceClient::getInstance()));
@@ -422,16 +422,16 @@ void LLVivoxVoiceClient::terminate()
         logoutOfVivox(false);
     }
 
-	if(sConnected)
-	{
+    if(sConnected)
+    {
         breakVoiceConnection(false);
         sConnected = false;
-	}
-	else
-	{
-		mRelogRequested = false;
-		killGateway();
-	}
+    }
+    else
+    {
+        mRelogRequested = false;
+        killGateway();
+    }
 
     sShuttingDown = true;
     sPump = NULL;
@@ -443,9 +443,9 @@ void LLVivoxVoiceClient::cleanUp()
 {
     LL_DEBUGS("Voice") << LL_ENDL;
 
-	deleteAllSessions();
-	deleteAllVoiceFonts();
-	deleteVoiceFontTemplates();
+    deleteAllSessions();
+    deleteAllVoiceFonts();
+    deleteVoiceFontTemplates();
     LL_DEBUGS("Voice") << "exiting" << LL_ENDL;
 }
 
@@ -453,7 +453,7 @@ void LLVivoxVoiceClient::cleanUp()
 
 const LLVoiceVersionInfo& LLVivoxVoiceClient::getVersion()
 {
-	return mVoiceVersion;
+    return mVoiceVersion;
 }
 
 //---------------------------------------------------
@@ -461,14 +461,14 @@ const LLVoiceVersionInfo& LLVivoxVoiceClient::getVersion()
 void LLVivoxVoiceClient::updateSettings()
 {
     setVoiceEnabled(LLVoiceClient::getInstance()->voiceEnabled());
-	setEarLocation(gSavedSettings.getS32("VoiceEarLocation"));
+    setEarLocation(gSavedSettings.getS32("VoiceEarLocation"));
 
-	std::string inputDevice = gSavedSettings.getString("VoiceInputAudioDevice");
-	setCaptureDevice(inputDevice);
-	std::string outputDevice = gSavedSettings.getString("VoiceOutputAudioDevice");
-	setRenderDevice(outputDevice);
-	F32 mic_level = gSavedSettings.getF32("AudioLevelMic");
-	setMicGain(mic_level);
+    std::string inputDevice = gSavedSettings.getString("VoiceInputAudioDevice");
+    setCaptureDevice(inputDevice);
+    std::string outputDevice = gSavedSettings.getString("VoiceOutputAudioDevice");
+    setRenderDevice(outputDevice);
+    F32 mic_level = gSavedSettings.getF32("AudioLevelMic");
+    setMicGain(mic_level);
 }
 
 /////////////////////////////
@@ -476,48 +476,48 @@ void LLVivoxVoiceClient::updateSettings()
 
 bool LLVivoxVoiceClient::writeString(const std::string &str)
 {
-	bool result = false;
+    bool result = false;
     LL_DEBUGS("LowVoice") << "sending:\n" << str << LL_ENDL;
 
-	if(sConnected)
-	{
-		apr_status_t err;
-		apr_size_t size = (apr_size_t)str.size();
-		apr_size_t written = size;
+    if(sConnected)
+    {
+        apr_status_t err;
+        apr_size_t size = (apr_size_t)str.size();
+        apr_size_t written = size;
 
-		//MARK: Turn this on to log outgoing XML
+        //MARK: Turn this on to log outgoing XML
         // LL_DEBUGS("Voice") << "sending: " << str << LL_ENDL;
 
-		// check return code - sockets will fail (broken, etc.)
-		err = apr_socket_send(
-				mSocket->getSocket(),
-				(const char*)str.data(),
-				&written);
-
-		if(err == 0 && written == size)
-		{
-			// Success.
-			result = true;
-		}
-		else if (err == 0 && written != size) {
-			// Did a short write,  log it for now
-			LL_WARNS("Voice") << ") short write on socket sending data to vivox daemon." << "Sent " << written << "bytes instead of " << size <<LL_ENDL;
-		}
-		else if(APR_STATUS_IS_EAGAIN(err))
-		{
-			char buf[MAX_STRING];
-			LL_WARNS("Voice") << "EAGAIN error " << err << " (" << apr_strerror(err, buf, MAX_STRING) << ") sending data to vivox daemon." << LL_ENDL;
-		}
-		else
-		{
-			// Assume any socket error means something bad.  For now, just close the socket.
-			char buf[MAX_STRING];
-			LL_WARNS("Voice") << "apr error " << err << " ("<< apr_strerror(err, buf, MAX_STRING) << ") sending data to vivox daemon." << LL_ENDL;
-			daemonDied();
-		}
-	}
-
-	return result;
+        // check return code - sockets will fail (broken, etc.)
+        err = apr_socket_send(
+                mSocket->getSocket(),
+                (const char*)str.data(),
+                &written);
+
+        if(err == 0 && written == size)
+        {
+            // Success.
+            result = true;
+        }
+        else if (err == 0 && written != size) {
+            // Did a short write,  log it for now
+            LL_WARNS("Voice") << ") short write on socket sending data to vivox daemon." << "Sent " << written << "bytes instead of " << size <<LL_ENDL;
+        }
+        else if(APR_STATUS_IS_EAGAIN(err))
+        {
+            char buf[MAX_STRING];
+            LL_WARNS("Voice") << "EAGAIN error " << err << " (" << apr_strerror(err, buf, MAX_STRING) << ") sending data to vivox daemon." << LL_ENDL;
+        }
+        else
+        {
+            // Assume any socket error means something bad.  For now, just close the socket.
+            char buf[MAX_STRING];
+            LL_WARNS("Voice") << "apr error " << err << " ("<< apr_strerror(err, buf, MAX_STRING) << ") sending data to vivox daemon." << LL_ENDL;
+            daemonDied();
+        }
+    }
+
+    return result;
 }
 
 
@@ -525,141 +525,141 @@ bool LLVivoxVoiceClient::writeString(const std::string &str)
 // session control messages
 void LLVivoxVoiceClient::connectorCreate()
 {
-	std::ostringstream stream;
-	std::string logdir = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "");
+    std::ostringstream stream;
+    std::string logdir = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "");
 
-	// Transition to stateConnectorStarted when the connector handle comes back.
-	std::string vivoxLogLevel = gSavedSettings.getString("VivoxDebugLevel");
+    // Transition to stateConnectorStarted when the connector handle comes back.
+    std::string vivoxLogLevel = gSavedSettings.getString("VivoxDebugLevel");
     if ( vivoxLogLevel.empty() )
     {
         vivoxLogLevel = "0";
     }
     LL_DEBUGS("Voice") << "creating connector with log level " << vivoxLogLevel << LL_ENDL;
 
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.Create.1\">"
-		<< "<ClientName>V2 SDK</ClientName>"
-		<< "<AccountManagementServer>" << mVoiceAccountServerURI << "</AccountManagementServer>"
-		<< "<Mode>Normal</Mode>"
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.Create.1\">"
+        << "<ClientName>V2 SDK</ClientName>"
+        << "<AccountManagementServer>" << mVoiceAccountServerURI << "</AccountManagementServer>"
+        << "<Mode>Normal</Mode>"
         << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-		<< "<Logging>"
-		<< "<Folder>" << logdir << "</Folder>"
-		<< "<FileNamePrefix>Connector</FileNamePrefix>"
-		<< "<FileNameSuffix>.log</FileNameSuffix>"
-		<< "<LogLevel>" << vivoxLogLevel << "</LogLevel>"
-		<< "</Logging>"
-		<< "<Application>" << LLVersionInfo::instance().getChannel() << " " << LLVersionInfo::instance().getVersion() << "</Application>"
-		//<< "<Application></Application>"  //Name can cause problems per vivox.
-		<< "<MaxCalls>12</MaxCalls>"
-		<< "</Request>\n\n\n";
+        << "<Logging>"
+        << "<Folder>" << logdir << "</Folder>"
+        << "<FileNamePrefix>Connector</FileNamePrefix>"
+        << "<FileNameSuffix>.log</FileNameSuffix>"
+        << "<LogLevel>" << vivoxLogLevel << "</LogLevel>"
+        << "</Logging>"
+        << "<Application>" << LLVersionInfo::instance().getChannel() << " " << LLVersionInfo::instance().getVersion() << "</Application>"
+        //<< "<Application></Application>"  //Name can cause problems per vivox.
+        << "<MaxCalls>12</MaxCalls>"
+        << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::connectorShutdown()
 {
-	if(mConnectorEstablished)
-	{
-		std::ostringstream stream;
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.InitiateShutdown.1\">"
-			<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-		<< "</Request>"
-		<< "\n\n\n";
+    if(mConnectorEstablished)
+    {
+        std::ostringstream stream;
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.InitiateShutdown.1\">"
+            << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+        << "</Request>"
+        << "\n\n\n";
 
-		mShutdownComplete = false;
-		mConnectorEstablished = false;
+        mShutdownComplete = false;
+        mConnectorEstablished = false;
 
-		writeString(stream.str());
-	}
-	else
-	{
-		mShutdownComplete = true;
-	}
+        writeString(stream.str());
+    }
+    else
+    {
+        mShutdownComplete = true;
+    }
 }
 
 void LLVivoxVoiceClient::userAuthorized(const std::string& user_id, const LLUUID &agentID)
 {
 
-	mAccountDisplayName = user_id;
+    mAccountDisplayName = user_id;
 
-	LL_INFOS("Voice") << "name \"" << mAccountDisplayName << "\" , ID " << agentID << LL_ENDL;
+    LL_INFOS("Voice") << "name \"" << mAccountDisplayName << "\" , ID " << agentID << LL_ENDL;
 
-	mAccountName = nameFromID(agentID);
+    mAccountName = nameFromID(agentID);
 }
 
 void LLVivoxVoiceClient::setLoginInfo(
-	const std::string& account_name,
-	const std::string& password,
-	const std::string& voice_sip_uri_hostname,
-	const std::string& voice_account_server_uri)
-{
-	mVoiceSIPURIHostName = voice_sip_uri_hostname;
-	mVoiceAccountServerURI = voice_account_server_uri;
-
-	if(mAccountLoggedIn)
-	{
-		// Already logged in.
-		LL_WARNS("Voice") << "Called while already logged in." << LL_ENDL;
-
-		// Don't process another login.
-		return;
-	}
-	else if ( account_name != mAccountName )
-	{
-		LL_WARNS("Voice") << "Mismatched account name! " << account_name
+    const std::string& account_name,
+    const std::string& password,
+    const std::string& voice_sip_uri_hostname,
+    const std::string& voice_account_server_uri)
+{
+    mVoiceSIPURIHostName = voice_sip_uri_hostname;
+    mVoiceAccountServerURI = voice_account_server_uri;
+
+    if(mAccountLoggedIn)
+    {
+        // Already logged in.
+        LL_WARNS("Voice") << "Called while already logged in." << LL_ENDL;
+
+        // Don't process another login.
+        return;
+    }
+    else if ( account_name != mAccountName )
+    {
+        LL_WARNS("Voice") << "Mismatched account name! " << account_name
                           << " instead of " << mAccountName << LL_ENDL;
-	}
-	else
-	{
-		mAccountPassword = password;
-	}
+    }
+    else
+    {
+        mAccountPassword = password;
+    }
 
-	std::string debugSIPURIHostName = gSavedSettings.getString("VivoxDebugSIPURIHostName");
+    std::string debugSIPURIHostName = gSavedSettings.getString("VivoxDebugSIPURIHostName");
 
-	if( !debugSIPURIHostName.empty() )
-	{
+    if( !debugSIPURIHostName.empty() )
+    {
         LL_INFOS("Voice") << "Overriding account server based on VivoxDebugSIPURIHostName: "
                           << debugSIPURIHostName << LL_ENDL;
-		mVoiceSIPURIHostName = debugSIPURIHostName;
-	}
-
-	if( mVoiceSIPURIHostName.empty() )
-	{
-		// we have an empty account server name
-		// so we fall back to hardcoded defaults
-
-		if(LLGridManager::getInstance()->isInProductionGrid())
-		{
-			// Use the release account server
-			mVoiceSIPURIHostName = "bhr.vivox.com";
-		}
-		else
-		{
-			// Use the development account server
-			mVoiceSIPURIHostName = "bhd.vivox.com";
-		}
+        mVoiceSIPURIHostName = debugSIPURIHostName;
+    }
+
+    if( mVoiceSIPURIHostName.empty() )
+    {
+        // we have an empty account server name
+        // so we fall back to hardcoded defaults
+
+        if(LLGridManager::getInstance()->isInProductionGrid())
+        {
+            // Use the release account server
+            mVoiceSIPURIHostName = "bhr.vivox.com";
+        }
+        else
+        {
+            // Use the development account server
+            mVoiceSIPURIHostName = "bhd.vivox.com";
+        }
         LL_INFOS("Voice") << "Defaulting SIP URI host: "
                           << mVoiceSIPURIHostName << LL_ENDL;
 
-	}
+    }
 
-	std::string debugAccountServerURI = gSavedSettings.getString("VivoxDebugVoiceAccountServerURI");
+    std::string debugAccountServerURI = gSavedSettings.getString("VivoxDebugVoiceAccountServerURI");
 
-	if( !debugAccountServerURI.empty() )
-	{
+    if( !debugAccountServerURI.empty() )
+    {
         LL_INFOS("Voice") << "Overriding account server based on VivoxDebugVoiceAccountServerURI: "
                           << debugAccountServerURI << LL_ENDL;
-		mVoiceAccountServerURI = debugAccountServerURI;
-	}
+        mVoiceAccountServerURI = debugAccountServerURI;
+    }
 
-	if( mVoiceAccountServerURI.empty() )
-	{
-		// If the account server URI isn't specified, construct it from the SIP URI hostname
-		mVoiceAccountServerURI = "https://www." + mVoiceSIPURIHostName + "/api2/";
+    if( mVoiceAccountServerURI.empty() )
+    {
+        // If the account server URI isn't specified, construct it from the SIP URI hostname
+        mVoiceAccountServerURI = "https://www." + mVoiceSIPURIHostName + "/api2/";
         LL_INFOS("Voice") << "Inferring account server based on SIP URI Host name: "
                           << mVoiceAccountServerURI << LL_ENDL;
-	}
+    }
 }
 
 void LLVivoxVoiceClient::idle(void* user_data)
@@ -1015,7 +1015,7 @@ bool LLVivoxVoiceClient::startAndLaunchDaemon()
             {
                 LLFile::rename(new_log, old_log);
             }
- 
+
             if (!shutdown_timeout().empty())
             {
                 params.args.add("-st");
@@ -1362,7 +1362,7 @@ bool LLVivoxVoiceClient::breakVoiceConnection(bool corowait)
     }
 
     LL_DEBUGS("Voice") << "closing SLVoice socket" << LL_ENDL;
-    closeSocket();		// Need to do this now -- bad things happen if the destructor does it later.
+    closeSocket();      // Need to do this now -- bad things happen if the destructor does it later.
     cleanUp();
     sConnected = false;
 
@@ -1842,7 +1842,7 @@ bool LLVivoxVoiceClient::terminateAudioSession(bool wait)
                 {
                     time_t now = time(NULL);
                     const size_t BUF_SIZE = 64;
-                    char time_str[BUF_SIZE];	/* Flawfinder: ignore */
+                    char time_str[BUF_SIZE];    /* Flawfinder: ignore */
 
                     strftime(time_str, BUF_SIZE, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
                     savepath += time_str;
@@ -2428,397 +2428,397 @@ bool LLVivoxVoiceClient::performMicTuning()
 
 void LLVivoxVoiceClient::closeSocket(void)
 {
-	mSocket.reset();
+    mSocket.reset();
     sConnected = false;
-	mConnectorEstablished = false;
-	mAccountLoggedIn = false;
+    mConnectorEstablished = false;
+    mAccountLoggedIn = false;
 }
 
 void LLVivoxVoiceClient::loginSendMessage()
 {
-	std::ostringstream stream;
+    std::ostringstream stream;
 
-	bool autoPostCrashDumps = gSavedSettings.getBOOL("VivoxAutoPostCrashDumps");
+    bool autoPostCrashDumps = gSavedSettings.getBOOL("VivoxAutoPostCrashDumps");
 
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.Login.1\">"
-		<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-		<< "<AccountName>" << mAccountName << "</AccountName>"
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.Login.1\">"
+        << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+        << "<AccountName>" << mAccountName << "</AccountName>"
         << "<AccountPassword>" << mAccountPassword << "</AccountPassword>"
         << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-		<< "<AudioSessionAnswerMode>VerifyAnswer</AudioSessionAnswerMode>"
-		<< "<EnableBuddiesAndPresence>false</EnableBuddiesAndPresence>"
-		<< "<EnablePresencePersistence>0</EnablePresencePersistence>"
-		<< "<BuddyManagementMode>Application</BuddyManagementMode>"
-		<< "<ParticipantPropertyFrequency>5</ParticipantPropertyFrequency>"
-		<< (autoPostCrashDumps?"<AutopostCrashDumps>true</AutopostCrashDumps>":"")
-	<< "</Request>\n\n\n";
+        << "<AudioSessionAnswerMode>VerifyAnswer</AudioSessionAnswerMode>"
+        << "<EnableBuddiesAndPresence>false</EnableBuddiesAndPresence>"
+        << "<EnablePresencePersistence>0</EnablePresencePersistence>"
+        << "<BuddyManagementMode>Application</BuddyManagementMode>"
+        << "<ParticipantPropertyFrequency>5</ParticipantPropertyFrequency>"
+        << (autoPostCrashDumps?"<AutopostCrashDumps>true</AutopostCrashDumps>":"")
+    << "</Request>\n\n\n";
 
     LL_INFOS("Voice") << "Attempting voice login" << LL_ENDL;
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::logout()
 {
-	// Ensure that we'll re-request provisioning before logging in again
-	mAccountPassword.clear();
-	mVoiceAccountServerURI.clear();
+    // Ensure that we'll re-request provisioning before logging in again
+    mAccountPassword.clear();
+    mVoiceAccountServerURI.clear();
 
-	logoutSendMessage();
+    logoutSendMessage();
 }
 
 void LLVivoxVoiceClient::logoutSendMessage()
 {
-	if(mAccountLoggedIn)
-	{
+    if(mAccountLoggedIn)
+    {
         LL_INFOS("Voice") << "Attempting voice logout" << LL_ENDL;
-		std::ostringstream stream;
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.Logout.1\">"
-			<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-		<< "</Request>"
-		<< "\n\n\n";
+        std::ostringstream stream;
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.Logout.1\">"
+            << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+        << "</Request>"
+        << "\n\n\n";
 
-		mAccountLoggedIn = false;
+        mAccountLoggedIn = false;
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::sessionGroupCreateSendMessage()
 {
-	if(mAccountLoggedIn)
-	{
-		std::ostringstream stream;
+    if(mAccountLoggedIn)
+    {
+        std::ostringstream stream;
 
-		LL_DEBUGS("Voice") << "creating session group" << LL_ENDL;
+        LL_DEBUGS("Voice") << "creating session group" << LL_ENDL;
 
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.Create.1\">"
-			<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-			<< "<Type>Normal</Type>"
-		<< "</Request>"
-		<< "\n\n\n";
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.Create.1\">"
+            << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+            << "<Type>Normal</Type>"
+        << "</Request>"
+        << "\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::sessionCreateSendMessage(const sessionStatePtr_t &session, bool startAudio, bool startText)
 {
-	S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
-	LL_DEBUGS("Voice") << "Requesting create: " << session->mSIPURI
+    S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
+    LL_DEBUGS("Voice") << "Requesting create: " << session->mSIPURI
                        << " with voice font: " << session->mVoiceFontID << " (" << font_index << ")"
                        << LL_ENDL;
 
-	session->mCreateInProgress = true;
-	if(startAudio)
-	{
-		session->mMediaConnectInProgress = true;
-	}
-
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << session->mSIPURI << "\" action=\"Session.Create.1\">"
-		<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-		<< "<URI>" << session->mSIPURI << "</URI>";
-
-	static const std::string allowed_chars =
-				"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-				"0123456789"
-				"-._~";
-
-	if(!session->mHash.empty())
-	{
-		stream
-			<< "<Password>" << LLURI::escape(session->mHash, allowed_chars) << "</Password>"
-			<< "<PasswordHashAlgorithm>SHA1UserName</PasswordHashAlgorithm>";
-	}
-
-	stream
-		<< "<ConnectAudio>" << (startAudio?"true":"false") << "</ConnectAudio>"
-		<< "<ConnectText>" << (startText?"true":"false") << "</ConnectText>"
-		<< "<VoiceFontID>" << font_index << "</VoiceFontID>"
-		<< "<Name>" << mChannelName << "</Name>"
-	<< "</Request>\n\n\n";
+    session->mCreateInProgress = true;
+    if(startAudio)
+    {
+        session->mMediaConnectInProgress = true;
+    }
+
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << session->mSIPURI << "\" action=\"Session.Create.1\">"
+        << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+        << "<URI>" << session->mSIPURI << "</URI>";
+
+    static const std::string allowed_chars =
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+                "0123456789"
+                "-._~";
+
+    if(!session->mHash.empty())
+    {
+        stream
+            << "<Password>" << LLURI::escape(session->mHash, allowed_chars) << "</Password>"
+            << "<PasswordHashAlgorithm>SHA1UserName</PasswordHashAlgorithm>";
+    }
+
+    stream
+        << "<ConnectAudio>" << (startAudio?"true":"false") << "</ConnectAudio>"
+        << "<ConnectText>" << (startText?"true":"false") << "</ConnectText>"
+        << "<VoiceFontID>" << font_index << "</VoiceFontID>"
+        << "<Name>" << mChannelName << "</Name>"
+    << "</Request>\n\n\n";
     LL_WARNS("Voice") << "Session.Create: " << stream.str() << LL_ENDL;
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::sessionGroupAddSessionSendMessage(const sessionStatePtr_t &session, bool startAudio, bool startText)
 {
-	LL_DEBUGS("Voice") << "Requesting create: " << session->mSIPURI << LL_ENDL;
-
-	S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
-	LL_DEBUGS("Voice") << "With voice font: " << session->mVoiceFontID << " (" << font_index << ")" << LL_ENDL;
-
-	session->mCreateInProgress = true;
-	if(startAudio)
-	{
-		session->mMediaConnectInProgress = true;
-	}
-
-	std::string password;
-	if(!session->mHash.empty())
-	{
-		static const std::string allowed_chars =
-					"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-					"0123456789"
-					"-._~"
-					;
-		password = LLURI::escape(session->mHash, allowed_chars);
-	}
-
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << session->mSIPURI << "\" action=\"SessionGroup.AddSession.1\">"
-		<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
-		<< "<URI>" << session->mSIPURI << "</URI>"
-		<< "<Name>" << mChannelName << "</Name>"
-		<< "<ConnectAudio>" << (startAudio?"true":"false") << "</ConnectAudio>"
-		<< "<ConnectText>" << (startText?"true":"false") << "</ConnectText>"
-		<< "<VoiceFontID>" << font_index << "</VoiceFontID>"
-		<< "<Password>" << password << "</Password>"
-		<< "<PasswordHashAlgorithm>SHA1UserName</PasswordHashAlgorithm>"
-	<< "</Request>\n\n\n"
-	;
-
-	writeString(stream.str());
+    LL_DEBUGS("Voice") << "Requesting create: " << session->mSIPURI << LL_ENDL;
+
+    S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
+    LL_DEBUGS("Voice") << "With voice font: " << session->mVoiceFontID << " (" << font_index << ")" << LL_ENDL;
+
+    session->mCreateInProgress = true;
+    if(startAudio)
+    {
+        session->mMediaConnectInProgress = true;
+    }
+
+    std::string password;
+    if(!session->mHash.empty())
+    {
+        static const std::string allowed_chars =
+                    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+                    "0123456789"
+                    "-._~"
+                    ;
+        password = LLURI::escape(session->mHash, allowed_chars);
+    }
+
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << session->mSIPURI << "\" action=\"SessionGroup.AddSession.1\">"
+        << "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
+        << "<URI>" << session->mSIPURI << "</URI>"
+        << "<Name>" << mChannelName << "</Name>"
+        << "<ConnectAudio>" << (startAudio?"true":"false") << "</ConnectAudio>"
+        << "<ConnectText>" << (startText?"true":"false") << "</ConnectText>"
+        << "<VoiceFontID>" << font_index << "</VoiceFontID>"
+        << "<Password>" << password << "</Password>"
+        << "<PasswordHashAlgorithm>SHA1UserName</PasswordHashAlgorithm>"
+    << "</Request>\n\n\n"
+    ;
+
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::sessionMediaConnectSendMessage(const sessionStatePtr_t &session)
 {
-	S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
-	LL_DEBUGS("Voice") << "Connecting audio to session handle: " << session->mHandle
+    S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
+    LL_DEBUGS("Voice") << "Connecting audio to session handle: " << session->mHandle
                        << " with voice font: " << session->mVoiceFontID << " (" << font_index << ")"
                        << LL_ENDL;
 
-	session->mMediaConnectInProgress = true;
+    session->mMediaConnectInProgress = true;
 
-	std::ostringstream stream;
+    std::ostringstream stream;
 
-	stream
-	<< "<Request requestId=\"" << session->mHandle << "\" action=\"Session.MediaConnect.1\">"
-		<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
-		<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
-		<< "<VoiceFontID>" << font_index << "</VoiceFontID>"
-		<< "<Media>Audio</Media>"
-	<< "</Request>\n\n\n";
+    stream
+    << "<Request requestId=\"" << session->mHandle << "\" action=\"Session.MediaConnect.1\">"
+        << "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
+        << "<SessionHandle>" << session->mHandle << "</SessionHandle>"
+        << "<VoiceFontID>" << font_index << "</VoiceFontID>"
+        << "<Media>Audio</Media>"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::sessionTextConnectSendMessage(const sessionStatePtr_t &session)
 {
-	LL_DEBUGS("Voice") << "connecting text to session handle: " << session->mHandle << LL_ENDL;
+    LL_DEBUGS("Voice") << "connecting text to session handle: " << session->mHandle << LL_ENDL;
 
-	std::ostringstream stream;
+    std::ostringstream stream;
 
-	stream
-	<< "<Request requestId=\"" << session->mHandle << "\" action=\"Session.TextConnect.1\">"
-		<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
-		<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
-	<< "</Request>\n\n\n";
+    stream
+    << "<Request requestId=\"" << session->mHandle << "\" action=\"Session.TextConnect.1\">"
+        << "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
+        << "<SessionHandle>" << session->mHandle << "</SessionHandle>"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::sessionTerminate()
 {
-	mSessionTerminateRequested = true;
+    mSessionTerminateRequested = true;
 }
 
 void LLVivoxVoiceClient::requestRelog()
 {
-	mSessionTerminateRequested = true;
-	mRelogRequested = true;
+    mSessionTerminateRequested = true;
+    mRelogRequested = true;
 }
 
 
 void LLVivoxVoiceClient::leaveAudioSession()
 {
-	if(mAudioSession)
-	{
-		LL_DEBUGS("Voice") << "leaving session: " << mAudioSession->mSIPURI << LL_ENDL;
+    if(mAudioSession)
+    {
+        LL_DEBUGS("Voice") << "leaving session: " << mAudioSession->mSIPURI << LL_ENDL;
 
-		if(!mAudioSession->mHandle.empty())
-		{
+        if(!mAudioSession->mHandle.empty())
+        {
 
 #if RECORD_EVERYTHING
-			// HACK: for testing only
-			// Save looped recording
-			std::string savepath("/tmp/vivoxrecording");
-			{
-				time_t now = time(NULL);
-				const size_t BUF_SIZE = 64;
-				char time_str[BUF_SIZE];	/* Flawfinder: ignore */
-
-				strftime(time_str, BUF_SIZE, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
-				savepath += time_str;
-			}
-			recordingLoopSave(savepath);
+            // HACK: for testing only
+            // Save looped recording
+            std::string savepath("/tmp/vivoxrecording");
+            {
+                time_t now = time(NULL);
+                const size_t BUF_SIZE = 64;
+                char time_str[BUF_SIZE];    /* Flawfinder: ignore */
+
+                strftime(time_str, BUF_SIZE, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
+                savepath += time_str;
+            }
+            recordingLoopSave(savepath);
 #endif
 
-			sessionMediaDisconnectSendMessage(mAudioSession);
-		}
-		else
-		{
-			LL_WARNS("Voice") << "called with no session handle" << LL_ENDL;
-		}
-	}
-	else
-	{
-		LL_WARNS("Voice") << "called with no active session" << LL_ENDL;
-	}
+            sessionMediaDisconnectSendMessage(mAudioSession);
+        }
+        else
+        {
+            LL_WARNS("Voice") << "called with no session handle" << LL_ENDL;
+        }
+    }
+    else
+    {
+        LL_WARNS("Voice") << "called with no active session" << LL_ENDL;
+    }
     sessionTerminate();
 }
 
 void LLVivoxVoiceClient::sessionTerminateSendMessage(const sessionStatePtr_t &session)
 {
-	std::ostringstream stream;
+    std::ostringstream stream;
 
-	sessionGroupTerminateSendMessage(session);
-	return;
-	/*
-	LL_DEBUGS("Voice") << "Sending Session.Terminate with handle " << session->mHandle << LL_ENDL;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.Terminate.1\">"
-		<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
-	<< "</Request>\n\n\n";
+    sessionGroupTerminateSendMessage(session);
+    return;
+    /*
+    LL_DEBUGS("Voice") << "Sending Session.Terminate with handle " << session->mHandle << LL_ENDL;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.Terminate.1\">"
+        << "<SessionHandle>" << session->mHandle << "</SessionHandle>"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
-	*/
+    writeString(stream.str());
+    */
 }
 
 void LLVivoxVoiceClient::sessionGroupTerminateSendMessage(const sessionStatePtr_t &session)
 {
-	std::ostringstream stream;
+    std::ostringstream stream;
 
-	LL_DEBUGS("Voice") << "Sending SessionGroup.Terminate with handle " << session->mGroupHandle << LL_ENDL;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.Terminate.1\">"
-		<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
-	<< "</Request>\n\n\n";
+    LL_DEBUGS("Voice") << "Sending SessionGroup.Terminate with handle " << session->mGroupHandle << LL_ENDL;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.Terminate.1\">"
+        << "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::sessionMediaDisconnectSendMessage(const sessionStatePtr_t &session)
 {
-	std::ostringstream stream;
-	sessionGroupTerminateSendMessage(session);
-	return;
-	/*
-	LL_DEBUGS("Voice") << "Sending Session.MediaDisconnect with handle " << session->mHandle << LL_ENDL;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.MediaDisconnect.1\">"
-		<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
-		<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
-		<< "<Media>Audio</Media>"
-	<< "</Request>\n\n\n";
+    std::ostringstream stream;
+    sessionGroupTerminateSendMessage(session);
+    return;
+    /*
+    LL_DEBUGS("Voice") << "Sending Session.MediaDisconnect with handle " << session->mHandle << LL_ENDL;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.MediaDisconnect.1\">"
+        << "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
+        << "<SessionHandle>" << session->mHandle << "</SessionHandle>"
+        << "<Media>Audio</Media>"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
-	*/
+    writeString(stream.str());
+    */
 
 }
 
 
 void LLVivoxVoiceClient::getCaptureDevicesSendMessage()
 {
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.GetCaptureDevices.1\">"
-	<< "</Request>\n\n\n";
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.GetCaptureDevices.1\">"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::getRenderDevicesSendMessage()
 {
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.GetRenderDevices.1\">"
-	<< "</Request>\n\n\n";
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.GetRenderDevices.1\">"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::clearCaptureDevices()
 {
-	LL_DEBUGS("Voice") << "called" << LL_ENDL;
-	mCaptureDevices.clear();
+    LL_DEBUGS("Voice") << "called" << LL_ENDL;
+    mCaptureDevices.clear();
 }
 
 void LLVivoxVoiceClient::addCaptureDevice(const LLVoiceDevice& device)
 {
-	LL_DEBUGS("Voice") << "display: '" << device.display_name << "' device: '" << device.full_name << "'" << LL_ENDL;
+    LL_DEBUGS("Voice") << "display: '" << device.display_name << "' device: '" << device.full_name << "'" << LL_ENDL;
     mCaptureDevices.push_back(device);
 }
 
 LLVoiceDeviceList& LLVivoxVoiceClient::getCaptureDevices()
 {
-	return mCaptureDevices;
+    return mCaptureDevices;
 }
 
 void LLVivoxVoiceClient::setCaptureDevice(const std::string& name)
 {
-	if(name == "Default")
-	{
-		if(!mCaptureDevice.empty())
-		{
-			mCaptureDevice.clear();
-			mCaptureDeviceDirty = true;
-		}
-	}
-	else
-	{
-		if(mCaptureDevice != name)
-		{
-			mCaptureDevice = name;
-			mCaptureDeviceDirty = true;
-		}
-	}
+    if(name == "Default")
+    {
+        if(!mCaptureDevice.empty())
+        {
+            mCaptureDevice.clear();
+            mCaptureDeviceDirty = true;
+        }
+    }
+    else
+    {
+        if(mCaptureDevice != name)
+        {
+            mCaptureDevice = name;
+            mCaptureDeviceDirty = true;
+        }
+    }
 }
 void LLVivoxVoiceClient::setDevicesListUpdated(bool state)
 {
-	mDevicesListUpdated = state;
+    mDevicesListUpdated = state;
 }
 
 void LLVivoxVoiceClient::clearRenderDevices()
 {
-	LL_DEBUGS("Voice") << "called" << LL_ENDL;
-	mRenderDevices.clear();
+    LL_DEBUGS("Voice") << "called" << LL_ENDL;
+    mRenderDevices.clear();
 }
 
 void LLVivoxVoiceClient::addRenderDevice(const LLVoiceDevice& device)
 {
-	LL_DEBUGS("Voice") << "display: '" << device.display_name << "' device: '" << device.full_name << "'" << LL_ENDL;
+    LL_DEBUGS("Voice") << "display: '" << device.display_name << "' device: '" << device.full_name << "'" << LL_ENDL;
     mRenderDevices.push_back(device);
 }
 
 LLVoiceDeviceList& LLVivoxVoiceClient::getRenderDevices()
 {
-	return mRenderDevices;
+    return mRenderDevices;
 }
 
 void LLVivoxVoiceClient::setRenderDevice(const std::string& name)
 {
-	if(name == "Default")
-	{
-		if(!mRenderDevice.empty())
-		{
-			mRenderDevice.clear();
-			mRenderDeviceDirty = true;
-		}
-	}
-	else
-	{
-		if(mRenderDevice != name)
-		{
-			mRenderDevice = name;
-			mRenderDeviceDirty = true;
-		}
-	}
+    if(name == "Default")
+    {
+        if(!mRenderDevice.empty())
+        {
+            mRenderDevice.clear();
+            mRenderDeviceDirty = true;
+        }
+    }
+    else
+    {
+        if(mRenderDevice != name)
+        {
+            mRenderDevice = name;
+            mRenderDeviceDirty = true;
+        }
+    }
 
 }
 
@@ -2832,18 +2832,18 @@ void LLVivoxVoiceClient::tuningStart()
             boost::bind(&LLVivoxVoiceClient::voiceControlCoro, LLVivoxVoiceClient::getInstance()));
     }
     else if (mIsInChannel)
-	{
-		LL_DEBUGS("Voice") << "no channel" << LL_ENDL;
-		sessionTerminate();
-	}
+    {
+        LL_DEBUGS("Voice") << "no channel" << LL_ENDL;
+        sessionTerminate();
+    }
 }
 
 void LLVivoxVoiceClient::tuningStop()
 {
-	mTuningMode = false;
-	// force a renegotiation.
-	mCurrentParcelLocalID = 0;
-	mCurrentRegionName = "";
+    mTuningMode = false;
+    // force a renegotiation.
+    mCurrentParcelLocalID = 0;
+    mCurrentRegionName = "";
 }
 
 bool LLVivoxVoiceClient::inTuningMode()
@@ -2853,250 +2853,250 @@ bool LLVivoxVoiceClient::inTuningMode()
 
 void LLVivoxVoiceClient::tuningRenderStartSendMessage(const std::string& name, bool loop)
 {
-	mTuningAudioFile = name;
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.RenderAudioStart.1\">"
+    mTuningAudioFile = name;
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.RenderAudioStart.1\">"
     << "<SoundFilePath>" << mTuningAudioFile << "</SoundFilePath>"
     << "<Loop>" << (loop?"1":"0") << "</Loop>"
-	<< "</Request>\n\n\n";
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::tuningRenderStopSendMessage()
 {
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.RenderAudioStop.1\">"
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.RenderAudioStop.1\">"
     << "<SoundFilePath>" << mTuningAudioFile << "</SoundFilePath>"
-	<< "</Request>\n\n\n";
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::tuningCaptureStartSendMessage(int loop)
 {
-	LL_DEBUGS("Voice") << "sending CaptureAudioStart" << LL_ENDL;
+    LL_DEBUGS("Voice") << "sending CaptureAudioStart" << LL_ENDL;
 
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.CaptureAudioStart.1\">"
-	<< "<Duration>-1</Duration>"
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.CaptureAudioStart.1\">"
+    << "<Duration>-1</Duration>"
     << "<LoopToRenderDevice>" << loop << "</LoopToRenderDevice>"
-	<< "</Request>\n\n\n";
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::tuningCaptureStopSendMessage()
 {
-	LL_DEBUGS("Voice") << "sending CaptureAudioStop" << LL_ENDL;
+    LL_DEBUGS("Voice") << "sending CaptureAudioStop" << LL_ENDL;
 
-	std::ostringstream stream;
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.CaptureAudioStop.1\">"
-	<< "</Request>\n\n\n";
+    std::ostringstream stream;
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.CaptureAudioStop.1\">"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 
-	mTuningEnergy = 0.0f;
+    mTuningEnergy = 0.0f;
 }
 
 void LLVivoxVoiceClient::tuningSetMicVolume(float volume)
 {
-	int scaled_volume = scale_mic_volume(volume);
+    int scaled_volume = scale_mic_volume(volume);
 
-	if(scaled_volume != mTuningMicVolume)
-	{
-		mTuningMicVolume = scaled_volume;
-		mTuningMicVolumeDirty = true;
-	}
+    if(scaled_volume != mTuningMicVolume)
+    {
+        mTuningMicVolume = scaled_volume;
+        mTuningMicVolumeDirty = true;
+    }
 }
 
 void LLVivoxVoiceClient::tuningSetSpeakerVolume(float volume)
 {
-	int scaled_volume = scale_speaker_volume(volume);
+    int scaled_volume = scale_speaker_volume(volume);
 
-	if(scaled_volume != mTuningSpeakerVolume)
-	{
-		mTuningSpeakerVolume = scaled_volume;
-		mTuningSpeakerVolumeDirty = true;
-	}
+    if(scaled_volume != mTuningSpeakerVolume)
+    {
+        mTuningSpeakerVolume = scaled_volume;
+        mTuningSpeakerVolumeDirty = true;
+    }
 }
 
 float LLVivoxVoiceClient::tuningGetEnergy(void)
 {
-	return mTuningEnergy;
+    return mTuningEnergy;
 }
 
 bool LLVivoxVoiceClient::deviceSettingsAvailable()
 {
-	bool result = true;
+    bool result = true;
 
-	if(!sConnected)
-		result = false;
+    if(!sConnected)
+        result = false;
 
-	if(mRenderDevices.empty())
-		result = false;
+    if(mRenderDevices.empty())
+        result = false;
 
-	return result;
+    return result;
 }
 bool LLVivoxVoiceClient::deviceSettingsUpdated()
 {
     bool updated = mDevicesListUpdated;
-	if (mDevicesListUpdated)
-	{
-		// a hot swap event or a polling of the audio devices has been parsed since the last redraw of the input and output device panel.
-		mDevicesListUpdated = false; // toggle the setting
-	}
-	return updated;
+    if (mDevicesListUpdated)
+    {
+        // a hot swap event or a polling of the audio devices has been parsed since the last redraw of the input and output device panel.
+        mDevicesListUpdated = false; // toggle the setting
+    }
+    return updated;
 }
 
 void LLVivoxVoiceClient::refreshDeviceLists(bool clearCurrentList)
 {
-	if(clearCurrentList)
-	{
-		clearCaptureDevices();
-		clearRenderDevices();
-	}
-	getCaptureDevicesSendMessage();
-	getRenderDevicesSendMessage();
+    if(clearCurrentList)
+    {
+        clearCaptureDevices();
+        clearRenderDevices();
+    }
+    getCaptureDevicesSendMessage();
+    getRenderDevicesSendMessage();
 }
 
 void LLVivoxVoiceClient::daemonDied()
 {
-	// The daemon died, so the connection is gone.  Reset everything and start over.
-	LL_WARNS("Voice") << "Connection to vivox daemon lost.  Resetting state."<< LL_ENDL;
+    // The daemon died, so the connection is gone.  Reset everything and start over.
+    LL_WARNS("Voice") << "Connection to vivox daemon lost.  Resetting state."<< LL_ENDL;
 
-	//TODO: Try to relaunch the daemon
+    //TODO: Try to relaunch the daemon
 }
 
 void LLVivoxVoiceClient::giveUp()
 {
-	// All has failed.  Clean up and stop trying.
+    // All has failed.  Clean up and stop trying.
     LL_WARNS("Voice") << "Terminating Voice Service" << LL_ENDL;
-	closeSocket();
-	cleanUp();
+    closeSocket();
+    cleanUp();
 }
 
 static void oldSDKTransform (LLVector3 &left, LLVector3 &up, LLVector3 &at, LLVector3d &pos, LLVector3 &vel)
 {
-	F32 nat[3], nup[3], nl[3]; // the new at, up, left vectors and the  new position and velocity
-//	F32 nvel[3];
-	F64 npos[3];
-
-	// The original XML command was sent like this:
-	/*
-			<< "<Position>"
-				<< "<X>" << pos[VX] << "</X>"
-				<< "<Y>" << pos[VZ] << "</Y>"
-				<< "<Z>" << pos[VY] << "</Z>"
-			<< "</Position>"
-			<< "<Velocity>"
-				<< "<X>" << mAvatarVelocity[VX] << "</X>"
-				<< "<Y>" << mAvatarVelocity[VZ] << "</Y>"
-				<< "<Z>" << mAvatarVelocity[VY] << "</Z>"
-			<< "</Velocity>"
-			<< "<AtOrientation>"
-				<< "<X>" << l.mV[VX] << "</X>"
-				<< "<Y>" << u.mV[VX] << "</Y>"
-				<< "<Z>" << a.mV[VX] << "</Z>"
-			<< "</AtOrientation>"
-			<< "<UpOrientation>"
-				<< "<X>" << l.mV[VZ] << "</X>"
-				<< "<Y>" << u.mV[VY] << "</Y>"
-				<< "<Z>" << a.mV[VZ] << "</Z>"
-			<< "</UpOrientation>"
-			<< "<LeftOrientation>"
-				<< "<X>" << l.mV [VY] << "</X>"
-				<< "<Y>" << u.mV [VZ] << "</Y>"
-				<< "<Z>" << a.mV [VY] << "</Z>"
-			<< "</LeftOrientation>";
-	*/
+    F32 nat[3], nup[3], nl[3]; // the new at, up, left vectors and the  new position and velocity
+//  F32 nvel[3];
+    F64 npos[3];
+
+    // The original XML command was sent like this:
+    /*
+            << "<Position>"
+                << "<X>" << pos[VX] << "</X>"
+                << "<Y>" << pos[VZ] << "</Y>"
+                << "<Z>" << pos[VY] << "</Z>"
+            << "</Position>"
+            << "<Velocity>"
+                << "<X>" << mAvatarVelocity[VX] << "</X>"
+                << "<Y>" << mAvatarVelocity[VZ] << "</Y>"
+                << "<Z>" << mAvatarVelocity[VY] << "</Z>"
+            << "</Velocity>"
+            << "<AtOrientation>"
+                << "<X>" << l.mV[VX] << "</X>"
+                << "<Y>" << u.mV[VX] << "</Y>"
+                << "<Z>" << a.mV[VX] << "</Z>"
+            << "</AtOrientation>"
+            << "<UpOrientation>"
+                << "<X>" << l.mV[VZ] << "</X>"
+                << "<Y>" << u.mV[VY] << "</Y>"
+                << "<Z>" << a.mV[VZ] << "</Z>"
+            << "</UpOrientation>"
+            << "<LeftOrientation>"
+                << "<X>" << l.mV [VY] << "</X>"
+                << "<Y>" << u.mV [VZ] << "</Y>"
+                << "<Z>" << a.mV [VY] << "</Z>"
+            << "</LeftOrientation>";
+    */
 
 #if 1
-	// This was the original transform done when building the XML command
-	nat[0] = left.mV[VX];
-	nat[1] = up.mV[VX];
-	nat[2] = at.mV[VX];
-
-	nup[0] = left.mV[VZ];
-	nup[1] = up.mV[VY];
-	nup[2] = at.mV[VZ];
-
-	nl[0] = left.mV[VY];
-	nl[1] = up.mV[VZ];
-	nl[2] = at.mV[VY];
-
-	npos[0] = pos.mdV[VX];
-	npos[1] = pos.mdV[VZ];
-	npos[2] = pos.mdV[VY];
-
-//	nvel[0] = vel.mV[VX];
-//	nvel[1] = vel.mV[VZ];
-//	nvel[2] = vel.mV[VY];
-
-	for(int i=0;i<3;++i) {
-		at.mV[i] = nat[i];
-		up.mV[i] = nup[i];
-		left.mV[i] = nl[i];
-		pos.mdV[i] = npos[i];
-	}
-
-	// This was the original transform done in the SDK
-	nat[0] = at.mV[2];
-	nat[1] = 0; // y component of at vector is always 0, this was up[2]
-	nat[2] = -1 * left.mV[2];
-
-	// We override whatever the application gives us
-	nup[0] = 0; // x component of up vector is always 0
-	nup[1] = 1; // y component of up vector is always 1
-	nup[2] = 0; // z component of up vector is always 0
-
-	nl[0] = at.mV[0];
-	nl[1] = 0;  // y component of left vector is always zero, this was up[0]
-	nl[2] = -1 * left.mV[0];
-
-	npos[2] = pos.mdV[2] * -1.0;
-	npos[1] = pos.mdV[1];
-	npos[0] = pos.mdV[0];
-
-	for(int i=0;i<3;++i) {
-		at.mV[i] = nat[i];
-		up.mV[i] = nup[i];
-		left.mV[i] = nl[i];
-		pos.mdV[i] = npos[i];
-	}
+    // This was the original transform done when building the XML command
+    nat[0] = left.mV[VX];
+    nat[1] = up.mV[VX];
+    nat[2] = at.mV[VX];
+
+    nup[0] = left.mV[VZ];
+    nup[1] = up.mV[VY];
+    nup[2] = at.mV[VZ];
+
+    nl[0] = left.mV[VY];
+    nl[1] = up.mV[VZ];
+    nl[2] = at.mV[VY];
+
+    npos[0] = pos.mdV[VX];
+    npos[1] = pos.mdV[VZ];
+    npos[2] = pos.mdV[VY];
+
+//  nvel[0] = vel.mV[VX];
+//  nvel[1] = vel.mV[VZ];
+//  nvel[2] = vel.mV[VY];
+
+    for(int i=0;i<3;++i) {
+        at.mV[i] = nat[i];
+        up.mV[i] = nup[i];
+        left.mV[i] = nl[i];
+        pos.mdV[i] = npos[i];
+    }
+
+    // This was the original transform done in the SDK
+    nat[0] = at.mV[2];
+    nat[1] = 0; // y component of at vector is always 0, this was up[2]
+    nat[2] = -1 * left.mV[2];
+
+    // We override whatever the application gives us
+    nup[0] = 0; // x component of up vector is always 0
+    nup[1] = 1; // y component of up vector is always 1
+    nup[2] = 0; // z component of up vector is always 0
+
+    nl[0] = at.mV[0];
+    nl[1] = 0;  // y component of left vector is always zero, this was up[0]
+    nl[2] = -1 * left.mV[0];
+
+    npos[2] = pos.mdV[2] * -1.0;
+    npos[1] = pos.mdV[1];
+    npos[0] = pos.mdV[0];
+
+    for(int i=0;i<3;++i) {
+        at.mV[i] = nat[i];
+        up.mV[i] = nup[i];
+        left.mV[i] = nl[i];
+        pos.mdV[i] = npos[i];
+    }
 #else
-	// This is the compose of the two transforms (at least, that's what I'm trying for)
-	nat[0] = at.mV[VX];
-	nat[1] = 0; // y component of at vector is always 0, this was up[2]
-	nat[2] = -1 * up.mV[VZ];
-
-	// We override whatever the application gives us
-	nup[0] = 0; // x component of up vector is always 0
-	nup[1] = 1; // y component of up vector is always 1
-	nup[2] = 0; // z component of up vector is always 0
-
-	nl[0] = left.mV[VX];
-	nl[1] = 0;  // y component of left vector is always zero, this was up[0]
-	nl[2] = -1 * left.mV[VY];
-
-	npos[0] = pos.mdV[VX];
-	npos[1] = pos.mdV[VZ];
-	npos[2] = pos.mdV[VY] * -1.0;
-
-	nvel[0] = vel.mV[VX];
-	nvel[1] = vel.mV[VZ];
-	nvel[2] = vel.mV[VY];
-
-	for(int i=0;i<3;++i) {
-		at.mV[i] = nat[i];
-		up.mV[i] = nup[i];
-		left.mV[i] = nl[i];
-		pos.mdV[i] = npos[i];
-	}
+    // This is the compose of the two transforms (at least, that's what I'm trying for)
+    nat[0] = at.mV[VX];
+    nat[1] = 0; // y component of at vector is always 0, this was up[2]
+    nat[2] = -1 * up.mV[VZ];
+
+    // We override whatever the application gives us
+    nup[0] = 0; // x component of up vector is always 0
+    nup[1] = 1; // y component of up vector is always 1
+    nup[2] = 0; // z component of up vector is always 0
+
+    nl[0] = left.mV[VX];
+    nl[1] = 0;  // y component of left vector is always zero, this was up[0]
+    nl[2] = -1 * left.mV[VY];
+
+    npos[0] = pos.mdV[VX];
+    npos[1] = pos.mdV[VZ];
+    npos[2] = pos.mdV[VY] * -1.0;
+
+    nvel[0] = vel.mV[VX];
+    nvel[1] = vel.mV[VZ];
+    nvel[2] = vel.mV[VY];
+
+    for(int i=0;i<3;++i) {
+        at.mV[i] = nat[i];
+        up.mV[i] = nup[i];
+        left.mV[i] = nl[i];
+        pos.mdV[i] = npos[i];
+    }
 
 #endif
 }
@@ -3118,34 +3118,34 @@ void LLVivoxVoiceClient::setHidden(bool hidden)
 
 void LLVivoxVoiceClient::sendPositionAndVolumeUpdate(void)
 {
-	std::ostringstream stream;
+    std::ostringstream stream;
 
-	if (mSpatialCoordsDirty && inSpatialChannel())
-	{
-		LLVector3 l, u, a, vel;
-		LLVector3d pos;
+    if (mSpatialCoordsDirty && inSpatialChannel())
+    {
+        LLVector3 l, u, a, vel;
+        LLVector3d pos;
 
-		mSpatialCoordsDirty = false;
+        mSpatialCoordsDirty = false;
 
-		// Always send both speaker and listener positions together.
-		stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.Set3DPosition.1\">"
-			<< "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>";
+        // Always send both speaker and listener positions together.
+        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.Set3DPosition.1\">"
+            << "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>";
 
-		stream << "<SpeakerPosition>";
+        stream << "<SpeakerPosition>";
 
         LLMatrix3 avatarRot = mAvatarRot.getMatrix3();
 
-//		LL_DEBUGS("Voice") << "Sending speaker position " << mAvatarPosition << LL_ENDL;
-		l = avatarRot.getLeftRow();
-		u = avatarRot.getUpRow();
-		a = avatarRot.getFwdRow();
+//      LL_DEBUGS("Voice") << "Sending speaker position " << mAvatarPosition << LL_ENDL;
+        l = avatarRot.getLeftRow();
+        u = avatarRot.getUpRow();
+        a = avatarRot.getFwdRow();
 
         pos = mAvatarPosition;
-		vel = mAvatarVelocity;
+        vel = mAvatarVelocity;
 
-		// SLIM SDK: the old SDK was doing a transform on the passed coordinates that the new one doesn't do anymore.
-		// The old transform is replicated by this function.
-		oldSDKTransform(l, u, a, pos, vel);
+        // SLIM SDK: the old SDK was doing a transform on the passed coordinates that the new one doesn't do anymore.
+        // The old transform is replicated by this function.
+        oldSDKTransform(l, u, a, pos, vel);
 
         if (mHidden)
         {
@@ -3155,73 +3155,73 @@ void LLVivoxVoiceClient::sendPositionAndVolumeUpdate(void)
             }
         }
 
-		stream
-			<< "<Position>"
-				<< "<X>" << pos.mdV[VX] << "</X>"
-				<< "<Y>" << pos.mdV[VY] << "</Y>"
-				<< "<Z>" << pos.mdV[VZ] << "</Z>"
-			<< "</Position>"
-			<< "<Velocity>"
-				<< "<X>" << vel.mV[VX] << "</X>"
-				<< "<Y>" << vel.mV[VY] << "</Y>"
-				<< "<Z>" << vel.mV[VZ] << "</Z>"
-			<< "</Velocity>"
-			<< "<AtOrientation>"
-				<< "<X>" << a.mV[VX] << "</X>"
-				<< "<Y>" << a.mV[VY] << "</Y>"
-				<< "<Z>" << a.mV[VZ] << "</Z>"
-			<< "</AtOrientation>"
-			<< "<UpOrientation>"
-				<< "<X>" << u.mV[VX] << "</X>"
-				<< "<Y>" << u.mV[VY] << "</Y>"
-				<< "<Z>" << u.mV[VZ] << "</Z>"
-			<< "</UpOrientation>"
-  			<< "<LeftOrientation>"
-  				<< "<X>" << l.mV [VX] << "</X>"
-  				<< "<Y>" << l.mV [VY] << "</Y>"
-  				<< "<Z>" << l.mV [VZ] << "</Z>"
-  			<< "</LeftOrientation>"
+        stream
+            << "<Position>"
+                << "<X>" << pos.mdV[VX] << "</X>"
+                << "<Y>" << pos.mdV[VY] << "</Y>"
+                << "<Z>" << pos.mdV[VZ] << "</Z>"
+            << "</Position>"
+            << "<Velocity>"
+                << "<X>" << vel.mV[VX] << "</X>"
+                << "<Y>" << vel.mV[VY] << "</Y>"
+                << "<Z>" << vel.mV[VZ] << "</Z>"
+            << "</Velocity>"
+            << "<AtOrientation>"
+                << "<X>" << a.mV[VX] << "</X>"
+                << "<Y>" << a.mV[VY] << "</Y>"
+                << "<Z>" << a.mV[VZ] << "</Z>"
+            << "</AtOrientation>"
+            << "<UpOrientation>"
+                << "<X>" << u.mV[VX] << "</X>"
+                << "<Y>" << u.mV[VY] << "</Y>"
+                << "<Z>" << u.mV[VZ] << "</Z>"
+            << "</UpOrientation>"
+            << "<LeftOrientation>"
+                << "<X>" << l.mV [VX] << "</X>"
+                << "<Y>" << l.mV [VY] << "</Y>"
+                << "<Z>" << l.mV [VZ] << "</Z>"
+            << "</LeftOrientation>"
             ;
 
-		stream << "</SpeakerPosition>";
+        stream << "</SpeakerPosition>";
 
-		stream << "<ListenerPosition>";
+        stream << "<ListenerPosition>";
 
-		LLVector3d	earPosition;
-		LLVector3	earVelocity;
-		LLMatrix3	earRot;
+        LLVector3d  earPosition;
+        LLVector3   earVelocity;
+        LLMatrix3   earRot;
 
-		switch(mEarLocation)
-		{
-			case earLocCamera:
-			default:
-				earPosition = mCameraPosition;
-				earVelocity = mCameraVelocity;
-				earRot = mCameraRot;
-			break;
+        switch(mEarLocation)
+        {
+            case earLocCamera:
+            default:
+                earPosition = mCameraPosition;
+                earVelocity = mCameraVelocity;
+                earRot = mCameraRot;
+            break;
 
-			case earLocAvatar:
-				earPosition = mAvatarPosition;
-				earVelocity = mAvatarVelocity;
-				earRot = avatarRot;
-			break;
+            case earLocAvatar:
+                earPosition = mAvatarPosition;
+                earVelocity = mAvatarVelocity;
+                earRot = avatarRot;
+            break;
 
-			case earLocMixed:
-				earPosition = mAvatarPosition;
-				earVelocity = mAvatarVelocity;
-				earRot = mCameraRot;
-			break;
-		}
+            case earLocMixed:
+                earPosition = mAvatarPosition;
+                earVelocity = mAvatarVelocity;
+                earRot = mCameraRot;
+            break;
+        }
 
-		l = earRot.getLeftRow();
-		u = earRot.getUpRow();
-		a = earRot.getFwdRow();
+        l = earRot.getLeftRow();
+        u = earRot.getUpRow();
+        a = earRot.getFwdRow();
 
         pos = earPosition;
-		vel = earVelocity;
+        vel = earVelocity;
 
 
-		oldSDKTransform(l, u, a, pos, vel);
+        oldSDKTransform(l, u, a, pos, vel);
 
         if (mHidden)
         {
@@ -3231,211 +3231,211 @@ void LLVivoxVoiceClient::sendPositionAndVolumeUpdate(void)
             }
         }
 
-		stream
-			<< "<Position>"
-				<< "<X>" << pos.mdV[VX] << "</X>"
-				<< "<Y>" << pos.mdV[VY] << "</Y>"
-				<< "<Z>" << pos.mdV[VZ] << "</Z>"
-			<< "</Position>"
-			<< "<Velocity>"
-				<< "<X>" << vel.mV[VX] << "</X>"
-				<< "<Y>" << vel.mV[VY] << "</Y>"
-				<< "<Z>" << vel.mV[VZ] << "</Z>"
-			<< "</Velocity>"
-			<< "<AtOrientation>"
-				<< "<X>" << a.mV[VX] << "</X>"
-				<< "<Y>" << a.mV[VY] << "</Y>"
-				<< "<Z>" << a.mV[VZ] << "</Z>"
-			<< "</AtOrientation>"
-			<< "<UpOrientation>"
-				<< "<X>" << u.mV[VX] << "</X>"
-				<< "<Y>" << u.mV[VY] << "</Y>"
-				<< "<Z>" << u.mV[VZ] << "</Z>"
-			<< "</UpOrientation>"
-  			<< "<LeftOrientation>"
-  				<< "<X>" << l.mV [VX] << "</X>"
-  				<< "<Y>" << l.mV [VY] << "</Y>"
-  				<< "<Z>" << l.mV [VZ] << "</Z>"
-  			<< "</LeftOrientation>"
+        stream
+            << "<Position>"
+                << "<X>" << pos.mdV[VX] << "</X>"
+                << "<Y>" << pos.mdV[VY] << "</Y>"
+                << "<Z>" << pos.mdV[VZ] << "</Z>"
+            << "</Position>"
+            << "<Velocity>"
+                << "<X>" << vel.mV[VX] << "</X>"
+                << "<Y>" << vel.mV[VY] << "</Y>"
+                << "<Z>" << vel.mV[VZ] << "</Z>"
+            << "</Velocity>"
+            << "<AtOrientation>"
+                << "<X>" << a.mV[VX] << "</X>"
+                << "<Y>" << a.mV[VY] << "</Y>"
+                << "<Z>" << a.mV[VZ] << "</Z>"
+            << "</AtOrientation>"
+            << "<UpOrientation>"
+                << "<X>" << u.mV[VX] << "</X>"
+                << "<Y>" << u.mV[VY] << "</Y>"
+                << "<Z>" << u.mV[VZ] << "</Z>"
+            << "</UpOrientation>"
+            << "<LeftOrientation>"
+                << "<X>" << l.mV [VX] << "</X>"
+                << "<Y>" << l.mV [VY] << "</Y>"
+                << "<Z>" << l.mV [VZ] << "</Z>"
+            << "</LeftOrientation>"
             ;
 
-		stream << "</ListenerPosition>";
-
-		stream << "<ReqDispositionType>1</ReqDispositionType>";  //do not generate responses for update requests
-		stream << "</Request>\n\n\n";
-	}
-
-	if(mAudioSession && (mAudioSession->mVolumeDirty || mAudioSession->mMuteDirty))
-	{
-		participantMap::iterator iter = mAudioSession->mParticipantsByURI.begin();
-
-		mAudioSession->mVolumeDirty = false;
-		mAudioSession->mMuteDirty = false;
-
-		for(; iter != mAudioSession->mParticipantsByURI.end(); iter++)
-		{
-			participantStatePtr_t p(iter->second);
-
-			if(p->mVolumeDirty)
-			{
-				// Can't set volume/mute for yourself
-				if(!p->mIsSelf)
-				{
-					// scale from the range 0.0-1.0 to vivox volume in the range 0-100
-					S32 volume = ll_round(p->mVolume / VOLUME_SCALE_VIVOX);
-					bool mute = p->mOnMuteList;
-
-					if(mute)
-					{
-						// SetParticipantMuteForMe doesn't work in p2p sessions.
-						// If we want the user to be muted, set their volume to 0 as well.
-						// This isn't perfect, but it will at least reduce their volume to a minimum.
-						volume = 0;
-						// Mark the current volume level as set to prevent incoming events
-						// changing it to 0, so that we can return to it when unmuting.
-						p->mVolumeSet = true;
-					}
-
-					if(volume == 0)
-					{
-						mute = true;
-					}
-
-					LL_DEBUGS("Voice") << "Setting volume/mute for avatar " << p->mAvatarID << " to " << volume << (mute?"/true":"/false") << LL_ENDL;
-
-					// SLIM SDK: Send both volume and mute commands.
-
-					// Send a "volume for me" command for the user.
-					stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.SetParticipantVolumeForMe.1\">"
-						<< "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>"
-						<< "<ParticipantURI>" << p->mURI << "</ParticipantURI>"
-						<< "<Volume>" << volume << "</Volume>"
-						<< "</Request>\n\n\n";
-
-					if(!mAudioSession->mIsP2P)
-					  {
-					    // Send a "mute for me" command for the user
-					    // Doesn't work in P2P sessions
-					    stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.SetParticipantMuteForMe.1\">"
-					      << "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>"
-					      << "<ParticipantURI>" << p->mURI << "</ParticipantURI>"
-					      << "<Mute>" << (mute?"1":"0") << "</Mute>"
-					      << "<Scope>Audio</Scope>"
-					      << "</Request>\n\n\n";
-					    }
-				}
-
-				p->mVolumeDirty = false;
-			}
-		}
-	}
+        stream << "</ListenerPosition>";
+
+        stream << "<ReqDispositionType>1</ReqDispositionType>";  //do not generate responses for update requests
+        stream << "</Request>\n\n\n";
+    }
+
+    if(mAudioSession && (mAudioSession->mVolumeDirty || mAudioSession->mMuteDirty))
+    {
+        participantMap::iterator iter = mAudioSession->mParticipantsByURI.begin();
+
+        mAudioSession->mVolumeDirty = false;
+        mAudioSession->mMuteDirty = false;
+
+        for(; iter != mAudioSession->mParticipantsByURI.end(); iter++)
+        {
+            participantStatePtr_t p(iter->second);
+
+            if(p->mVolumeDirty)
+            {
+                // Can't set volume/mute for yourself
+                if(!p->mIsSelf)
+                {
+                    // scale from the range 0.0-1.0 to vivox volume in the range 0-100
+                    S32 volume = ll_round(p->mVolume / VOLUME_SCALE_VIVOX);
+                    bool mute = p->mOnMuteList;
+
+                    if(mute)
+                    {
+                        // SetParticipantMuteForMe doesn't work in p2p sessions.
+                        // If we want the user to be muted, set their volume to 0 as well.
+                        // This isn't perfect, but it will at least reduce their volume to a minimum.
+                        volume = 0;
+                        // Mark the current volume level as set to prevent incoming events
+                        // changing it to 0, so that we can return to it when unmuting.
+                        p->mVolumeSet = true;
+                    }
+
+                    if(volume == 0)
+                    {
+                        mute = true;
+                    }
+
+                    LL_DEBUGS("Voice") << "Setting volume/mute for avatar " << p->mAvatarID << " to " << volume << (mute?"/true":"/false") << LL_ENDL;
+
+                    // SLIM SDK: Send both volume and mute commands.
+
+                    // Send a "volume for me" command for the user.
+                    stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.SetParticipantVolumeForMe.1\">"
+                        << "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>"
+                        << "<ParticipantURI>" << p->mURI << "</ParticipantURI>"
+                        << "<Volume>" << volume << "</Volume>"
+                        << "</Request>\n\n\n";
+
+                    if(!mAudioSession->mIsP2P)
+                      {
+                        // Send a "mute for me" command for the user
+                        // Doesn't work in P2P sessions
+                        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.SetParticipantMuteForMe.1\">"
+                          << "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>"
+                          << "<ParticipantURI>" << p->mURI << "</ParticipantURI>"
+                          << "<Mute>" << (mute?"1":"0") << "</Mute>"
+                          << "<Scope>Audio</Scope>"
+                          << "</Request>\n\n\n";
+                        }
+                }
+
+                p->mVolumeDirty = false;
+            }
+        }
+    }
 
     std::string update(stream.str());
-	if(!update.empty())
-	{
+    if(!update.empty())
+    {
         LL_DEBUGS("VoiceUpdate") << "sending update " << update << LL_ENDL;
-		writeString(update);
-	}
+        writeString(update);
+    }
 
 }
 
 void LLVivoxVoiceClient::buildSetCaptureDevice(std::ostringstream &stream)
 {
-	if(mCaptureDeviceDirty)
-	{
-		LL_DEBUGS("Voice") << "Setting input device = \"" << mCaptureDevice << "\"" << LL_ENDL;
+    if(mCaptureDeviceDirty)
+    {
+        LL_DEBUGS("Voice") << "Setting input device = \"" << mCaptureDevice << "\"" << LL_ENDL;
 
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.SetCaptureDevice.1\">"
-			<< "<CaptureDeviceSpecifier>" << mCaptureDevice << "</CaptureDeviceSpecifier>"
-		<< "</Request>"
-		<< "\n\n\n";
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.SetCaptureDevice.1\">"
+            << "<CaptureDeviceSpecifier>" << mCaptureDevice << "</CaptureDeviceSpecifier>"
+        << "</Request>"
+        << "\n\n\n";
 
-		mCaptureDeviceDirty = false;
-	}
+        mCaptureDeviceDirty = false;
+    }
 }
 
 void LLVivoxVoiceClient::buildSetRenderDevice(std::ostringstream &stream)
 {
-	if(mRenderDeviceDirty)
-	{
-		LL_DEBUGS("Voice") << "Setting output device = \"" << mRenderDevice << "\"" << LL_ENDL;
-
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.SetRenderDevice.1\">"
-			<< "<RenderDeviceSpecifier>" << mRenderDevice << "</RenderDeviceSpecifier>"
-		<< "</Request>"
-		<< "\n\n\n";
-		mRenderDeviceDirty = false;
-	}
+    if(mRenderDeviceDirty)
+    {
+        LL_DEBUGS("Voice") << "Setting output device = \"" << mRenderDevice << "\"" << LL_ENDL;
+
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.SetRenderDevice.1\">"
+            << "<RenderDeviceSpecifier>" << mRenderDevice << "</RenderDeviceSpecifier>"
+        << "</Request>"
+        << "\n\n\n";
+        mRenderDeviceDirty = false;
+    }
 }
 
 void LLVivoxVoiceClient::sendLocalAudioUpdates()
 {
-	// Check all of the dirty states and then send messages to those needing to be changed.
-	// Tuningmode hands its own mute settings.
-	std::ostringstream stream;
+    // Check all of the dirty states and then send messages to those needing to be changed.
+    // Tuningmode hands its own mute settings.
+    std::ostringstream stream;
 
-	if (mMuteMicDirty && !mTuningMode)
-	{
-		mMuteMicDirty = false;
+    if (mMuteMicDirty && !mTuningMode)
+    {
+        mMuteMicDirty = false;
 
-		// Send a local mute command.
+        // Send a local mute command.
 
-		LL_INFOS("Voice") << "Sending MuteLocalMic command with parameter " << (mMuteMic ? "true" : "false") << LL_ENDL;
+        LL_INFOS("Voice") << "Sending MuteLocalMic command with parameter " << (mMuteMic ? "true" : "false") << LL_ENDL;
 
-		stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalMic.1\">"
-			<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-			<< "<Value>" << (mMuteMic ? "true" : "false") << "</Value>"
-			<< "</Request>\n\n\n";
+        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalMic.1\">"
+            << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+            << "<Value>" << (mMuteMic ? "true" : "false") << "</Value>"
+            << "</Request>\n\n\n";
 
-	}
+    }
 
-	if (mSpeakerMuteDirty && !mTuningMode)
-	{
-		const char *muteval = ((mSpeakerVolume <= scale_speaker_volume(0)) ? "true" : "false");
+    if (mSpeakerMuteDirty && !mTuningMode)
+    {
+        const char *muteval = ((mSpeakerVolume <= scale_speaker_volume(0)) ? "true" : "false");
 
-		mSpeakerMuteDirty = false;
+        mSpeakerMuteDirty = false;
 
-		LL_INFOS("Voice") << "Setting speaker mute to " << muteval << LL_ENDL;
+        LL_INFOS("Voice") << "Setting speaker mute to " << muteval << LL_ENDL;
 
-		stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalSpeaker.1\">"
-			<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-			<< "<Value>" << muteval << "</Value>"
-			<< "</Request>\n\n\n";
+        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalSpeaker.1\">"
+            << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+            << "<Value>" << muteval << "</Value>"
+            << "</Request>\n\n\n";
 
-	}
+    }
 
-	if (mSpeakerVolumeDirty)
-	{
-		mSpeakerVolumeDirty = false;
+    if (mSpeakerVolumeDirty)
+    {
+        mSpeakerVolumeDirty = false;
 
-		LL_INFOS("Voice") << "Setting speaker volume to " << mSpeakerVolume << LL_ENDL;
+        LL_INFOS("Voice") << "Setting speaker volume to " << mSpeakerVolume << LL_ENDL;
 
-		stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.SetLocalSpeakerVolume.1\">"
-			<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-			<< "<Value>" << mSpeakerVolume << "</Value>"
-			<< "</Request>\n\n\n";
+        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.SetLocalSpeakerVolume.1\">"
+            << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+            << "<Value>" << mSpeakerVolume << "</Value>"
+            << "</Request>\n\n\n";
 
-	}
+    }
 
-	if (mMicVolumeDirty)
-	{
-		mMicVolumeDirty = false;
+    if (mMicVolumeDirty)
+    {
+        mMicVolumeDirty = false;
 
-		LL_INFOS("Voice") << "Setting mic volume to " << mMicVolume << LL_ENDL;
+        LL_INFOS("Voice") << "Setting mic volume to " << mMicVolume << LL_ENDL;
 
-		stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.SetLocalMicVolume.1\">"
-			<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-			<< "<Value>" << mMicVolume << "</Value>"
-			<< "</Request>\n\n\n";
-	}
+        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.SetLocalMicVolume.1\">"
+            << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+            << "<Value>" << mMicVolume << "</Value>"
+            << "</Request>\n\n\n";
+    }
 
 
-	if (!stream.str().empty())
-	{
-		writeString(stream.str());
-	}
+    if (!stream.str().empty())
+    {
+        writeString(stream.str());
+    }
 }
 
 /**
@@ -3473,14 +3473,14 @@ void LLVivoxVoiceClient::setupVADParams(unsigned int vad_auto,
 
     LL_INFOS("Voice") << "Setting the automatic VAD to "
         << (vad_auto ? "True" : "False")
-		<< " and discrete values to"
-		<< " VadHangover = " << vad_hangover
-		<< ", VadSensitivity = " << vad_sensitivity
-		<< ", VadNoiseFloor = " << vad_noise_floor
+        << " and discrete values to"
+        << " VadHangover = " << vad_hangover
+        << ", VadSensitivity = " << vad_sensitivity
+        << ", VadNoiseFloor = " << vad_noise_floor
         << LL_ENDL;
 
-	// Create a request to set the VAD parameters:
-	stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.SetVadProperties.1\">"
+    // Create a request to set the VAD parameters:
+    stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.SetVadProperties.1\">"
                << "<VadAuto>" << vad_auto << "</VadAuto>"
                << "<VadHangover>" << vad_hangover << "</VadHangover>"
                << "<VadSensitivity>" << vad_sensitivity << "</VadSensitivity>"
@@ -3495,14 +3495,14 @@ void LLVivoxVoiceClient::setupVADParams(unsigned int vad_auto,
 
 void LLVivoxVoiceClient::onVADSettingsChange()
 {
-	// pick up the VAD variables (one of which was changed)
-	unsigned int vad_auto = gSavedSettings.getU32("VivoxVadAuto");
-	unsigned int vad_hangover = gSavedSettings.getU32("VivoxVadHangover");
-	unsigned int vad_noise_floor = gSavedSettings.getU32("VivoxVadNoiseFloor");
-	unsigned int vad_sensitivity = gSavedSettings.getU32("VivoxVadSensitivity");
+    // pick up the VAD variables (one of which was changed)
+    unsigned int vad_auto = gSavedSettings.getU32("VivoxVadAuto");
+    unsigned int vad_hangover = gSavedSettings.getU32("VivoxVadHangover");
+    unsigned int vad_noise_floor = gSavedSettings.getU32("VivoxVadNoiseFloor");
+    unsigned int vad_sensitivity = gSavedSettings.getU32("VivoxVadSensitivity");
 
-	// build a VAD params change request and send it to SLVoice
-	setupVADParams(vad_auto, vad_hangover, vad_noise_floor, vad_sensitivity);
+    // build a VAD params change request and send it to SLVoice
+    setupVADParams(vad_auto, vad_hangover, vad_noise_floor, vad_sensitivity);
 }
 
 /////////////////////////////
@@ -3512,9 +3512,9 @@ void LLVivoxVoiceClient::connectorCreateResponse(int statusCode, std::string &st
 {
     LLSD result = LLSD::emptyMap();
 
-	if(statusCode == 0)
-	{
-		// Connector created, move forward.
+    if(statusCode == 0)
+    {
+        // Connector created, move forward.
         if (connectorHandle == LLVivoxSecurity::getInstance()->connectorHandle())
         {
             LL_INFOS("Voice") << "Voice connector succeeded, Vivox SDK version is " << versionID << " connector handle " << connectorHandle << LL_ENDL;
@@ -3537,7 +3537,7 @@ void LLVivoxVoiceClient::connectorCreateResponse(int statusCode, std::string &st
             // Give up.
             mTerminateDaemon = true;
         }
-	}
+    }
     else if (statusCode == 10028) // web request timeout prior to login
     {
         // this is usually fatal, but a long timeout might work
@@ -3570,26 +3570,26 @@ void LLVivoxVoiceClient::loginResponse(int statusCode, std::string &statusString
 
     LL_DEBUGS("Voice") << "Account.Login response (" << statusCode << "): " << statusString << LL_ENDL;
 
-	// Status code of 20200 means "bad password".  We may want to special-case that at some point.
+    // Status code of 20200 means "bad password".  We may want to special-case that at some point.
 
-	if ( statusCode == HTTP_UNAUTHORIZED )
-	{
-		// Login failure which is probably caused by the delay after a user's password being updated.
-		LL_INFOS("Voice") << "Account.Login response failure (" << statusCode << "): " << statusString << LL_ENDL;
+    if ( statusCode == HTTP_UNAUTHORIZED )
+    {
+        // Login failure which is probably caused by the delay after a user's password being updated.
+        LL_INFOS("Voice") << "Account.Login response failure (" << statusCode << "): " << statusString << LL_ENDL;
         result["login"] = LLSD::String("retry");
-	}
-	else if(statusCode != 0)
-	{
-		LL_WARNS("Voice") << "Account.Login response failure (" << statusCode << "): " << statusString << LL_ENDL;
+    }
+    else if(statusCode != 0)
+    {
+        LL_WARNS("Voice") << "Account.Login response failure (" << statusCode << "): " << statusString << LL_ENDL;
         result["login"] = LLSD::String("failed");
-	}
-	else
-	{
-		// Login succeeded, move forward.
-		mAccountLoggedIn = true;
-		mNumberOfAliases = numberOfAliases;
+    }
+    else
+    {
+        // Login succeeded, move forward.
+        mAccountLoggedIn = true;
+        mNumberOfAliases = numberOfAliases;
         result["login"] = LLSD::String("response_ok");
-	}
+    }
 
     mVivoxPump.post(result);
 
@@ -3599,127 +3599,127 @@ void LLVivoxVoiceClient::sessionCreateResponse(std::string &requestId, int statu
 {
     sessionStatePtr_t session(findSessionBeingCreatedByURI(requestId));
 
-	if(session)
-	{
-		session->mCreateInProgress = false;
-	}
-
-	if(statusCode != 0)
-	{
-		LL_WARNS("Voice") << "Session.Create response failure (" << statusCode << "): " << statusString << LL_ENDL;
-		if(session)
-		{
-			session->mErrorStatusCode = statusCode;
-			session->mErrorStatusString = statusString;
-			if(session == mAudioSession)
-			{
+    if(session)
+    {
+        session->mCreateInProgress = false;
+    }
+
+    if(statusCode != 0)
+    {
+        LL_WARNS("Voice") << "Session.Create response failure (" << statusCode << "): " << statusString << LL_ENDL;
+        if(session)
+        {
+            session->mErrorStatusCode = statusCode;
+            session->mErrorStatusString = statusString;
+            if(session == mAudioSession)
+            {
                 LLSD vivoxevent(LLSDMap("handle", LLSD::String(sessionHandle))
                         ("session", "failed")
                         ("reason", LLSD::Integer(statusCode)));
 
                 mVivoxPump.post(vivoxevent);
             }
-			else
-			{
-				reapSession(session);
-			}
-		}
-	}
-	else
-	{
-		LL_INFOS("Voice") << "Session.Create response received (success), session handle is " << sessionHandle << LL_ENDL;
-		if(session)
-		{
-			setSessionHandle(session, sessionHandle);
-		}
+            else
+            {
+                reapSession(session);
+            }
+        }
+    }
+    else
+    {
+        LL_INFOS("Voice") << "Session.Create response received (success), session handle is " << sessionHandle << LL_ENDL;
+        if(session)
+        {
+            setSessionHandle(session, sessionHandle);
+        }
         LLSD vivoxevent(LLSDMap("handle", LLSD::String(sessionHandle))
                 ("session", "created"));
 
         mVivoxPump.post(vivoxevent);
-	}
+    }
 }
 
 void LLVivoxVoiceClient::sessionGroupAddSessionResponse(std::string &requestId, int statusCode, std::string &statusString, std::string &sessionHandle)
 {
     sessionStatePtr_t session(findSessionBeingCreatedByURI(requestId));
 
-	if(session)
-	{
-		session->mCreateInProgress = false;
-	}
-
-	if(statusCode != 0)
-	{
-		LL_WARNS("Voice") << "SessionGroup.AddSession response failure (" << statusCode << "): " << statusString << LL_ENDL;
-		if(session)
-		{
-			session->mErrorStatusCode = statusCode;
-			session->mErrorStatusString = statusString;
-			if(session == mAudioSession)
-			{
+    if(session)
+    {
+        session->mCreateInProgress = false;
+    }
+
+    if(statusCode != 0)
+    {
+        LL_WARNS("Voice") << "SessionGroup.AddSession response failure (" << statusCode << "): " << statusString << LL_ENDL;
+        if(session)
+        {
+            session->mErrorStatusCode = statusCode;
+            session->mErrorStatusString = statusString;
+            if(session == mAudioSession)
+            {
                 LLSD vivoxevent(LLSDMap("handle", LLSD::String(sessionHandle))
                     ("session", "failed"));
 
                 mVivoxPump.post(vivoxevent);
-			}
-			else
-			{
-				reapSession(session);
-			}
-		}
-	}
-	else
-	{
-		LL_DEBUGS("Voice") << "SessionGroup.AddSession response received (success), session handle is " << sessionHandle << LL_ENDL;
-		if(session)
-		{
-			setSessionHandle(session, sessionHandle);
-		}
+            }
+            else
+            {
+                reapSession(session);
+            }
+        }
+    }
+    else
+    {
+        LL_DEBUGS("Voice") << "SessionGroup.AddSession response received (success), session handle is " << sessionHandle << LL_ENDL;
+        if(session)
+        {
+            setSessionHandle(session, sessionHandle);
+        }
 
         LLSD vivoxevent(LLSDMap("handle", LLSD::String(sessionHandle))
             ("session", "added"));
 
         mVivoxPump.post(vivoxevent);
 
-	}
+    }
 }
 
 void LLVivoxVoiceClient::sessionConnectResponse(std::string &requestId, int statusCode, std::string &statusString)
 {
     sessionStatePtr_t session(findSession(requestId));
-	// 1026 is session already has media,  somehow mediaconnect was called twice on the same session.
-	// set the session info to reflect that the user is already connected.
-	if (statusCode == 1026)
-	{
-		session->mVoiceActive = true;
-		session->mMediaConnectInProgress = false;
-		session->mMediaStreamState = streamStateConnected;
-		//session->mTextStreamState = streamStateConnected;
-		session->mErrorStatusCode = 0;
-	}
-	else if (statusCode != 0)
-	{
-		LL_WARNS("Voice") << "Session.Connect response failure (" << statusCode << "): " << statusString << LL_ENDL;
-		if (session)
-		{
-			session->mMediaConnectInProgress = false;
-			session->mErrorStatusCode = statusCode;
-			session->mErrorStatusString = statusString;
-		}
-	}
-	else
-	{
-		LL_DEBUGS("Voice") << "Session.Connect response received (success)" << LL_ENDL;
-	}
+    // 1026 is session already has media,  somehow mediaconnect was called twice on the same session.
+    // set the session info to reflect that the user is already connected.
+    if (statusCode == 1026)
+    {
+        session->mVoiceActive = true;
+        session->mMediaConnectInProgress = false;
+        session->mMediaStreamState = streamStateConnected;
+        //session->mTextStreamState = streamStateConnected;
+        session->mErrorStatusCode = 0;
+    }
+    else if (statusCode != 0)
+    {
+        LL_WARNS("Voice") << "Session.Connect response failure (" << statusCode << "): " << statusString << LL_ENDL;
+        if (session)
+        {
+            session->mMediaConnectInProgress = false;
+            session->mErrorStatusCode = statusCode;
+            session->mErrorStatusString = statusString;
+        }
+    }
+    else
+    {
+        LL_DEBUGS("Voice") << "Session.Connect response received (success)" << LL_ENDL;
+    }
 }
 
 void LLVivoxVoiceClient::logoutResponse(int statusCode, std::string &statusString)
 {
-	if(statusCode != 0)
-	{
-		LL_WARNS("Voice") << "Account.Logout response failure: " << statusString << LL_ENDL;
-		// Should this ever fail?  do we care if it does?
-	}
+    if(statusCode != 0)
+    {
+        LL_WARNS("Voice") << "Account.Logout response failure: " << statusString << LL_ENDL;
+        // Should this ever fail?  do we care if it does?
+    }
     LLSD vivoxevent(LLSDMap("logout", LLSD::Boolean(true)));
 
     mVivoxPump.post(vivoxevent);
@@ -3727,14 +3727,14 @@ void LLVivoxVoiceClient::logoutResponse(int statusCode, std::string &statusStrin
 
 void LLVivoxVoiceClient::connectorShutdownResponse(int statusCode, std::string &statusString)
 {
-	if(statusCode != 0)
-	{
-		LL_WARNS("Voice") << "Connector.InitiateShutdown response failure: " << statusString << LL_ENDL;
-		// Should this ever fail?  do we care if it does?
-	}
+    if(statusCode != 0)
+    {
+        LL_WARNS("Voice") << "Connector.InitiateShutdown response failure: " << statusString << LL_ENDL;
+        // Should this ever fail?  do we care if it does?
+    }
 
-	sConnected = false;
-	mShutdownComplete = true;
+    sConnected = false;
+    mShutdownComplete = true;
 
     LLSD vivoxevent(LLSDMap("connector", LLSD::Boolean(false)));
 
@@ -3742,246 +3742,246 @@ void LLVivoxVoiceClient::connectorShutdownResponse(int statusCode, std::string &
 }
 
 void LLVivoxVoiceClient::sessionAddedEvent(
-		std::string &uriString,
-		std::string &alias,
-		std::string &sessionHandle,
-		std::string &sessionGroupHandle,
-		bool isChannel,
-		bool incoming,
-		std::string &nameString,
-		std::string &applicationString)
+        std::string &uriString,
+        std::string &alias,
+        std::string &sessionHandle,
+        std::string &sessionGroupHandle,
+        bool isChannel,
+        bool incoming,
+        std::string &nameString,
+        std::string &applicationString)
 {
     sessionStatePtr_t session;
 
-	LL_INFOS("Voice") << "session " << uriString << ", alias " << alias << ", name " << nameString << " handle " << sessionHandle << LL_ENDL;
-
-	session = addSession(uriString, sessionHandle);
-	if(session)
-	{
-		session->mGroupHandle = sessionGroupHandle;
-		session->mIsChannel = isChannel;
-		session->mIncoming = incoming;
-		session->mAlias = alias;
-
-		// Generate a caller UUID -- don't need to do this for channels
-		if(!session->mIsChannel)
-		{
-			if(IDFromName(session->mSIPURI, session->mCallerID))
-			{
-				// Normal URI(base64-encoded UUID)
-			}
-			else if(!session->mAlias.empty() && IDFromName(session->mAlias, session->mCallerID))
-			{
-				// Wrong URI, but an alias is available.  Stash the incoming URI as an alternate
-				session->mAlternateSIPURI = session->mSIPURI;
-
-				// and generate a proper URI from the ID.
-				setSessionURI(session, sipURIFromID(session->mCallerID));
-			}
-			else
-			{
-				LL_INFOS("Voice") << "Could not generate caller id from uri, using hash of uri " << session->mSIPURI << LL_ENDL;
-				session->mCallerID.generate(session->mSIPURI);
-				session->mSynthesizedCallerID = true;
-
-				// Can't look up the name in this case -- we have to extract it from the URI.
-				std::string namePortion = nameFromsipURI(session->mSIPURI);
-				if(namePortion.empty())
-				{
-					// Didn't seem to be a SIP URI, just use the whole provided name.
-					namePortion = nameString;
-				}
-
-				// Some incoming names may be separated with an underscore instead of a space.  Fix this.
-				LLStringUtil::replaceChar(namePortion, '_', ' ');
-
-				// Act like we just finished resolving the name (this stores it in all the right places)
-				avatarNameResolved(session->mCallerID, namePortion);
-			}
-
-			LL_INFOS("Voice") << "caller ID: " << session->mCallerID << LL_ENDL;
-
-			if(!session->mSynthesizedCallerID)
-			{
-				// If we got here, we don't have a proper name.  Initiate a lookup.
-				lookupName(session->mCallerID);
-			}
-		}
-	}
+    LL_INFOS("Voice") << "session " << uriString << ", alias " << alias << ", name " << nameString << " handle " << sessionHandle << LL_ENDL;
+
+    session = addSession(uriString, sessionHandle);
+    if(session)
+    {
+        session->mGroupHandle = sessionGroupHandle;
+        session->mIsChannel = isChannel;
+        session->mIncoming = incoming;
+        session->mAlias = alias;
+
+        // Generate a caller UUID -- don't need to do this for channels
+        if(!session->mIsChannel)
+        {
+            if(IDFromName(session->mSIPURI, session->mCallerID))
+            {
+                // Normal URI(base64-encoded UUID)
+            }
+            else if(!session->mAlias.empty() && IDFromName(session->mAlias, session->mCallerID))
+            {
+                // Wrong URI, but an alias is available.  Stash the incoming URI as an alternate
+                session->mAlternateSIPURI = session->mSIPURI;
+
+                // and generate a proper URI from the ID.
+                setSessionURI(session, sipURIFromID(session->mCallerID));
+            }
+            else
+            {
+                LL_INFOS("Voice") << "Could not generate caller id from uri, using hash of uri " << session->mSIPURI << LL_ENDL;
+                session->mCallerID.generate(session->mSIPURI);
+                session->mSynthesizedCallerID = true;
+
+                // Can't look up the name in this case -- we have to extract it from the URI.
+                std::string namePortion = nameFromsipURI(session->mSIPURI);
+                if(namePortion.empty())
+                {
+                    // Didn't seem to be a SIP URI, just use the whole provided name.
+                    namePortion = nameString;
+                }
+
+                // Some incoming names may be separated with an underscore instead of a space.  Fix this.
+                LLStringUtil::replaceChar(namePortion, '_', ' ');
+
+                // Act like we just finished resolving the name (this stores it in all the right places)
+                avatarNameResolved(session->mCallerID, namePortion);
+            }
+
+            LL_INFOS("Voice") << "caller ID: " << session->mCallerID << LL_ENDL;
+
+            if(!session->mSynthesizedCallerID)
+            {
+                // If we got here, we don't have a proper name.  Initiate a lookup.
+                lookupName(session->mCallerID);
+            }
+        }
+    }
 }
 
 void LLVivoxVoiceClient::sessionGroupAddedEvent(std::string &sessionGroupHandle)
 {
-	LL_DEBUGS("Voice") << "handle " << sessionGroupHandle << LL_ENDL;
+    LL_DEBUGS("Voice") << "handle " << sessionGroupHandle << LL_ENDL;
 
 #if  USE_SESSION_GROUPS
-	if(mMainSessionGroupHandle.empty())
-	{
-		// This is the first (i.e. "main") session group.  Save its handle.
-		mMainSessionGroupHandle = sessionGroupHandle;
-	}
-	else
-	{
-		LL_DEBUGS("Voice") << "Already had a session group handle " << mMainSessionGroupHandle << LL_ENDL;
-	}
+    if(mMainSessionGroupHandle.empty())
+    {
+        // This is the first (i.e. "main") session group.  Save its handle.
+        mMainSessionGroupHandle = sessionGroupHandle;
+    }
+    else
+    {
+        LL_DEBUGS("Voice") << "Already had a session group handle " << mMainSessionGroupHandle << LL_ENDL;
+    }
 #endif
 }
 
 void LLVivoxVoiceClient::joinedAudioSession(const sessionStatePtr_t &session)
 {
-	LL_DEBUGS("Voice") << "Joined Audio Session" << LL_ENDL;
-	if(mAudioSession != session)
-	{
+    LL_DEBUGS("Voice") << "Joined Audio Session" << LL_ENDL;
+    if(mAudioSession != session)
+    {
         sessionStatePtr_t oldSession = mAudioSession;
 
-		mAudioSession = session;
-		mAudioSessionChanged = true;
+        mAudioSession = session;
+        mAudioSessionChanged = true;
 
-		// The old session may now need to be deleted.
-		reapSession(oldSession);
-	}
+        // The old session may now need to be deleted.
+        reapSession(oldSession);
+    }
 
-	// This is the session we're joining.
-	if(mIsJoiningSession)
-	{
+    // This is the session we're joining.
+    if(mIsJoiningSession)
+    {
         LLSD vivoxevent(LLSDMap("handle", LLSD::String(session->mHandle))
                 ("session", "joined"));
 
         mVivoxPump.post(vivoxevent);
 
-		// Add the current user as a participant here.
+        // Add the current user as a participant here.
         participantStatePtr_t participant(session->addParticipant(sipURIFromName(mAccountName)));
-		if(participant)
-		{
-			participant->mIsSelf = true;
-			lookupName(participant->mAvatarID);
-
-			LL_INFOS("Voice") << "added self as participant \"" << participant->mAccountName
-					<< "\" (" << participant->mAvatarID << ")"<< LL_ENDL;
-		}
-
-		if(!session->mIsChannel)
-		{
-			// this is a p2p session.  Make sure the other end is added as a participant.
+        if(participant)
+        {
+            participant->mIsSelf = true;
+            lookupName(participant->mAvatarID);
+
+            LL_INFOS("Voice") << "added self as participant \"" << participant->mAccountName
+                    << "\" (" << participant->mAvatarID << ")"<< LL_ENDL;
+        }
+
+        if(!session->mIsChannel)
+        {
+            // this is a p2p session.  Make sure the other end is added as a participant.
             participantStatePtr_t participant(session->addParticipant(session->mSIPURI));
-			if(participant)
-			{
-				if(participant->mAvatarIDValid)
-				{
-					lookupName(participant->mAvatarID);
-				}
-				else if(!session->mName.empty())
-				{
-					participant->mDisplayName = session->mName;
-					avatarNameResolved(participant->mAvatarID, session->mName);
-				}
-
-				// TODO: Question: Do we need to set up mAvatarID/mAvatarIDValid here?
-				LL_INFOS("Voice") << "added caller as participant \"" << participant->mAccountName
-						<< "\" (" << participant->mAvatarID << ")"<< LL_ENDL;
-			}
-		}
-	}
+            if(participant)
+            {
+                if(participant->mAvatarIDValid)
+                {
+                    lookupName(participant->mAvatarID);
+                }
+                else if(!session->mName.empty())
+                {
+                    participant->mDisplayName = session->mName;
+                    avatarNameResolved(participant->mAvatarID, session->mName);
+                }
+
+                // TODO: Question: Do we need to set up mAvatarID/mAvatarIDValid here?
+                LL_INFOS("Voice") << "added caller as participant \"" << participant->mAccountName
+                        << "\" (" << participant->mAvatarID << ")"<< LL_ENDL;
+            }
+        }
+    }
 }
 
 void LLVivoxVoiceClient::sessionRemovedEvent(
-	std::string &sessionHandle,
-	std::string &sessionGroupHandle)
+    std::string &sessionHandle,
+    std::string &sessionGroupHandle)
 {
-	LL_INFOS("Voice") << "handle " << sessionHandle << LL_ENDL;
+    LL_INFOS("Voice") << "handle " << sessionHandle << LL_ENDL;
 
     sessionStatePtr_t session(findSession(sessionHandle));
-	if(session)
-	{
-		leftAudioSession(session);
+    if(session)
+    {
+        leftAudioSession(session);
 
-		// This message invalidates the session's handle.  Set it to empty.
+        // This message invalidates the session's handle.  Set it to empty.
         clearSessionHandle(session);
 
-		// This also means that the session's session group is now empty.
-		// Terminate the session group so it doesn't leak.
-		sessionGroupTerminateSendMessage(session);
+        // This also means that the session's session group is now empty.
+        // Terminate the session group so it doesn't leak.
+        sessionGroupTerminateSendMessage(session);
 
-		// Reset the media state (we now have no info)
-		session->mMediaStreamState = streamStateUnknown;
-		//session->mTextStreamState = streamStateUnknown;
+        // Reset the media state (we now have no info)
+        session->mMediaStreamState = streamStateUnknown;
+        //session->mTextStreamState = streamStateUnknown;
 
-		// Conditionally delete the session
-		reapSession(session);
-	}
-	else
-	{
-		// Already reaped this session.
-		LL_DEBUGS("Voice") << "unknown session " << sessionHandle << " removed" << LL_ENDL;
-	}
+        // Conditionally delete the session
+        reapSession(session);
+    }
+    else
+    {
+        // Already reaped this session.
+        LL_DEBUGS("Voice") << "unknown session " << sessionHandle << " removed" << LL_ENDL;
+    }
 
 }
 
 void LLVivoxVoiceClient::reapSession(const sessionStatePtr_t &session)
 {
-	if(session)
-	{
-
-		if(session->mCreateInProgress)
-		{
-			LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (create in progress)" << LL_ENDL;
-		}
-		else if(session->mMediaConnectInProgress)
-		{
-			LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (connect in progress)" << LL_ENDL;
-		}
-		else if(session == mAudioSession)
-		{
-			LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (it's the current session)" << LL_ENDL;
-		}
-		else if(session == mNextAudioSession)
-		{
-			LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (it's the next session)" << LL_ENDL;
-		}
-		else
-		{
-			// We don't have a reason to keep tracking this session, so just delete it.
-			LL_DEBUGS("Voice") << "deleting session " << session->mSIPURI << LL_ENDL;
-			deleteSession(session);
-		}
-	}
-	else
-	{
-//		LL_DEBUGS("Voice") << "session is NULL" << LL_ENDL;
-	}
+    if(session)
+    {
+
+        if(session->mCreateInProgress)
+        {
+            LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (create in progress)" << LL_ENDL;
+        }
+        else if(session->mMediaConnectInProgress)
+        {
+            LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (connect in progress)" << LL_ENDL;
+        }
+        else if(session == mAudioSession)
+        {
+            LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (it's the current session)" << LL_ENDL;
+        }
+        else if(session == mNextAudioSession)
+        {
+            LL_DEBUGS("Voice") << "NOT deleting session " << session->mSIPURI << " (it's the next session)" << LL_ENDL;
+        }
+        else
+        {
+            // We don't have a reason to keep tracking this session, so just delete it.
+            LL_DEBUGS("Voice") << "deleting session " << session->mSIPURI << LL_ENDL;
+            deleteSession(session);
+        }
+    }
+    else
+    {
+//      LL_DEBUGS("Voice") << "session is NULL" << LL_ENDL;
+    }
 }
 
 // Returns true if the session seems to indicate we've moved to a region on a different voice server
 bool LLVivoxVoiceClient::sessionNeedsRelog(const sessionStatePtr_t &session)
 {
-	bool result = false;
+    bool result = false;
 
-	if(session)
-	{
-		// Only make this check for spatial channels (so it won't happen for group or p2p calls)
-		if(session->mIsSpatial)
-		{
-			std::string::size_type atsign;
+    if(session)
+    {
+        // Only make this check for spatial channels (so it won't happen for group or p2p calls)
+        if(session->mIsSpatial)
+        {
+            std::string::size_type atsign;
 
-			atsign = session->mSIPURI.find("@");
+            atsign = session->mSIPURI.find("@");
 
-			if(atsign != std::string::npos)
-			{
-				std::string urihost = session->mSIPURI.substr(atsign + 1);
-				if(stricmp(urihost.c_str(), mVoiceSIPURIHostName.c_str()))
-				{
-					// The hostname in this URI is different from what we expect.  This probably means we need to relog.
+            if(atsign != std::string::npos)
+            {
+                std::string urihost = session->mSIPURI.substr(atsign + 1);
+                if(stricmp(urihost.c_str(), mVoiceSIPURIHostName.c_str()))
+                {
+                    // The hostname in this URI is different from what we expect.  This probably means we need to relog.
 
-					// We could make a ProvisionVoiceAccountRequest and compare the result with the current values of
-					// mVoiceSIPURIHostName and mVoiceAccountServerURI to be really sure, but this is a pretty good indicator.
+                    // We could make a ProvisionVoiceAccountRequest and compare the result with the current values of
+                    // mVoiceSIPURIHostName and mVoiceAccountServerURI to be really sure, but this is a pretty good indicator.
 
-					result = true;
-				}
-			}
-		}
-	}
+                    result = true;
+                }
+            }
+        }
+    }
 
-	return result;
+    return result;
 }
 
 void LLVivoxVoiceClient::leftAudioSession(const sessionStatePtr_t &session)
@@ -3996,27 +3996,27 @@ void LLVivoxVoiceClient::leftAudioSession(const sessionStatePtr_t &session)
 }
 
 void LLVivoxVoiceClient::accountLoginStateChangeEvent(
-		std::string &accountHandle,
-		int statusCode,
-		std::string &statusString,
-		int state)
+        std::string &accountHandle,
+        int statusCode,
+        std::string &statusString,
+        int state)
 {
     LLSD levent = LLSD::emptyMap();
 
-	/*
-		According to Mike S., status codes for this event are:
-		login_state_logged_out=0,
+    /*
+        According to Mike S., status codes for this event are:
+        login_state_logged_out=0,
         login_state_logged_in = 1,
         login_state_logging_in = 2,
         login_state_logging_out = 3,
         login_state_resetting = 4,
         login_state_error=100
-	*/
+    */
 
-	LL_DEBUGS("Voice") << "state change event: " << state << LL_ENDL;
-	switch(state)
-	{
-		case 1:
+    LL_DEBUGS("Voice") << "state change event: " << state << LL_ENDL;
+    switch(state)
+    {
+        case 1:
             levent["login"] = LLSD::String("account_login");
 
             mVivoxPump.post(levent);
@@ -4044,665 +4044,665 @@ void LLVivoxVoiceClient::accountLoginStateChangeEvent(
             break;
 
         default:
-			//Used to be a commented out warning
-			LL_WARNS("Voice") << "unknown account state event: " << state << LL_ENDL;
-	    	break;
-	}
+            //Used to be a commented out warning
+            LL_WARNS("Voice") << "unknown account state event: " << state << LL_ENDL;
+            break;
+    }
 }
 
 void LLVivoxVoiceClient::mediaCompletionEvent(std::string &sessionGroupHandle, std::string &mediaCompletionType)
 {
     LLSD result;
 
-	if (mediaCompletionType == "AuxBufferAudioCapture")
-	{
-		mCaptureBufferRecording = false;
+    if (mediaCompletionType == "AuxBufferAudioCapture")
+    {
+        mCaptureBufferRecording = false;
         result["recplay"] = "end";
-	}
-	else if (mediaCompletionType == "AuxBufferAudioRender")
-	{
-		// Ignore all but the last stop event
-		if (--mPlayRequestCount <= 0)
-		{
-			mCaptureBufferPlaying = false;
+    }
+    else if (mediaCompletionType == "AuxBufferAudioRender")
+    {
+        // Ignore all but the last stop event
+        if (--mPlayRequestCount <= 0)
+        {
+            mCaptureBufferPlaying = false;
             result["recplay"] = "end";
 //          result["recplay"] = "done";
         }
-	}
-	else
-	{
-		LL_WARNS("Voice") << "Unknown MediaCompletionType: " << mediaCompletionType << LL_ENDL;
-	}
+    }
+    else
+    {
+        LL_WARNS("Voice") << "Unknown MediaCompletionType: " << mediaCompletionType << LL_ENDL;
+    }
 
     if (!result.isUndefined())
         mVivoxPump.post(result);
 }
 
 void LLVivoxVoiceClient::mediaStreamUpdatedEvent(
-	std::string &sessionHandle,
-	std::string &sessionGroupHandle,
-	int statusCode,
-	std::string &statusString,
-	int state,
-	bool incoming)
+    std::string &sessionHandle,
+    std::string &sessionGroupHandle,
+    int statusCode,
+    std::string &statusString,
+    int state,
+    bool incoming)
 {
     sessionStatePtr_t session(findSession(sessionHandle));
 
-	LL_DEBUGS("Voice") << "session " << sessionHandle << ", status code " << statusCode << ", string \"" << statusString << "\"" << LL_ENDL;
-
-	if(session)
-	{
-		// We know about this session
-
-		// Save the state for later use
-		session->mMediaStreamState = state;
-
-		switch(statusCode)
-		{
-			case 0:
-			case HTTP_OK:
-				// generic success
-				// Don't change the saved error code (it may have been set elsewhere)
-			break;
-			default:
-				// save the status code for later
-				session->mErrorStatusCode = statusCode;
-			break;
-		}
-
-		switch(state)
-		{
-		case streamStateDisconnecting:
-		case streamStateIdle:
-				// Standard "left audio session", Vivox state 'disconnected'
-				session->mVoiceActive = false;
-				session->mMediaConnectInProgress = false;
-				leftAudioSession(session);
-			break;
-
-			case streamStateConnected:
-				session->mVoiceActive = true;
-				session->mMediaConnectInProgress = false;
-				joinedAudioSession(session);
-			case streamStateConnecting: // do nothing, but prevents a warning getting into the logs.
-			break;
-
-			case streamStateRinging:
-				if(incoming)
-				{
-					// Send the voice chat invite to the GUI layer
-					// TODO: Question: Should we correlate with the mute list here?
-					session->mIMSessionID = LLIMMgr::computeSessionID(IM_SESSION_P2P_INVITE, session->mCallerID);
-					session->mVoiceInvitePending = true;
-					if(session->mName.empty())
-					{
-						lookupName(session->mCallerID);
-					}
-					else
-					{
-						// Act like we just finished resolving the name
-						avatarNameResolved(session->mCallerID, session->mName);
-					}
-				}
-			break;
-
-			default:
-				LL_WARNS("Voice") << "unknown state " << state << LL_ENDL;
-			break;
-
-		}
-
-	}
-	else
-	{
-		// session disconnectintg and disconnected events arriving after we have already left the session.
-		LL_DEBUGS("Voice") << "session " << sessionHandle << " not found"<< LL_ENDL;
-	}
+    LL_DEBUGS("Voice") << "session " << sessionHandle << ", status code " << statusCode << ", string \"" << statusString << "\"" << LL_ENDL;
+
+    if(session)
+    {
+        // We know about this session
+
+        // Save the state for later use
+        session->mMediaStreamState = state;
+
+        switch(statusCode)
+        {
+            case 0:
+            case HTTP_OK:
+                // generic success
+                // Don't change the saved error code (it may have been set elsewhere)
+            break;
+            default:
+                // save the status code for later
+                session->mErrorStatusCode = statusCode;
+            break;
+        }
+
+        switch(state)
+        {
+        case streamStateDisconnecting:
+        case streamStateIdle:
+                // Standard "left audio session", Vivox state 'disconnected'
+                session->mVoiceActive = false;
+                session->mMediaConnectInProgress = false;
+                leftAudioSession(session);
+            break;
+
+            case streamStateConnected:
+                session->mVoiceActive = true;
+                session->mMediaConnectInProgress = false;
+                joinedAudioSession(session);
+            case streamStateConnecting: // do nothing, but prevents a warning getting into the logs.
+            break;
+
+            case streamStateRinging:
+                if(incoming)
+                {
+                    // Send the voice chat invite to the GUI layer
+                    // TODO: Question: Should we correlate with the mute list here?
+                    session->mIMSessionID = LLIMMgr::computeSessionID(IM_SESSION_P2P_INVITE, session->mCallerID);
+                    session->mVoiceInvitePending = true;
+                    if(session->mName.empty())
+                    {
+                        lookupName(session->mCallerID);
+                    }
+                    else
+                    {
+                        // Act like we just finished resolving the name
+                        avatarNameResolved(session->mCallerID, session->mName);
+                    }
+                }
+            break;
+
+            default:
+                LL_WARNS("Voice") << "unknown state " << state << LL_ENDL;
+            break;
+
+        }
+
+    }
+    else
+    {
+        // session disconnectintg and disconnected events arriving after we have already left the session.
+        LL_DEBUGS("Voice") << "session " << sessionHandle << " not found"<< LL_ENDL;
+    }
 }
 
 void LLVivoxVoiceClient::participantAddedEvent(
-		std::string &sessionHandle,
-		std::string &sessionGroupHandle,
-		std::string &uriString,
-		std::string &alias,
-		std::string &nameString,
-		std::string &displayNameString,
-		int participantType)
+        std::string &sessionHandle,
+        std::string &sessionGroupHandle,
+        std::string &uriString,
+        std::string &alias,
+        std::string &nameString,
+        std::string &displayNameString,
+        int participantType)
 {
     sessionStatePtr_t session(findSession(sessionHandle));
-	if(session)
-	{
+    if(session)
+    {
         participantStatePtr_t participant(session->addParticipant(uriString));
-		if(participant)
-		{
-			participant->mAccountName = nameString;
-
-			LL_DEBUGS("Voice") << "added participant \"" << participant->mAccountName
-					<< "\" (" << participant->mAvatarID << ")"<< LL_ENDL;
-
-			if(participant->mAvatarIDValid)
-			{
-				// Initiate a lookup
-				lookupName(participant->mAvatarID);
-			}
-			else
-			{
-				// If we don't have a valid avatar UUID, we need to fill in the display name to make the active speakers floater work.
-				std::string namePortion = nameFromsipURI(uriString);
-				if(namePortion.empty())
-				{
-					// Problem with the SIP URI, fall back to the display name
-					namePortion = displayNameString;
-				}
-				if(namePortion.empty())
-				{
-					// Problems with both of the above, fall back to the account name
-					namePortion = nameString;
-				}
-
-				// Set the display name (which is a hint to the active speakers window not to do its own lookup)
-				participant->mDisplayName = namePortion;
-				avatarNameResolved(participant->mAvatarID, namePortion);
-			}
-		}
-	}
+        if(participant)
+        {
+            participant->mAccountName = nameString;
+
+            LL_DEBUGS("Voice") << "added participant \"" << participant->mAccountName
+                    << "\" (" << participant->mAvatarID << ")"<< LL_ENDL;
+
+            if(participant->mAvatarIDValid)
+            {
+                // Initiate a lookup
+                lookupName(participant->mAvatarID);
+            }
+            else
+            {
+                // If we don't have a valid avatar UUID, we need to fill in the display name to make the active speakers floater work.
+                std::string namePortion = nameFromsipURI(uriString);
+                if(namePortion.empty())
+                {
+                    // Problem with the SIP URI, fall back to the display name
+                    namePortion = displayNameString;
+                }
+                if(namePortion.empty())
+                {
+                    // Problems with both of the above, fall back to the account name
+                    namePortion = nameString;
+                }
+
+                // Set the display name (which is a hint to the active speakers window not to do its own lookup)
+                participant->mDisplayName = namePortion;
+                avatarNameResolved(participant->mAvatarID, namePortion);
+            }
+        }
+    }
 }
 
 void LLVivoxVoiceClient::participantRemovedEvent(
-		std::string &sessionHandle,
-		std::string &sessionGroupHandle,
-		std::string &uriString,
-		std::string &alias,
-		std::string &nameString)
+        std::string &sessionHandle,
+        std::string &sessionGroupHandle,
+        std::string &uriString,
+        std::string &alias,
+        std::string &nameString)
 {
     sessionStatePtr_t session(findSession(sessionHandle));
-	if(session)
-	{
+    if(session)
+    {
         participantStatePtr_t participant(session->findParticipant(uriString));
-		if(participant)
-		{
-			session->removeParticipant(participant);
-		}
-		else
-		{
-			LL_DEBUGS("Voice") << "unknown participant " << uriString << LL_ENDL;
-		}
-	}
-	else
-	{
-		// a late arriving event on a session we have already left.
-		LL_DEBUGS("Voice") << "unknown session " << sessionHandle << LL_ENDL;
-	}
+        if(participant)
+        {
+            session->removeParticipant(participant);
+        }
+        else
+        {
+            LL_DEBUGS("Voice") << "unknown participant " << uriString << LL_ENDL;
+        }
+    }
+    else
+    {
+        // a late arriving event on a session we have already left.
+        LL_DEBUGS("Voice") << "unknown session " << sessionHandle << LL_ENDL;
+    }
 }
 
 
 void LLVivoxVoiceClient::participantUpdatedEvent(
-		std::string &sessionHandle,
-		std::string &sessionGroupHandle,
-		std::string &uriString,
-		std::string &alias,
-		bool isModeratorMuted,
-		bool isSpeaking,
-		int volume,
-		F32 energy)
+        std::string &sessionHandle,
+        std::string &sessionGroupHandle,
+        std::string &uriString,
+        std::string &alias,
+        bool isModeratorMuted,
+        bool isSpeaking,
+        int volume,
+        F32 energy)
 {
     sessionStatePtr_t session(findSession(sessionHandle));
-	if(session)
-	{
-		participantStatePtr_t participant(session->findParticipant(uriString));
+    if(session)
+    {
+        participantStatePtr_t participant(session->findParticipant(uriString));
 
-		if(participant)
-		{
+        if(participant)
+        {
             //LL_INFOS("Voice") << "Participant Update for " << participant->mDisplayName << LL_ENDL;
 
-			participant->mIsSpeaking = isSpeaking;
-			participant->mIsModeratorMuted = isModeratorMuted;
-
-			// SLIM SDK: convert range: ensure that energy is set to zero if is_speaking is false
-			if (isSpeaking)
-			{
-				participant->mSpeakingTimeout.reset();
-				participant->mPower = energy;
-			}
-			else
-			{
-				participant->mPower = 0.0f;
-			}
-
-			// Ignore incoming volume level if it has been explicitly set, or there
-			//  is a volume or mute change pending.
-			if ( !participant->mVolumeSet && !participant->mVolumeDirty)
-			{
-				participant->mVolume = (F32)volume * VOLUME_SCALE_VIVOX;
-			}
-
-			// *HACK: mantipov: added while working on EXT-3544
-			/*
-			 Sometimes LLVoiceClient::participantUpdatedEvent callback is called BEFORE
-			 LLViewerChatterBoxSessionAgentListUpdates::post() sometimes AFTER.
-
-			 participantUpdatedEvent updates voice participant state in particular participantState::mIsModeratorMuted
-			 Originally we wanted to update session Speaker Manager to fire LLSpeakerVoiceModerationEvent to fix the EXT-3544 bug.
-			 Calling of the LLSpeakerMgr::update() method was added into LLIMMgr::processAgentListUpdates.
-
-			 But in case participantUpdatedEvent() is called after LLViewerChatterBoxSessionAgentListUpdates::post()
-			 voice participant mIsModeratorMuted is changed after speakers are updated in Speaker Manager
-			 and event is not fired.
-
-			 So, we have to call LLSpeakerMgr::update() here.
-			 */
-			LLVoiceChannel* voice_cnl = LLVoiceChannel::getCurrentVoiceChannel();
-
-			// ignore session ID of local chat
-			if (voice_cnl && voice_cnl->getSessionID().notNull())
-			{
-				LLSpeakerMgr* speaker_manager = LLIMModel::getInstance()->getSpeakerManager(voice_cnl->getSessionID());
-				if (speaker_manager)
-				{
-					speaker_manager->update(true);
-
-					// also initialize voice moderate_mode depend on Agent's participant. See EXT-6937.
-					// *TODO: remove once a way to request the current voice channel moderation mode is implemented.
-					if (gAgent.getID() == participant->mAvatarID)
-					{
-						speaker_manager->initVoiceModerateMode();
-					}
-				}
-			}
-		}
-		else
-		{
-			LL_WARNS("Voice") << "unknown participant: " << uriString << LL_ENDL;
-		}
-	}
-	else
-	{
-		LL_DEBUGS("Voice") << "unknown session " << sessionHandle << LL_ENDL;
-	}
+            participant->mIsSpeaking = isSpeaking;
+            participant->mIsModeratorMuted = isModeratorMuted;
+
+            // SLIM SDK: convert range: ensure that energy is set to zero if is_speaking is false
+            if (isSpeaking)
+            {
+                participant->mSpeakingTimeout.reset();
+                participant->mPower = energy;
+            }
+            else
+            {
+                participant->mPower = 0.0f;
+            }
+
+            // Ignore incoming volume level if it has been explicitly set, or there
+            //  is a volume or mute change pending.
+            if ( !participant->mVolumeSet && !participant->mVolumeDirty)
+            {
+                participant->mVolume = (F32)volume * VOLUME_SCALE_VIVOX;
+            }
+
+            // *HACK: mantipov: added while working on EXT-3544
+            /*
+             Sometimes LLVoiceClient::participantUpdatedEvent callback is called BEFORE
+             LLViewerChatterBoxSessionAgentListUpdates::post() sometimes AFTER.
+
+             participantUpdatedEvent updates voice participant state in particular participantState::mIsModeratorMuted
+             Originally we wanted to update session Speaker Manager to fire LLSpeakerVoiceModerationEvent to fix the EXT-3544 bug.
+             Calling of the LLSpeakerMgr::update() method was added into LLIMMgr::processAgentListUpdates.
+
+             But in case participantUpdatedEvent() is called after LLViewerChatterBoxSessionAgentListUpdates::post()
+             voice participant mIsModeratorMuted is changed after speakers are updated in Speaker Manager
+             and event is not fired.
+
+             So, we have to call LLSpeakerMgr::update() here.
+             */
+            LLVoiceChannel* voice_cnl = LLVoiceChannel::getCurrentVoiceChannel();
+
+            // ignore session ID of local chat
+            if (voice_cnl && voice_cnl->getSessionID().notNull())
+            {
+                LLSpeakerMgr* speaker_manager = LLIMModel::getInstance()->getSpeakerManager(voice_cnl->getSessionID());
+                if (speaker_manager)
+                {
+                    speaker_manager->update(true);
+
+                    // also initialize voice moderate_mode depend on Agent's participant. See EXT-6937.
+                    // *TODO: remove once a way to request the current voice channel moderation mode is implemented.
+                    if (gAgent.getID() == participant->mAvatarID)
+                    {
+                        speaker_manager->initVoiceModerateMode();
+                    }
+                }
+            }
+        }
+        else
+        {
+            LL_WARNS("Voice") << "unknown participant: " << uriString << LL_ENDL;
+        }
+    }
+    else
+    {
+        LL_DEBUGS("Voice") << "unknown session " << sessionHandle << LL_ENDL;
+    }
 }
 
 void LLVivoxVoiceClient::messageEvent(
-		std::string &sessionHandle,
-		std::string &uriString,
-		std::string &alias,
-		std::string &messageHeader,
-		std::string &messageBody,
-		std::string &applicationString)
+        std::string &sessionHandle,
+        std::string &uriString,
+        std::string &alias,
+        std::string &messageHeader,
+        std::string &messageBody,
+        std::string &applicationString)
 {
-	LL_DEBUGS("Voice") << "Message event, session " << sessionHandle << " from " << uriString << LL_ENDL;
-//	LL_DEBUGS("Voice") << "    header " << messageHeader << ", body: \n" << messageBody << LL_ENDL;
+    LL_DEBUGS("Voice") << "Message event, session " << sessionHandle << " from " << uriString << LL_ENDL;
+//  LL_DEBUGS("Voice") << "    header " << messageHeader << ", body: \n" << messageBody << LL_ENDL;
 
     LL_INFOS("Voice") << "Vivox raw message:" << std::endl << messageBody << LL_ENDL;
 
-	if(messageHeader.find(HTTP_CONTENT_TEXT_HTML) != std::string::npos)
-	{
-		std::string message;
-
-		{
-			const std::string startMarker = "<body";
-			const std::string startMarker2 = ">";
-			const std::string endMarker = "</body>";
-			const std::string startSpan = "<span";
-			const std::string endSpan = "</span>";
-			std::string::size_type start;
-			std::string::size_type end;
-
-			// Default to displaying the raw string, so the message gets through.
-			message = messageBody;
-
-			// Find the actual message text within the XML fragment
-			start = messageBody.find(startMarker);
-			start = messageBody.find(startMarker2, start);
-			end = messageBody.find(endMarker);
-
-			if(start != std::string::npos)
-			{
-				start += startMarker2.size();
-
-				if(end != std::string::npos)
-					end -= start;
-
-				message.assign(messageBody, start, end);
-			}
-			else
-			{
-				// Didn't find a <body>, try looking for a <span> instead.
-				start = messageBody.find(startSpan);
-				start = messageBody.find(startMarker2, start);
-				end = messageBody.find(endSpan);
-
-				if(start != std::string::npos)
-				{
-					start += startMarker2.size();
-
-					if(end != std::string::npos)
-						end -= start;
-
-					message.assign(messageBody, start, end);
-				}
-			}
-		}
-
-//		LL_DEBUGS("Voice") << "    raw message = \n" << message << LL_ENDL;
-
-		// strip formatting tags
-		{
-			std::string::size_type start;
-			std::string::size_type end;
-
-			while((start = message.find('<')) != std::string::npos)
-			{
-				if((end = message.find('>', start + 1)) != std::string::npos)
-				{
-					// Strip out the tag
-					message.erase(start, (end + 1) - start);
-				}
-				else
-				{
-					// Avoid an infinite loop
-					break;
-				}
-			}
-		}
-
-		// Decode ampersand-escaped chars
-		{
-			std::string::size_type mark = 0;
-
-			// The text may contain text encoded with &lt;, &gt;, and &amp;
-			mark = 0;
-			while((mark = message.find("&lt;", mark)) != std::string::npos)
-			{
-				message.replace(mark, 4, "<");
-				mark += 1;
-			}
-
-			mark = 0;
-			while((mark = message.find("&gt;", mark)) != std::string::npos)
-			{
-				message.replace(mark, 4, ">");
-				mark += 1;
-			}
-
-			mark = 0;
-			while((mark = message.find("&amp;", mark)) != std::string::npos)
-			{
-				message.replace(mark, 5, "&");
-				mark += 1;
-			}
-		}
-
-		// strip leading/trailing whitespace (since we always seem to get a couple newlines)
-		LLStringUtil::trim(message);
-
-//		LL_DEBUGS("Voice") << "    stripped message = \n" << message << LL_ENDL;
+    if(messageHeader.find(HTTP_CONTENT_TEXT_HTML) != std::string::npos)
+    {
+        std::string message;
+
+        {
+            const std::string startMarker = "<body";
+            const std::string startMarker2 = ">";
+            const std::string endMarker = "</body>";
+            const std::string startSpan = "<span";
+            const std::string endSpan = "</span>";
+            std::string::size_type start;
+            std::string::size_type end;
+
+            // Default to displaying the raw string, so the message gets through.
+            message = messageBody;
+
+            // Find the actual message text within the XML fragment
+            start = messageBody.find(startMarker);
+            start = messageBody.find(startMarker2, start);
+            end = messageBody.find(endMarker);
+
+            if(start != std::string::npos)
+            {
+                start += startMarker2.size();
+
+                if(end != std::string::npos)
+                    end -= start;
+
+                message.assign(messageBody, start, end);
+            }
+            else
+            {
+                // Didn't find a <body>, try looking for a <span> instead.
+                start = messageBody.find(startSpan);
+                start = messageBody.find(startMarker2, start);
+                end = messageBody.find(endSpan);
+
+                if(start != std::string::npos)
+                {
+                    start += startMarker2.size();
+
+                    if(end != std::string::npos)
+                        end -= start;
+
+                    message.assign(messageBody, start, end);
+                }
+            }
+        }
+
+//      LL_DEBUGS("Voice") << "    raw message = \n" << message << LL_ENDL;
+
+        // strip formatting tags
+        {
+            std::string::size_type start;
+            std::string::size_type end;
+
+            while((start = message.find('<')) != std::string::npos)
+            {
+                if((end = message.find('>', start + 1)) != std::string::npos)
+                {
+                    // Strip out the tag
+                    message.erase(start, (end + 1) - start);
+                }
+                else
+                {
+                    // Avoid an infinite loop
+                    break;
+                }
+            }
+        }
+
+        // Decode ampersand-escaped chars
+        {
+            std::string::size_type mark = 0;
+
+            // The text may contain text encoded with &lt;, &gt;, and &amp;
+            mark = 0;
+            while((mark = message.find("&lt;", mark)) != std::string::npos)
+            {
+                message.replace(mark, 4, "<");
+                mark += 1;
+            }
+
+            mark = 0;
+            while((mark = message.find("&gt;", mark)) != std::string::npos)
+            {
+                message.replace(mark, 4, ">");
+                mark += 1;
+            }
+
+            mark = 0;
+            while((mark = message.find("&amp;", mark)) != std::string::npos)
+            {
+                message.replace(mark, 5, "&");
+                mark += 1;
+            }
+        }
+
+        // strip leading/trailing whitespace (since we always seem to get a couple newlines)
+        LLStringUtil::trim(message);
+
+//      LL_DEBUGS("Voice") << "    stripped message = \n" << message << LL_ENDL;
 
         sessionStatePtr_t session(findSession(sessionHandle));
-		if(session)
-		{
-			bool is_do_not_disturb = gAgent.isDoNotDisturb();
-			bool is_muted = LLMuteList::getInstance()->isMuted(session->mCallerID, session->mName, LLMute::flagTextChat);
-			bool is_linden = LLMuteList::isLinden(session->mName);
-			LLChat chat;
-
-			chat.mMuted = is_muted && !is_linden;
-
-			if(!chat.mMuted)
-			{
-				chat.mFromID = session->mCallerID;
-				chat.mFromName = session->mName;
-				chat.mSourceType = CHAT_SOURCE_AGENT;
-
-				if(is_do_not_disturb && !is_linden)
-				{
-					// TODO: Question: Return do not disturb mode response here?  Or maybe when session is started instead?
-				}
-
-				LL_DEBUGS("Voice") << "adding message, name " << session->mName << " session " << session->mIMSessionID << ", target " << session->mCallerID << LL_ENDL;
-				LLIMMgr::getInstance()->addMessage(session->mIMSessionID,
-						session->mCallerID,
-						session->mName.c_str(),
-						message.c_str(),
-						false,
-						LLStringUtil::null,		// default arg
-						IM_NOTHING_SPECIAL,		// default arg
-						0,						// default arg
-						LLUUID::null,			// default arg
-						LLVector3::zero);		// default arg
-			}
-		}
-	}
+        if(session)
+        {
+            bool is_do_not_disturb = gAgent.isDoNotDisturb();
+            bool is_muted = LLMuteList::getInstance()->isMuted(session->mCallerID, session->mName, LLMute::flagTextChat);
+            bool is_linden = LLMuteList::isLinden(session->mName);
+            LLChat chat;
+
+            chat.mMuted = is_muted && !is_linden;
+
+            if(!chat.mMuted)
+            {
+                chat.mFromID = session->mCallerID;
+                chat.mFromName = session->mName;
+                chat.mSourceType = CHAT_SOURCE_AGENT;
+
+                if(is_do_not_disturb && !is_linden)
+                {
+                    // TODO: Question: Return do not disturb mode response here?  Or maybe when session is started instead?
+                }
+
+                LL_DEBUGS("Voice") << "adding message, name " << session->mName << " session " << session->mIMSessionID << ", target " << session->mCallerID << LL_ENDL;
+                LLIMMgr::getInstance()->addMessage(session->mIMSessionID,
+                        session->mCallerID,
+                        session->mName.c_str(),
+                        message.c_str(),
+                        false,
+                        LLStringUtil::null,     // default arg
+                        IM_NOTHING_SPECIAL,     // default arg
+                        0,                      // default arg
+                        LLUUID::null,           // default arg
+                        LLVector3::zero);       // default arg
+            }
+        }
+    }
 }
 
 void LLVivoxVoiceClient::sessionNotificationEvent(std::string &sessionHandle, std::string &uriString, std::string &notificationType)
 {
     sessionStatePtr_t session(findSession(sessionHandle));
 
-	if(session)
-	{
-		participantStatePtr_t participant(session->findParticipant(uriString));
-		if(participant)
-		{
-			if (!stricmp(notificationType.c_str(), "Typing"))
-			{
-				// Other end started typing
-				// TODO: The proper way to add a typing notification seems to be LLIMMgr::processIMTypingStart().
-				// It requires some info for the message, which we don't have here.
-			}
-			else if (!stricmp(notificationType.c_str(), "NotTyping"))
-			{
-				// Other end stopped typing
-				// TODO: The proper way to remove a typing notification seems to be LLIMMgr::processIMTypingStop().
-				// It requires some info for the message, which we don't have here.
-			}
-			else
-			{
-				LL_DEBUGS("Voice") << "Unknown notification type " << notificationType << "for participant " << uriString << " in session " << session->mSIPURI << LL_ENDL;
-			}
-		}
-		else
-		{
-			LL_DEBUGS("Voice") << "Unknown participant " << uriString << " in session " << session->mSIPURI << LL_ENDL;
-		}
-	}
-	else
-	{
-		LL_DEBUGS("Voice") << "Unknown session handle " << sessionHandle << LL_ENDL;
-	}
+    if(session)
+    {
+        participantStatePtr_t participant(session->findParticipant(uriString));
+        if(participant)
+        {
+            if (!stricmp(notificationType.c_str(), "Typing"))
+            {
+                // Other end started typing
+                // TODO: The proper way to add a typing notification seems to be LLIMMgr::processIMTypingStart().
+                // It requires some info for the message, which we don't have here.
+            }
+            else if (!stricmp(notificationType.c_str(), "NotTyping"))
+            {
+                // Other end stopped typing
+                // TODO: The proper way to remove a typing notification seems to be LLIMMgr::processIMTypingStop().
+                // It requires some info for the message, which we don't have here.
+            }
+            else
+            {
+                LL_DEBUGS("Voice") << "Unknown notification type " << notificationType << "for participant " << uriString << " in session " << session->mSIPURI << LL_ENDL;
+            }
+        }
+        else
+        {
+            LL_DEBUGS("Voice") << "Unknown participant " << uriString << " in session " << session->mSIPURI << LL_ENDL;
+        }
+    }
+    else
+    {
+        LL_DEBUGS("Voice") << "Unknown session handle " << sessionHandle << LL_ENDL;
+    }
 }
 
 void LLVivoxVoiceClient::voiceServiceConnectionStateChangedEvent(int statusCode, std::string &statusString, std::string &build_id)
 {
-	// We don't generally need to process this. However, one occurence is when we first connect, and so it is the
-	// earliest opportunity to learn what we're connected to.
-	if (statusCode)
-	{
-		LL_WARNS("Voice") << "VoiceServiceConnectionStateChangedEvent statusCode: " << statusCode <<
-			"statusString: " << statusString << LL_ENDL;
-		return;
-	}
-	if (build_id.empty())
-	{
-		return;
-	}
-	mVoiceVersion.mBuildVersion = build_id;
+    // We don't generally need to process this. However, one occurence is when we first connect, and so it is the
+    // earliest opportunity to learn what we're connected to.
+    if (statusCode)
+    {
+        LL_WARNS("Voice") << "VoiceServiceConnectionStateChangedEvent statusCode: " << statusCode <<
+            "statusString: " << statusString << LL_ENDL;
+        return;
+    }
+    if (build_id.empty())
+    {
+        return;
+    }
+    mVoiceVersion.mBuildVersion = build_id;
 }
 
 void LLVivoxVoiceClient::auxAudioPropertiesEvent(F32 energy)
 {
-	LL_DEBUGS("VoiceEnergy") << "got energy " << energy << LL_ENDL;
-	mTuningEnergy = energy;
+    LL_DEBUGS("VoiceEnergy") << "got energy " << energy << LL_ENDL;
+    mTuningEnergy = energy;
 }
 
 void LLVivoxVoiceClient::muteListChanged()
 {
-	// The user's mute list has been updated.  Go through the current participant list and sync it with the mute list.
-	if(mAudioSession)
-	{
-		participantMap::iterator iter = mAudioSession->mParticipantsByURI.begin();
+    // The user's mute list has been updated.  Go through the current participant list and sync it with the mute list.
+    if(mAudioSession)
+    {
+        participantMap::iterator iter = mAudioSession->mParticipantsByURI.begin();
 
-		for(; iter != mAudioSession->mParticipantsByURI.end(); iter++)
-		{
-			participantStatePtr_t p(iter->second);
+        for(; iter != mAudioSession->mParticipantsByURI.end(); iter++)
+        {
+            participantStatePtr_t p(iter->second);
 
-			// Check to see if this participant is on the mute list already
-			if(p->updateMuteState())
-				mAudioSession->mVolumeDirty = true;
-		}
-	}
+            // Check to see if this participant is on the mute list already
+            if(p->updateMuteState())
+                mAudioSession->mVolumeDirty = true;
+        }
+    }
 }
 
 /////////////////////////////
 // Managing list of participants
 LLVivoxVoiceClient::participantState::participantState(const std::string &uri) :
-	 mURI(uri),
-	 mPTT(false),
-	 mIsSpeaking(false),
-	 mIsModeratorMuted(false),
-	 mLastSpokeTimestamp(0.f),
-	 mPower(0.f),
-	 mVolume(LLVoiceClient::VOLUME_DEFAULT),
-	 mUserVolume(0),
-	 mOnMuteList(false),
-	 mVolumeSet(false),
-	 mVolumeDirty(false),
-	 mAvatarIDValid(false),
-	 mIsSelf(false)
+     mURI(uri),
+     mPTT(false),
+     mIsSpeaking(false),
+     mIsModeratorMuted(false),
+     mLastSpokeTimestamp(0.f),
+     mPower(0.f),
+     mVolume(LLVoiceClient::VOLUME_DEFAULT),
+     mUserVolume(0),
+     mOnMuteList(false),
+     mVolumeSet(false),
+     mVolumeDirty(false),
+     mAvatarIDValid(false),
+     mIsSelf(false)
 {
 }
 
 LLVivoxVoiceClient::participantStatePtr_t LLVivoxVoiceClient::sessionState::addParticipant(const std::string &uri)
 {
     participantStatePtr_t result;
-	bool useAlternateURI = false;
-
-	// Note: this is mostly the body of LLVivoxVoiceClient::sessionState::findParticipant(), but since we need to know if it
-	// matched the alternate SIP URI (so we can add it properly), we need to reproduce it here.
-	{
-		participantMap::iterator iter = mParticipantsByURI.find(uri);
-
-		if(iter == mParticipantsByURI.end())
-		{
-			if(!mAlternateSIPURI.empty() && (uri == mAlternateSIPURI))
-			{
-				// This is a p2p session (probably with the SLIM client) with an alternate URI for the other participant.
-				// Use mSIPURI instead, since it will be properly encoded.
-				iter = mParticipantsByURI.find(mSIPURI);
-				useAlternateURI = true;
-			}
-		}
-
-		if(iter != mParticipantsByURI.end())
-		{
-			result = iter->second;
-		}
-	}
-
-	if(!result)
-	{
-		// participant isn't already in one list or the other.
-		result.reset(new participantState(useAlternateURI?mSIPURI:uri));
-		mParticipantsByURI.insert(participantMap::value_type(result->mURI, result));
-		mParticipantsChanged = true;
-
-		// Try to do a reverse transform on the URI to get the GUID back.
-		{
-			LLUUID id;
-			if(LLVivoxVoiceClient::getInstance()->IDFromName(result->mURI, id))
-			{
-				result->mAvatarIDValid = true;
-				result->mAvatarID = id;
-			}
-			else
-			{
-				// Create a UUID by hashing the URI, but do NOT set mAvatarIDValid.
-				// This indicates that the ID will not be in the name cache.
-				result->mAvatarID.generate(uri);
-			}
-		}
+    bool useAlternateURI = false;
+
+    // Note: this is mostly the body of LLVivoxVoiceClient::sessionState::findParticipant(), but since we need to know if it
+    // matched the alternate SIP URI (so we can add it properly), we need to reproduce it here.
+    {
+        participantMap::iterator iter = mParticipantsByURI.find(uri);
+
+        if(iter == mParticipantsByURI.end())
+        {
+            if(!mAlternateSIPURI.empty() && (uri == mAlternateSIPURI))
+            {
+                // This is a p2p session (probably with the SLIM client) with an alternate URI for the other participant.
+                // Use mSIPURI instead, since it will be properly encoded.
+                iter = mParticipantsByURI.find(mSIPURI);
+                useAlternateURI = true;
+            }
+        }
+
+        if(iter != mParticipantsByURI.end())
+        {
+            result = iter->second;
+        }
+    }
+
+    if(!result)
+    {
+        // participant isn't already in one list or the other.
+        result.reset(new participantState(useAlternateURI?mSIPURI:uri));
+        mParticipantsByURI.insert(participantMap::value_type(result->mURI, result));
+        mParticipantsChanged = true;
+
+        // Try to do a reverse transform on the URI to get the GUID back.
+        {
+            LLUUID id;
+            if(LLVivoxVoiceClient::getInstance()->IDFromName(result->mURI, id))
+            {
+                result->mAvatarIDValid = true;
+                result->mAvatarID = id;
+            }
+            else
+            {
+                // Create a UUID by hashing the URI, but do NOT set mAvatarIDValid.
+                // This indicates that the ID will not be in the name cache.
+                result->mAvatarID.generate(uri);
+            }
+        }
 
         if(result->updateMuteState())
         {
-	        mMuteDirty = true;
+            mMuteDirty = true;
         }
 
-		mParticipantsByUUID.insert(participantUUIDMap::value_type(result->mAvatarID, result));
+        mParticipantsByUUID.insert(participantUUIDMap::value_type(result->mAvatarID, result));
 
-		if (LLSpeakerVolumeStorage::getInstance()->getSpeakerVolume(result->mAvatarID, result->mVolume))
-		{
-			result->mVolumeDirty = true;
-			mVolumeDirty = true;
-		}
+        if (LLSpeakerVolumeStorage::getInstance()->getSpeakerVolume(result->mAvatarID, result->mVolume))
+        {
+            result->mVolumeDirty = true;
+            mVolumeDirty = true;
+        }
 
-		LL_DEBUGS("Voice") << "participant \"" << result->mURI << "\" added." << LL_ENDL;
-	}
+        LL_DEBUGS("Voice") << "participant \"" << result->mURI << "\" added." << LL_ENDL;
+    }
 
-	return result;
+    return result;
 }
 
 bool LLVivoxVoiceClient::participantState::updateMuteState()
 {
-	bool result = false;
+    bool result = false;
 
-	bool isMuted = LLMuteList::getInstance()->isMuted(mAvatarID, LLMute::flagVoiceChat);
-	if(mOnMuteList != isMuted)
-	{
-	    mOnMuteList = isMuted;
-	    mVolumeDirty = true;
-	    result = true;
-	}
-	return result;
+    bool isMuted = LLMuteList::getInstance()->isMuted(mAvatarID, LLMute::flagVoiceChat);
+    if(mOnMuteList != isMuted)
+    {
+        mOnMuteList = isMuted;
+        mVolumeDirty = true;
+        result = true;
+    }
+    return result;
 }
 
 bool LLVivoxVoiceClient::participantState::isAvatar()
 {
-	return mAvatarIDValid;
+    return mAvatarIDValid;
 }
 
 void LLVivoxVoiceClient::sessionState::removeParticipant(const LLVivoxVoiceClient::participantStatePtr_t &participant)
 {
-	if(participant)
-	{
-		participantMap::iterator iter = mParticipantsByURI.find(participant->mURI);
-		participantUUIDMap::iterator iter2 = mParticipantsByUUID.find(participant->mAvatarID);
-
-		LL_DEBUGS("Voice") << "participant \"" << participant->mURI <<  "\" (" << participant->mAvatarID << ") removed." << LL_ENDL;
-
-		if(iter == mParticipantsByURI.end())
-		{
-			LL_WARNS("Voice") << "Internal error: participant " << participant->mURI << " not in URI map" << LL_ENDL;
-		}
-		else if(iter2 == mParticipantsByUUID.end())
-		{
-			LL_WARNS("Voice") << "Internal error: participant ID " << participant->mAvatarID << " not in UUID map" << LL_ENDL;
-		}
-		else if(iter->second != iter2->second)
-		{
-			LL_WARNS("Voice") << "Internal error: participant mismatch!" << LL_ENDL;
-		}
-		else
-		{
-			mParticipantsByURI.erase(iter);
-			mParticipantsByUUID.erase(iter2);
+    if(participant)
+    {
+        participantMap::iterator iter = mParticipantsByURI.find(participant->mURI);
+        participantUUIDMap::iterator iter2 = mParticipantsByUUID.find(participant->mAvatarID);
+
+        LL_DEBUGS("Voice") << "participant \"" << participant->mURI <<  "\" (" << participant->mAvatarID << ") removed." << LL_ENDL;
+
+        if(iter == mParticipantsByURI.end())
+        {
+            LL_WARNS("Voice") << "Internal error: participant " << participant->mURI << " not in URI map" << LL_ENDL;
+        }
+        else if(iter2 == mParticipantsByUUID.end())
+        {
+            LL_WARNS("Voice") << "Internal error: participant ID " << participant->mAvatarID << " not in UUID map" << LL_ENDL;
+        }
+        else if(iter->second != iter2->second)
+        {
+            LL_WARNS("Voice") << "Internal error: participant mismatch!" << LL_ENDL;
+        }
+        else
+        {
+            mParticipantsByURI.erase(iter);
+            mParticipantsByUUID.erase(iter2);
 
             mParticipantsChanged = true;
-		}
-	}
+        }
+    }
 }
 
 void LLVivoxVoiceClient::sessionState::removeAllParticipants()
 {
-	LL_DEBUGS("Voice") << "called" << LL_ENDL;
+    LL_DEBUGS("Voice") << "called" << LL_ENDL;
 
-	while(!mParticipantsByURI.empty())
-	{
-		removeParticipant(mParticipantsByURI.begin()->second);
-	}
+    while(!mParticipantsByURI.empty())
+    {
+        removeParticipant(mParticipantsByURI.begin()->second);
+    }
 
-	if(!mParticipantsByUUID.empty())
-	{
-		LL_WARNS("Voice") << "Internal error: empty URI map, non-empty UUID map" << LL_ENDL;
-	}
+    if(!mParticipantsByUUID.empty())
+    {
+        LL_WARNS("Voice") << "Internal error: empty URI map, non-empty UUID map" << LL_ENDL;
+    }
 }
 
 /*static*/
@@ -4724,15 +4724,15 @@ void LLVivoxVoiceClient::sessionState::VerifySessions()
 
 void LLVivoxVoiceClient::getParticipantList(std::set<LLUUID> &participants)
 {
-	if(mProcessChannels && mAudioSession)
-	{
-		for(participantUUIDMap::iterator iter = mAudioSession->mParticipantsByUUID.begin();
-			iter != mAudioSession->mParticipantsByUUID.end();
-			iter++)
-		{
-			participants.insert(iter->first);
-		}
-	}
+    if(mProcessChannels && mAudioSession)
+    {
+        for(participantUUIDMap::iterator iter = mAudioSession->mParticipantsByUUID.begin();
+            iter != mAudioSession->mParticipantsByUUID.end();
+            iter++)
+        {
+            participants.insert(iter->first);
+        }
+    }
 }
 
 bool LLVivoxVoiceClient::isParticipant(const LLUUID &speaker_id)
@@ -4749,49 +4749,49 @@ LLVivoxVoiceClient::participantStatePtr_t LLVivoxVoiceClient::sessionState::find
 {
     participantStatePtr_t result;
 
-	participantMap::iterator iter = mParticipantsByURI.find(uri);
+    participantMap::iterator iter = mParticipantsByURI.find(uri);
 
-	if(iter == mParticipantsByURI.end())
-	{
-		if(!mAlternateSIPURI.empty() && (uri == mAlternateSIPURI))
-		{
-			// This is a p2p session (probably with the SLIM client) with an alternate URI for the other participant.
-			// Look up the other URI
-			iter = mParticipantsByURI.find(mSIPURI);
-		}
-	}
+    if(iter == mParticipantsByURI.end())
+    {
+        if(!mAlternateSIPURI.empty() && (uri == mAlternateSIPURI))
+        {
+            // This is a p2p session (probably with the SLIM client) with an alternate URI for the other participant.
+            // Look up the other URI
+            iter = mParticipantsByURI.find(mSIPURI);
+        }
+    }
 
-	if(iter != mParticipantsByURI.end())
-	{
-		result = iter->second;
-	}
+    if(iter != mParticipantsByURI.end())
+    {
+        result = iter->second;
+    }
 
-	return result;
+    return result;
 }
 
 LLVivoxVoiceClient::participantStatePtr_t LLVivoxVoiceClient::sessionState::findParticipantByID(const LLUUID& id)
 {
     participantStatePtr_t result;
-	participantUUIDMap::iterator iter = mParticipantsByUUID.find(id);
+    participantUUIDMap::iterator iter = mParticipantsByUUID.find(id);
 
-	if(iter != mParticipantsByUUID.end())
-	{
-		result = iter->second;
-	}
+    if(iter != mParticipantsByUUID.end())
+    {
+        result = iter->second;
+    }
 
-	return result;
+    return result;
 }
 
 LLVivoxVoiceClient::participantStatePtr_t LLVivoxVoiceClient::findParticipantByID(const LLUUID& id)
 {
     participantStatePtr_t result;
 
-	if(mAudioSession)
-	{
-		result = mAudioSession->findParticipantByID(id);
-	}
+    if(mAudioSession)
+    {
+        result = mAudioSession->findParticipantByID(id);
+    }
 
-	return result;
+    return result;
 }
 
 
@@ -4799,44 +4799,44 @@ LLVivoxVoiceClient::participantStatePtr_t LLVivoxVoiceClient::findParticipantByI
 // Check for parcel boundary crossing
 bool LLVivoxVoiceClient::checkParcelChanged(bool update)
 {
-	LLViewerRegion *region = gAgent.getRegion();
-	LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-
-	if(region && parcel)
-	{
-		S32 parcelLocalID = parcel->getLocalID();
-		std::string regionName = region->getName();
-
-		//			LL_DEBUGS("Voice") << "Region name = \"" << regionName << "\", parcel local ID = " << parcelLocalID << ", cap URI = \"" << capURI << "\"" << LL_ENDL;
-
-		// The region name starts out empty and gets filled in later.
-		// Also, the cap gets filled in a short time after the region cross, but a little too late for our purposes.
-		// If either is empty, wait for the next time around.
-		if(!regionName.empty())
-		{
-			if((parcelLocalID != mCurrentParcelLocalID) || (regionName != mCurrentRegionName))
-			{
-				// We have changed parcels.  Initiate a parcel channel lookup.
-				if (update)
-				{
-					mCurrentParcelLocalID = parcelLocalID;
-					mCurrentRegionName = regionName;
-				}
-				return true;
-			}
-		}
-	}
-	return false;
+    LLViewerRegion *region = gAgent.getRegion();
+    LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
+
+    if(region && parcel)
+    {
+        S32 parcelLocalID = parcel->getLocalID();
+        std::string regionName = region->getName();
+
+        //          LL_DEBUGS("Voice") << "Region name = \"" << regionName << "\", parcel local ID = " << parcelLocalID << ", cap URI = \"" << capURI << "\"" << LL_ENDL;
+
+        // The region name starts out empty and gets filled in later.
+        // Also, the cap gets filled in a short time after the region cross, but a little too late for our purposes.
+        // If either is empty, wait for the next time around.
+        if(!regionName.empty())
+        {
+            if((parcelLocalID != mCurrentParcelLocalID) || (regionName != mCurrentRegionName))
+            {
+                // We have changed parcels.  Initiate a parcel channel lookup.
+                if (update)
+                {
+                    mCurrentParcelLocalID = parcelLocalID;
+                    mCurrentRegionName = regionName;
+                }
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 bool LLVivoxVoiceClient::switchChannel(
-	std::string uri,
-	bool spatial,
-	bool no_reconnect,
-	bool is_p2p,
-	std::string hash)
+    std::string uri,
+    bool spatial,
+    bool no_reconnect,
+    bool is_p2p,
+    std::string hash)
 {
-	bool needsSwitch = !mIsInChannel;
+    bool needsSwitch = !mIsInChannel;
 
     if (mIsInChannel)
     {
@@ -4884,17 +4884,17 @@ bool LLVivoxVoiceClient::switchChannel(
     }
 
     if(needsSwitch)
-	{
-		if(uri.empty())
-		{
-			// Leave any channel we may be in
-			LL_DEBUGS("Voice") << "leaving channel" << LL_ENDL;
+    {
+        if(uri.empty())
+        {
+            // Leave any channel we may be in
+            LL_DEBUGS("Voice") << "leaving channel" << LL_ENDL;
 
             sessionStatePtr_t oldSession = mNextAudioSession;
-			mNextAudioSession.reset();
+            mNextAudioSession.reset();
 
-			// The old session may now need to be deleted.
-			reapSession(oldSession);
+            // The old session may now need to be deleted.
+            reapSession(oldSession);
 
             // If voice was on, turn it off
             if (LLVoiceClient::getInstance()->getUserPTTState())
@@ -4902,33 +4902,33 @@ bool LLVivoxVoiceClient::switchChannel(
                 LLVoiceClient::getInstance()->setUserPTTState(false);
             }
 
-			notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_VOICE_DISABLED);
-		}
-		else
-		{
-			LL_DEBUGS("Voice") << "switching to channel " << uri << LL_ENDL;
+            notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_VOICE_DISABLED);
+        }
+        else
+        {
+            LL_DEBUGS("Voice") << "switching to channel " << uri << LL_ENDL;
 
-			mNextAudioSession = addSession(uri);
-			mNextAudioSession->mHash = hash;
-			mNextAudioSession->mIsSpatial = spatial;
-			mNextAudioSession->mReconnect = !no_reconnect;
-			mNextAudioSession->mIsP2P = is_p2p;
-		}
+            mNextAudioSession = addSession(uri);
+            mNextAudioSession->mHash = hash;
+            mNextAudioSession->mIsSpatial = spatial;
+            mNextAudioSession->mReconnect = !no_reconnect;
+            mNextAudioSession->mIsP2P = is_p2p;
+        }
 
         if (mIsInChannel)
-		{
-			// If we're already in a channel, or if we're joining one, terminate
-			// so we can rejoin with the new session data.
-			sessionTerminate();
-		}
-	}
+        {
+            // If we're already in a channel, or if we're joining one, terminate
+            // so we can rejoin with the new session data.
+            sessionTerminate();
+        }
+    }
 
     return needsSwitch;
 }
 
 void LLVivoxVoiceClient::joinSession(const sessionStatePtr_t &session)
 {
-	mNextAudioSession = session;
+    mNextAudioSession = session;
 
     if (mIsInChannel)
     {
@@ -4947,33 +4947,33 @@ bool LLVivoxVoiceClient::setSpatialChannel(const LLSD& channelInfo)
 {
     mSpatialSessionURI         = channelInfo["channel_uri"].asString();
     mSpatialSessionCredentials = channelInfo["channel_credentials"].asString();
-	if (!mProcessChannels)
-	{
-		// we're not even processing channels (another provider is) so 
-		// save the credentials aside and exit
-		return false;
-	}
-
-	LL_DEBUGS("Voice") << "got spatial channel uri: \"" << mSpatialSessionURI << "\"" << LL_ENDL;
-
-	if((mIsInChannel && mAudioSession && !(mAudioSession->mIsSpatial)) || (mNextAudioSession && !(mNextAudioSession->mIsSpatial)))
-	{
-		// User is in a non-spatial chat or joining a non-spatial chat.  Don't switch channels.
-		LL_INFOS("Voice") << "in non-spatial chat, not switching channels" << LL_ENDL;
+    if (!mProcessChannels)
+    {
+        // we're not even processing channels (another provider is) so
+        // save the credentials aside and exit
+        return false;
+    }
+
+    LL_DEBUGS("Voice") << "got spatial channel uri: \"" << mSpatialSessionURI << "\"" << LL_ENDL;
+
+    if((mIsInChannel && mAudioSession && !(mAudioSession->mIsSpatial)) || (mNextAudioSession && !(mNextAudioSession->mIsSpatial)))
+    {
+        // User is in a non-spatial chat or joining a non-spatial chat.  Don't switch channels.
+        LL_INFOS("Voice") << "in non-spatial chat, not switching channels" << LL_ENDL;
         return false;
-	}
-	else
-	{
-		return switchChannel(mSpatialSessionURI, true, false, false, mSpatialSessionCredentials);
-	}
+    }
+    else
+    {
+        return switchChannel(mSpatialSessionURI, true, false, false, mSpatialSessionCredentials);
+    }
 }
 
 void LLVivoxVoiceClient::callUser(const LLUUID &uuid)
 {
-	std::string userURI = sipURIFromID(uuid);
-	mProcessChannels = true;
+    std::string userURI = sipURIFromID(uuid);
+    mProcessChannels = true;
 
-	switchChannel(userURI, false, true, true);
+    switchChannel(userURI, false, true, true);
 }
 
 void LLVivoxVoiceClient::hangup() { leaveChannel(); }
@@ -5025,75 +5025,75 @@ bool LLVivoxVoiceClient::isVoiceWorking() const
 // Currently this will be false only for PSTN callers into group chats, and PSTN p2p calls.
 BOOL LLVivoxVoiceClient::isParticipantAvatar(const LLUUID &id)
 {
-	BOOL result = TRUE;
+    BOOL result = TRUE;
     sessionStatePtr_t session(findSession(id));
 
-	if(session)
-	{
-		// this is a p2p session with the indicated caller, or the session with the specified UUID.
-		if(session->mSynthesizedCallerID)
-			result = FALSE;
-	}
-	else
-	{
-		// Didn't find a matching session -- check the current audio session for a matching participant
-		if(mAudioSession)
-		{
+    if(session)
+    {
+        // this is a p2p session with the indicated caller, or the session with the specified UUID.
+        if(session->mSynthesizedCallerID)
+            result = FALSE;
+    }
+    else
+    {
+        // Didn't find a matching session -- check the current audio session for a matching participant
+        if(mAudioSession)
+        {
             participantStatePtr_t participant(findParticipantByID(id));
-			if(participant)
-			{
-				result = participant->isAvatar();
-			}
-		}
-	}
+            if(participant)
+            {
+                result = participant->isAvatar();
+            }
+        }
+    }
 
-	return result;
+    return result;
 }
 
 // Returns true if calling back the session URI after the session has closed is possible.
 // Currently this will be false only for PSTN P2P calls.
 BOOL LLVivoxVoiceClient::isSessionCallBackPossible(const LLUUID &session_id)
 {
-	BOOL result = TRUE;
+    BOOL result = TRUE;
     sessionStatePtr_t session(findSession(session_id));
 
-	if(session != NULL)
-	{
-		result = session->isCallBackPossible();
-	}
+    if(session != NULL)
+    {
+        result = session->isCallBackPossible();
+    }
 
-	return result;
+    return result;
 }
 
 // Returns true if the session can accept text IM's.
 // Currently this will be false only for PSTN P2P calls.
 BOOL LLVivoxVoiceClient::isSessionTextIMPossible(const LLUUID &session_id)
 {
-	bool result = TRUE;
+    bool result = TRUE;
     sessionStatePtr_t session(findSession(session_id));
 
-	if(session != NULL)
-	{
-		result = session->isTextIMPossible();
-	}
+    if(session != NULL)
+    {
+        result = session->isTextIMPossible();
+    }
 
-	return result;
+    return result;
 }
 
 void LLVivoxVoiceClient::leaveNonSpatialChannel()
 {
     LL_DEBUGS("Voice") << "Request to leave spacial channel." << LL_ENDL;
 
-	// Make sure we don't rejoin the current session.
+    // Make sure we don't rejoin the current session.
     sessionStatePtr_t oldNextSession(mNextAudioSession);
-	mNextAudioSession.reset();
+    mNextAudioSession.reset();
 
-	// Most likely this will still be the current session at this point, but check it anyway.
-	reapSession(oldNextSession);
+    // Most likely this will still be the current session at this point, but check it anyway.
+    reapSession(oldNextSession);
 
-	verifySessionState();
+    verifySessionState();
 
-	sessionTerminate();
+    sessionTerminate();
 }
 
 void LLVivoxVoiceClient::processChannels(bool process)
@@ -5115,7 +5115,7 @@ bool LLVivoxVoiceClient::isCurrentChannel(const LLSD &channelInfo)
         {
             return mAudioSession->mHandle == channelInfo["session_handle"].asString();
         }
-		return channelInfo["channel_uri"].asString() == mAudioSession->mSIPURI;
+        return channelInfo["channel_uri"].asString() == mAudioSession->mSIPURI;
     }
     return false;
 }
@@ -5129,153 +5129,153 @@ bool LLVivoxVoiceClient::compareChannels(const LLSD& channelInfo1, const LLSD& c
 
 bool LLVivoxVoiceClient::inProximalChannel()
 {
-	bool result = false;
+    bool result = false;
 
     if (mIsInChannel && !mSessionTerminateRequested)
-	{
-		result = inSpatialChannel();
-	}
+    {
+        result = inSpatialChannel();
+    }
 
-	return result;
+    return result;
 }
 
 std::string LLVivoxVoiceClient::sipURIFromID(const LLUUID &id)
 {
-	std::string result;
-	result = "sip:";
-	result += nameFromID(id);
-	result += "@";
-	result += mVoiceSIPURIHostName;
+    std::string result;
+    result = "sip:";
+    result += nameFromID(id);
+    result += "@";
+    result += mVoiceSIPURIHostName;
 
-	return result;
+    return result;
 }
 
 std::string LLVivoxVoiceClient::sipURIFromAvatar(LLVOAvatar *avatar)
 {
-	std::string result;
-	if(avatar)
-	{
-		result = "sip:";
-		result += nameFromID(avatar->getID());
-		result += "@";
-		result += mVoiceSIPURIHostName;
-	}
+    std::string result;
+    if(avatar)
+    {
+        result = "sip:";
+        result += nameFromID(avatar->getID());
+        result += "@";
+        result += mVoiceSIPURIHostName;
+    }
 
-	return result;
+    return result;
 }
 
 std::string LLVivoxVoiceClient::nameFromID(const LLUUID &uuid)
 {
-	std::string result;
+    std::string result;
 
-	if (uuid.isNull()) {
-		//VIVOX, the uuid emtpy look for the mURIString and return that instead.
-		//result.assign(uuid.mURIStringName);
-		LLStringUtil::replaceChar(result, '_', ' ');
-		return result;
-	}
-	// Prepending this apparently prevents conflicts with reserved names inside the vivox code.
-	result = "x";
+    if (uuid.isNull()) {
+        //VIVOX, the uuid emtpy look for the mURIString and return that instead.
+        //result.assign(uuid.mURIStringName);
+        LLStringUtil::replaceChar(result, '_', ' ');
+        return result;
+    }
+    // Prepending this apparently prevents conflicts with reserved names inside the vivox code.
+    result = "x";
 
-	// Base64 encode and replace the pieces of base64 that are less compatible
-	// with e-mail local-parts.
-	// See RFC-4648 "Base 64 Encoding with URL and Filename Safe Alphabet"
-	result += LLBase64::encode(uuid.mData, UUID_BYTES);
-	LLStringUtil::replaceChar(result, '+', '-');
-	LLStringUtil::replaceChar(result, '/', '_');
+    // Base64 encode and replace the pieces of base64 that are less compatible
+    // with e-mail local-parts.
+    // See RFC-4648 "Base 64 Encoding with URL and Filename Safe Alphabet"
+    result += LLBase64::encode(uuid.mData, UUID_BYTES);
+    LLStringUtil::replaceChar(result, '+', '-');
+    LLStringUtil::replaceChar(result, '/', '_');
 
-	// If you need to transform a GUID to this form on the Mac OS X command line, this will do so:
-	// echo -n x && (echo e669132a-6c43-4ee1-a78d-6c82fff59f32 |xxd -r -p |openssl base64|tr '/+' '_-')
+    // If you need to transform a GUID to this form on the Mac OS X command line, this will do so:
+    // echo -n x && (echo e669132a-6c43-4ee1-a78d-6c82fff59f32 |xxd -r -p |openssl base64|tr '/+' '_-')
 
-	// The reverse transform can be done with:
-	// echo 'x5mkTKmxDTuGnjWyC__WfMg==' |cut -b 2- -|tr '_-' '/+' |openssl base64 -d|xxd -p
+    // The reverse transform can be done with:
+    // echo 'x5mkTKmxDTuGnjWyC__WfMg==' |cut -b 2- -|tr '_-' '/+' |openssl base64 -d|xxd -p
 
-	return result;
+    return result;
 }
 
 bool LLVivoxVoiceClient::IDFromName(const std::string inName, LLUUID &uuid)
 {
-	bool result = false;
+    bool result = false;
 
-	// SLIM SDK: The "name" may actually be a SIP URI such as: "sip:xFnPP04IpREWNkuw1cOXlhw==@bhr.vivox.com"
-	// If it is, convert to a bare name before doing the transform.
-	std::string name = nameFromsipURI(inName);
+    // SLIM SDK: The "name" may actually be a SIP URI such as: "sip:xFnPP04IpREWNkuw1cOXlhw==@bhr.vivox.com"
+    // If it is, convert to a bare name before doing the transform.
+    std::string name = nameFromsipURI(inName);
 
-	// Doesn't look like a SIP URI, assume it's an actual name.
-	if(name.empty())
-		name = inName;
+    // Doesn't look like a SIP URI, assume it's an actual name.
+    if(name.empty())
+        name = inName;
 
-	// This will only work if the name is of the proper form.
-	// As an example, the account name for Monroe Linden (UUID 1673cfd3-8229-4445-8d92-ec3570e5e587) is:
-	// "xFnPP04IpREWNkuw1cOXlhw=="
+    // This will only work if the name is of the proper form.
+    // As an example, the account name for Monroe Linden (UUID 1673cfd3-8229-4445-8d92-ec3570e5e587) is:
+    // "xFnPP04IpREWNkuw1cOXlhw=="
 
-	if((name.size() == 25) && (name[0] == 'x') && (name[23] == '=') && (name[24] == '='))
-	{
-		// The name appears to have the right form.
+    if((name.size() == 25) && (name[0] == 'x') && (name[23] == '=') && (name[24] == '='))
+    {
+        // The name appears to have the right form.
 
-		// Reverse the transforms done by nameFromID
-		std::string temp = name;
-		LLStringUtil::replaceChar(temp, '-', '+');
-		LLStringUtil::replaceChar(temp, '_', '/');
+        // Reverse the transforms done by nameFromID
+        std::string temp = name;
+        LLStringUtil::replaceChar(temp, '-', '+');
+        LLStringUtil::replaceChar(temp, '_', '/');
 
-		U8 rawuuid[UUID_BYTES + 1];
-		int len = apr_base64_decode_binary(rawuuid, temp.c_str() + 1);
-		if(len == UUID_BYTES)
-		{
-			// The decode succeeded.  Stuff the bits into the result's UUID
-			memcpy(uuid.mData, rawuuid, UUID_BYTES);
-			result = true;
-		}
-	}
+        U8 rawuuid[UUID_BYTES + 1];
+        int len = apr_base64_decode_binary(rawuuid, temp.c_str() + 1);
+        if(len == UUID_BYTES)
+        {
+            // The decode succeeded.  Stuff the bits into the result's UUID
+            memcpy(uuid.mData, rawuuid, UUID_BYTES);
+            result = true;
+        }
+    }
 
-	if(!result)
-	{
-		// VIVOX:  not a standard account name, just copy the URI name mURIString field
-		// and hope for the best.  bpj
-		uuid.setNull();  // VIVOX, set the uuid field to nulls
-	}
+    if(!result)
+    {
+        // VIVOX:  not a standard account name, just copy the URI name mURIString field
+        // and hope for the best.  bpj
+        uuid.setNull();  // VIVOX, set the uuid field to nulls
+    }
 
-	return result;
+    return result;
 }
 
 std::string LLVivoxVoiceClient::sipURIFromName(std::string &name)
 {
-	std::string result;
-	result = "sip:";
-	result += name;
-	result += "@";
-	result += mVoiceSIPURIHostName;
+    std::string result;
+    result = "sip:";
+    result += name;
+    result += "@";
+    result += mVoiceSIPURIHostName;
 
-//	LLStringUtil::toLower(result);
+//  LLStringUtil::toLower(result);
 
-	return result;
+    return result;
 }
 
 std::string LLVivoxVoiceClient::nameFromsipURI(const std::string &uri)
 {
-	std::string result;
+    std::string result;
 
-	std::string::size_type sipOffset, atOffset;
-	sipOffset = uri.find("sip:");
-	atOffset = uri.find("@");
-	if((sipOffset != std::string::npos) && (atOffset != std::string::npos))
-	{
-		result = uri.substr(sipOffset + 4, atOffset - (sipOffset + 4));
-	}
+    std::string::size_type sipOffset, atOffset;
+    sipOffset = uri.find("sip:");
+    atOffset = uri.find("@");
+    if((sipOffset != std::string::npos) && (atOffset != std::string::npos))
+    {
+        result = uri.substr(sipOffset + 4, atOffset - (sipOffset + 4));
+    }
 
-	return result;
+    return result;
 }
 
 bool LLVivoxVoiceClient::inSpatialChannel(void)
 {
-	bool result = false;
+    bool result = false;
 
-	if(mAudioSession)
+    if(mAudioSession)
     {
-		result = mAudioSession->mIsSpatial;
+        result = mAudioSession->mIsSpatial;
     }
 
-	return result;
+    return result;
 }
 
 
@@ -5283,22 +5283,22 @@ LLSD LLVivoxVoiceClient::getAudioSessionChannelInfo()
 {
     LLSD result;
 
-	if (mAudioSession)
-	{
+    if (mAudioSession)
+    {
         result = mAudioSession->getVoiceChannelInfo();
-	}
+    }
 
-	return result;
+    return result;
 }
 
 std::string LLVivoxVoiceClient::getAudioSessionHandle()
 {
-	std::string result;
+    std::string result;
 
-	if(mAudioSession)
-		result = mAudioSession->mHandle;
+    if(mAudioSession)
+        result = mAudioSession->mHandle;
 
-	return result;
+    return result;
 }
 
 
@@ -5307,138 +5307,138 @@ std::string LLVivoxVoiceClient::getAudioSessionHandle()
 
 void LLVivoxVoiceClient::enforceTether(void)
 {
-	LLVector3d tethered	= mCameraRequestedPosition;
+    LLVector3d tethered = mCameraRequestedPosition;
 
-	// constrain 'tethered' to within 50m of mAvatarPosition.
-	{
-		F32 max_dist = 50.0f;
-		LLVector3d camera_offset = mCameraRequestedPosition - mAvatarPosition;
-		F32 camera_distance = (F32)camera_offset.magVec();
-		if(camera_distance > max_dist)
-		{
-			tethered = mAvatarPosition +
-				(max_dist / camera_distance) * camera_offset;
-		}
-	}
+    // constrain 'tethered' to within 50m of mAvatarPosition.
+    {
+        F32 max_dist = 50.0f;
+        LLVector3d camera_offset = mCameraRequestedPosition - mAvatarPosition;
+        F32 camera_distance = (F32)camera_offset.magVec();
+        if(camera_distance > max_dist)
+        {
+            tethered = mAvatarPosition +
+                (max_dist / camera_distance) * camera_offset;
+        }
+    }
 
-	if(dist_vec_squared(mCameraPosition, tethered) > 0.01)
-	{
-		mCameraPosition = tethered;
-		mSpatialCoordsDirty = true;
-	}
+    if(dist_vec_squared(mCameraPosition, tethered) > 0.01)
+    {
+        mCameraPosition = tethered;
+        mSpatialCoordsDirty = true;
+    }
 }
 
 void LLVivoxVoiceClient::updatePosition(void)
 {
 
-	LLViewerRegion *region = gAgent.getRegion();
-	if(region && isAgentAvatarValid())
-	{
-		LLMatrix3 rot;
-		LLVector3d pos;
+    LLViewerRegion *region = gAgent.getRegion();
+    if(region && isAgentAvatarValid())
+    {
+        LLMatrix3 rot;
+        LLVector3d pos;
         LLQuaternion qrot;
 
-		// TODO: If camera and avatar velocity are actually used by the voice system, we could compute them here...
-		// They're currently always set to zero.
+        // TODO: If camera and avatar velocity are actually used by the voice system, we could compute them here...
+        // They're currently always set to zero.
 
-		// Send the current camera position to the voice code
-		rot.setRows(LLViewerCamera::getInstance()->getAtAxis(), LLViewerCamera::getInstance()->getLeftAxis (),  LLViewerCamera::getInstance()->getUpAxis());
-		pos = gAgent.getRegion()->getPosGlobalFromRegion(LLViewerCamera::getInstance()->getOrigin());
+        // Send the current camera position to the voice code
+        rot.setRows(LLViewerCamera::getInstance()->getAtAxis(), LLViewerCamera::getInstance()->getLeftAxis (),  LLViewerCamera::getInstance()->getUpAxis());
+        pos = gAgent.getRegion()->getPosGlobalFromRegion(LLViewerCamera::getInstance()->getOrigin());
 
-		LLVivoxVoiceClient::getInstance()->setCameraPosition(
-															 pos,				// position
-															 LLVector3::zero, 	// velocity
-															 rot);				// rotation matrix
+        LLVivoxVoiceClient::getInstance()->setCameraPosition(
+                                                             pos,               // position
+                                                             LLVector3::zero,   // velocity
+                                                             rot);              // rotation matrix
 
-		// Send the current avatar position to the voice code
+        // Send the current avatar position to the voice code
         qrot = gAgentAvatarp->getRootJoint()->getWorldRotation();
-		pos = gAgentAvatarp->getPositionGlobal();
+        pos = gAgentAvatarp->getPositionGlobal();
 
-		// TODO: Can we get the head offset from outside the LLVOAvatar?
-		//			pos += LLVector3d(mHeadOffset);
-		pos += LLVector3d(0.f, 0.f, 1.f);
+        // TODO: Can we get the head offset from outside the LLVOAvatar?
+        //          pos += LLVector3d(mHeadOffset);
+        pos += LLVector3d(0.f, 0.f, 1.f);
 
-		LLVivoxVoiceClient::getInstance()->setAvatarPosition(
-															 pos,				// position
-															 LLVector3::zero, 	// velocity
-															 qrot);				// rotation matrix
-	}
+        LLVivoxVoiceClient::getInstance()->setAvatarPosition(
+                                                             pos,               // position
+                                                             LLVector3::zero,   // velocity
+                                                             qrot);             // rotation matrix
+    }
 }
 
 void LLVivoxVoiceClient::setCameraPosition(const LLVector3d &position, const LLVector3 &velocity, const LLMatrix3 &rot)
 {
-	mCameraRequestedPosition = position;
+    mCameraRequestedPosition = position;
 
-	if(mCameraVelocity != velocity)
-	{
-		mCameraVelocity = velocity;
-		mSpatialCoordsDirty = true;
-	}
+    if(mCameraVelocity != velocity)
+    {
+        mCameraVelocity = velocity;
+        mSpatialCoordsDirty = true;
+    }
 
-	if(mCameraRot != rot)
-	{
-		mCameraRot = rot;
-		mSpatialCoordsDirty = true;
-	}
+    if(mCameraRot != rot)
+    {
+        mCameraRot = rot;
+        mSpatialCoordsDirty = true;
+    }
 }
 
 void LLVivoxVoiceClient::setAvatarPosition(const LLVector3d &position, const LLVector3 &velocity, const LLQuaternion &rot)
 {
-	if(dist_vec_squared(mAvatarPosition, position) > 0.01)
-	{
-		mAvatarPosition = position;
-		mSpatialCoordsDirty = true;
-	}
+    if(dist_vec_squared(mAvatarPosition, position) > 0.01)
+    {
+        mAvatarPosition = position;
+        mSpatialCoordsDirty = true;
+    }
 
-	if(mAvatarVelocity != velocity)
-	{
-		mAvatarVelocity = velocity;
-		mSpatialCoordsDirty = true;
-	}
+    if(mAvatarVelocity != velocity)
+    {
+        mAvatarVelocity = velocity;
+        mSpatialCoordsDirty = true;
+    }
 
     // If the two rotations are not exactly equal test their dot product
     // to get the cos of the angle between them.
     // If it is too small, don't update.
     F32 rot_cos_diff = llabs(dot(mAvatarRot, rot));
     if ((mAvatarRot != rot) && (rot_cos_diff < MINUSCULE_ANGLE_COS))
-	{
-		mAvatarRot = rot;
-		mSpatialCoordsDirty = true;
-	}
+    {
+        mAvatarRot = rot;
+        mSpatialCoordsDirty = true;
+    }
 }
 
 bool LLVivoxVoiceClient::channelFromRegion(LLViewerRegion *region, std::string &name)
 {
-	bool result = false;
+    bool result = false;
 
-	if(region)
-	{
-		name = region->getName();
-	}
+    if(region)
+    {
+        name = region->getName();
+    }
 
-	if(!name.empty())
-		result = true;
+    if(!name.empty())
+        result = true;
 
-	return result;
+    return result;
 }
 
 void LLVivoxVoiceClient::leaveChannel(void)
 {
     if (mIsInChannel)
-	{
-		LL_DEBUGS("Voice") << "leaving channel for teleport/logout" << LL_ENDL;
-		mChannelName.clear();
-		sessionTerminate();
-	}
+    {
+        LL_DEBUGS("Voice") << "leaving channel for teleport/logout" << LL_ENDL;
+        mChannelName.clear();
+        sessionTerminate();
+    }
 }
 
 void LLVivoxVoiceClient::setMuteMic(bool muted)
 {
-	if(mMuteMic != muted)
-	{
-		mMuteMic = muted;
-		mMuteMicDirty = true;
-	}
+    if(mMuteMic != muted)
+    {
+        mMuteMic = muted;
+        mMuteMicDirty = true;
+    }
 }
 
 void LLVivoxVoiceClient::setVoiceEnabled(bool enabled)
@@ -5449,18 +5449,18 @@ void LLVivoxVoiceClient::setVoiceEnabled(bool enabled)
         << " coro "<< (mIsCoroutineActive ? "active" : "inactive")
         << LL_ENDL;
 
-	if (enabled != mVoiceEnabled)
-	{
-		// TODO: Refactor this so we don't call into LLVoiceChannel, but simply
-		// use the status observer
-		mVoiceEnabled = enabled;
-		LLVoiceClientStatusObserver::EStatusType status;
+    if (enabled != mVoiceEnabled)
+    {
+        // TODO: Refactor this so we don't call into LLVoiceChannel, but simply
+        // use the status observer
+        mVoiceEnabled = enabled;
+        LLVoiceClientStatusObserver::EStatusType status;
 
-		if (enabled)
-		{
+        if (enabled)
+        {
             LL_DEBUGS("Voice") << "enabling" << LL_ENDL;
-			LLVoiceChannel::getCurrentVoiceChannel()->activate();
-			status = LLVoiceClientStatusObserver::STATUS_VOICE_ENABLED;
+            LLVoiceChannel::getCurrentVoiceChannel()->activate();
+            status = LLVoiceClientStatusObserver::STATUS_VOICE_ENABLED;
 
             if (!mIsCoroutineActive)
             {
@@ -5471,19 +5471,19 @@ void LLVivoxVoiceClient::setVoiceEnabled(bool enabled)
             {
                 LL_DEBUGS("Voice") << "coro should be active.. not launching" << LL_ENDL;
             }
-		}
-		else
-		{
-			// Turning voice off looses your current channel -- this makes sure the UI isn't out of sync when you re-enable it.
-			LLVoiceChannel::getCurrentVoiceChannel()->deactivate();
-			gAgent.setVoiceConnected(false);
-			status = LLVoiceClientStatusObserver::STATUS_VOICE_DISABLED;
-			mCurrentParcelLocalID = -1;
-			mCurrentRegionName.clear();
-		}
-
-		notifyStatusObservers(status);
-	}
+        }
+        else
+        {
+            // Turning voice off looses your current channel -- this makes sure the UI isn't out of sync when you re-enable it.
+            LLVoiceChannel::getCurrentVoiceChannel()->deactivate();
+            gAgent.setVoiceConnected(false);
+            status = LLVoiceClientStatusObserver::STATUS_VOICE_DISABLED;
+            mCurrentParcelLocalID = -1;
+            mCurrentRegionName.clear();
+        }
+
+        notifyStatusObservers(status);
+    }
     else
     {
         LL_DEBUGS("Voice") << " no-op" << LL_ENDL;
@@ -5493,41 +5493,41 @@ void LLVivoxVoiceClient::setVoiceEnabled(bool enabled)
 
 void LLVivoxVoiceClient::setEarLocation(S32 loc)
 {
-	if(mEarLocation != loc)
-	{
-		LL_DEBUGS("Voice") << "Setting mEarLocation to " << loc << LL_ENDL;
+    if(mEarLocation != loc)
+    {
+        LL_DEBUGS("Voice") << "Setting mEarLocation to " << loc << LL_ENDL;
 
-		mEarLocation = loc;
-		mSpatialCoordsDirty = true;
-	}
+        mEarLocation = loc;
+        mSpatialCoordsDirty = true;
+    }
 }
 
 void LLVivoxVoiceClient::setVoiceVolume(F32 volume)
 {
-	int scaled_volume = scale_speaker_volume(volume);
+    int scaled_volume = scale_speaker_volume(volume);
 
-	if(scaled_volume != mSpeakerVolume)
-	{
-	  int min_volume = scale_speaker_volume(0);
-		if((scaled_volume == min_volume) || (mSpeakerVolume == min_volume))
-		{
-			mSpeakerMuteDirty = true;
-		}
+    if(scaled_volume != mSpeakerVolume)
+    {
+      int min_volume = scale_speaker_volume(0);
+        if((scaled_volume == min_volume) || (mSpeakerVolume == min_volume))
+        {
+            mSpeakerMuteDirty = true;
+        }
 
-		mSpeakerVolume = scaled_volume;
-		mSpeakerVolumeDirty = true;
-	}
+        mSpeakerVolume = scaled_volume;
+        mSpeakerVolumeDirty = true;
+    }
 }
 
 void LLVivoxVoiceClient::setMicGain(F32 volume)
 {
-	int scaled_volume = scale_mic_volume(volume);
+    int scaled_volume = scale_mic_volume(volume);
 
-	if(scaled_volume != mMicVolume)
-	{
-		mMicVolume = scaled_volume;
-		mMicVolumeDirty = true;
-	}
+    if(scaled_volume != mMicVolume)
+    {
+        mMicVolume = scaled_volume;
+        mMicVolumeDirty = true;
+    }
 }
 
 /////////////////////////////
@@ -5535,7 +5535,7 @@ void LLVivoxVoiceClient::setMicGain(F32 volume)
 
 std::string LLVivoxVoiceClient::getDisplayName(const LLUUID& id)
 {
-	std::string result;
+    std::string result;
     if (mProcessChannels)
     {
         participantStatePtr_t participant(findParticipantByID(id));
@@ -5545,14 +5545,14 @@ std::string LLVivoxVoiceClient::getDisplayName(const LLUUID& id)
         }
     }
 
-	return result;
+    return result;
 }
 
 
 
 BOOL LLVivoxVoiceClient::getIsSpeaking(const LLUUID& id)
 {
-	BOOL result = FALSE;
+    BOOL result = FALSE;
     if (mProcessChannels)
     {
         participantStatePtr_t participant(findParticipantByID(id));
@@ -5566,52 +5566,52 @@ BOOL LLVivoxVoiceClient::getIsSpeaking(const LLUUID& id)
         }
     }
 
-	return result;
+    return result;
 }
 
 BOOL LLVivoxVoiceClient::getIsModeratorMuted(const LLUUID& id)
 {
-	BOOL result = FALSE;
-	if (!mProcessChannels)
-	{
+    BOOL result = FALSE;
+    if (!mProcessChannels)
+    {
         return FALSE;
-	}
+    }
     participantStatePtr_t participant(findParticipantByID(id));
-	if(participant)
-	{
-		result = participant->mIsModeratorMuted;
-	}
+    if(participant)
+    {
+        result = participant->mIsModeratorMuted;
+    }
 
-	return result;
+    return result;
 }
 
 F32 LLVivoxVoiceClient::getCurrentPower(const LLUUID& id)
 {
-	F32 result = 0;
+    F32 result = 0;
     participantStatePtr_t participant(findParticipantByID(id));
-	if(participant)
-	{
-		result = participant->mPower;
-	}
+    if(participant)
+    {
+        result = participant->mPower;
+    }
 
-	return result;
+    return result;
 }
 
 
 
 BOOL LLVivoxVoiceClient::getUsingPTT(const LLUUID& id)
 {
-	BOOL result = FALSE;
+    BOOL result = FALSE;
 
     participantStatePtr_t participant(findParticipantByID(id));
-	if(participant)
-	{
-		// I'm not sure what the semantics of this should be.
-		// Does "using PTT" mean they're configured with a push-to-talk button?
-		// For now, we know there's no PTT mechanism in place, so nobody is using it.
-	}
+    if(participant)
+    {
+        // I'm not sure what the semantics of this should be.
+        // Does "using PTT" mean they're configured with a push-to-talk button?
+        // For now, we know there's no PTT mechanism in place, so nobody is using it.
+    }
 
-	return result;
+    return result;
 }
 
 // External accessors.
@@ -5622,155 +5622,155 @@ F32 LLVivoxVoiceClient::getUserVolume(const LLUUID& id)
 
     participantStatePtr_t participant(findParticipantByID(id));
     if(participant)
-	{
-		result = participant->mVolume;
+    {
+        result = participant->mVolume;
 
-		// Enable this when debugging voice slider issues.  It's way to spammy even for debug-level logging.
-		// LL_DEBUGS("Voice") << "mVolume = " << result <<  " for " << id << LL_ENDL;
-	}
+        // Enable this when debugging voice slider issues.  It's way to spammy even for debug-level logging.
+        // LL_DEBUGS("Voice") << "mVolume = " << result <<  " for " << id << LL_ENDL;
+    }
 
-	return result;
+    return result;
 }
 
 void LLVivoxVoiceClient::setUserVolume(const LLUUID& id, F32 volume)
 {
-	if(mAudioSession)
-	{
+    if(mAudioSession)
+    {
         participantStatePtr_t participant(findParticipantByID(id));
-		if (participant && !participant->mIsSelf)
-		{
-			if (!is_approx_equal(volume, LLVoiceClient::VOLUME_DEFAULT))
-			{
-				// Store this volume setting for future sessions if it has been
-				// changed from the default
-				LLSpeakerVolumeStorage::getInstance()->storeSpeakerVolume(id, volume);
-			}
-			else
-			{
-				// Remove stored volume setting if it is returned to the default
-				LLSpeakerVolumeStorage::getInstance()->removeSpeakerVolume(id);
-			}
-
-			participant->mVolume = llclamp(volume, LLVoiceClient::VOLUME_MIN, LLVoiceClient::VOLUME_MAX);
-			participant->mVolumeDirty = true;
-			mAudioSession->mVolumeDirty = true;
-		}
-	}
+        if (participant && !participant->mIsSelf)
+        {
+            if (!is_approx_equal(volume, LLVoiceClient::VOLUME_DEFAULT))
+            {
+                // Store this volume setting for future sessions if it has been
+                // changed from the default
+                LLSpeakerVolumeStorage::getInstance()->storeSpeakerVolume(id, volume);
+            }
+            else
+            {
+                // Remove stored volume setting if it is returned to the default
+                LLSpeakerVolumeStorage::getInstance()->removeSpeakerVolume(id);
+            }
+
+            participant->mVolume = llclamp(volume, LLVoiceClient::VOLUME_MIN, LLVoiceClient::VOLUME_MAX);
+            participant->mVolumeDirty = true;
+            mAudioSession->mVolumeDirty = true;
+        }
+    }
 }
 
 std::string LLVivoxVoiceClient::getGroupID(const LLUUID& id)
 {
-	std::string result;
+    std::string result;
 
     participantStatePtr_t participant(findParticipantByID(id));
-	if(participant)
-	{
-		result = participant->mGroupID;
-	}
+    if(participant)
+    {
+        result = participant->mGroupID;
+    }
 
-	return result;
+    return result;
 }
 
 void LLVivoxVoiceClient::recordingLoopStart(int seconds, int deltaFramesPerControlFrame)
 {
-//	LL_DEBUGS("Voice") << "sending SessionGroup.ControlRecording (Start)" << LL_ENDL;
+//  LL_DEBUGS("Voice") << "sending SessionGroup.ControlRecording (Start)" << LL_ENDL;
 
-	if(!mMainSessionGroupHandle.empty())
-	{
-		std::ostringstream stream;
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlRecording.1\">"
-		<< "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
-		<< "<RecordingControlType>Start</RecordingControlType>"
-		<< "<DeltaFramesPerControlFrame>" << deltaFramesPerControlFrame << "</DeltaFramesPerControlFrame>"
-		<< "<Filename>" << "" << "</Filename>"
-		<< "<EnableAudioRecordingEvents>false</EnableAudioRecordingEvents>"
-		<< "<LoopModeDurationSeconds>" << seconds << "</LoopModeDurationSeconds>"
-		<< "</Request>\n\n\n";
+    if(!mMainSessionGroupHandle.empty())
+    {
+        std::ostringstream stream;
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlRecording.1\">"
+        << "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
+        << "<RecordingControlType>Start</RecordingControlType>"
+        << "<DeltaFramesPerControlFrame>" << deltaFramesPerControlFrame << "</DeltaFramesPerControlFrame>"
+        << "<Filename>" << "" << "</Filename>"
+        << "<EnableAudioRecordingEvents>false</EnableAudioRecordingEvents>"
+        << "<LoopModeDurationSeconds>" << seconds << "</LoopModeDurationSeconds>"
+        << "</Request>\n\n\n";
 
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::recordingLoopSave(const std::string& filename)
 {
-//	LL_DEBUGS("Voice") << "sending SessionGroup.ControlRecording (Flush)" << LL_ENDL;
+//  LL_DEBUGS("Voice") << "sending SessionGroup.ControlRecording (Flush)" << LL_ENDL;
 
-	if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
-	{
-		std::ostringstream stream;
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlRecording.1\">"
-		<< "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
-		<< "<RecordingControlType>Flush</RecordingControlType>"
-		<< "<Filename>" << filename << "</Filename>"
-		<< "</Request>\n\n\n";
+    if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
+    {
+        std::ostringstream stream;
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlRecording.1\">"
+        << "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
+        << "<RecordingControlType>Flush</RecordingControlType>"
+        << "<Filename>" << filename << "</Filename>"
+        << "</Request>\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::recordingStop()
 {
-//	LL_DEBUGS("Voice") << "sending SessionGroup.ControlRecording (Stop)" << LL_ENDL;
+//  LL_DEBUGS("Voice") << "sending SessionGroup.ControlRecording (Stop)" << LL_ENDL;
 
-	if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
-	{
-		std::ostringstream stream;
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlRecording.1\">"
-		<< "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
-		<< "<RecordingControlType>Stop</RecordingControlType>"
-		<< "</Request>\n\n\n";
+    if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
+    {
+        std::ostringstream stream;
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlRecording.1\">"
+        << "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
+        << "<RecordingControlType>Stop</RecordingControlType>"
+        << "</Request>\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::filePlaybackStart(const std::string& filename)
 {
-//	LL_DEBUGS("Voice") << "sending SessionGroup.ControlPlayback (Start)" << LL_ENDL;
+//  LL_DEBUGS("Voice") << "sending SessionGroup.ControlPlayback (Start)" << LL_ENDL;
 
-	if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
-	{
-		std::ostringstream stream;
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlPlayback.1\">"
-		<< "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
-		<< "<RecordingControlType>Start</RecordingControlType>"
-		<< "<Filename>" << filename << "</Filename>"
-		<< "</Request>\n\n\n";
+    if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
+    {
+        std::ostringstream stream;
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlPlayback.1\">"
+        << "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
+        << "<RecordingControlType>Start</RecordingControlType>"
+        << "<Filename>" << filename << "</Filename>"
+        << "</Request>\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::filePlaybackStop()
 {
-//	LL_DEBUGS("Voice") << "sending SessionGroup.ControlPlayback (Stop)" << LL_ENDL;
+//  LL_DEBUGS("Voice") << "sending SessionGroup.ControlPlayback (Stop)" << LL_ENDL;
 
-	if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
-	{
-		std::ostringstream stream;
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlPlayback.1\">"
-		<< "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
-		<< "<RecordingControlType>Stop</RecordingControlType>"
-		<< "</Request>\n\n\n";
+    if(mAudioSession != NULL && !mAudioSession->mGroupHandle.empty())
+    {
+        std::ostringstream stream;
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"SessionGroup.ControlPlayback.1\">"
+        << "<SessionGroupHandle>" << mMainSessionGroupHandle << "</SessionGroupHandle>"
+        << "<RecordingControlType>Stop</RecordingControlType>"
+        << "</Request>\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::filePlaybackSetPaused(bool paused)
 {
-	// TODO: Implement once Vivox gives me a sample
+    // TODO: Implement once Vivox gives me a sample
 }
 
 void LLVivoxVoiceClient::filePlaybackSetMode(bool vox, float speed)
 {
-	// TODO: Implement once Vivox gives me a sample
+    // TODO: Implement once Vivox gives me a sample
 }
 
 //------------------------------------------------------------------------
@@ -5828,21 +5828,21 @@ LLVivoxVoiceClient::sessionState::~sessionState()
     if (mMyIterator != mSession.end())
         mSession.erase(mMyIterator);
 
-	removeAllParticipants();
+    removeAllParticipants();
 }
 
 bool LLVivoxVoiceClient::sessionState::isCallBackPossible()
 {
-	// This may change to be explicitly specified by vivox in the future...
-	// Currently, only PSTN P2P calls cannot be returned.
-	// Conveniently, this is also the only case where we synthesize a caller UUID.
-	return !mSynthesizedCallerID;
+    // This may change to be explicitly specified by vivox in the future...
+    // Currently, only PSTN P2P calls cannot be returned.
+    // Conveniently, this is also the only case where we synthesize a caller UUID.
+    return !mSynthesizedCallerID;
 }
 
 bool LLVivoxVoiceClient::sessionState::isTextIMPossible()
 {
-	// This may change to be explicitly specified by vivox in the future...
-	return !mSynthesizedCallerID;
+    // This may change to be explicitly specified by vivox in the future...
+    return !mSynthesizedCallerID;
 }
 
 
@@ -5956,104 +5956,104 @@ void LLVivoxVoiceClient::sessionState::for_eachPredicate(const LLVivoxVoiceClien
 LLVivoxVoiceClient::sessionStatePtr_t LLVivoxVoiceClient::findSession(const std::string &handle)
 {
     sessionStatePtr_t result;
-	sessionMap::iterator iter = mSessionsByHandle.find(handle);
-	if(iter != mSessionsByHandle.end())
-	{
-		result = iter->second;
-	}
+    sessionMap::iterator iter = mSessionsByHandle.find(handle);
+    if(iter != mSessionsByHandle.end())
+    {
+        result = iter->second;
+    }
 
-	return result;
+    return result;
 }
 
 LLVivoxVoiceClient::sessionStatePtr_t LLVivoxVoiceClient::findSessionBeingCreatedByURI(const std::string &uri)
 {
     sessionStatePtr_t result = sessionState::matchCreatingSessionByURI(uri);
 
-	return result;
+    return result;
 }
 
 LLVivoxVoiceClient::sessionStatePtr_t LLVivoxVoiceClient::findSession(const LLUUID &participant_id)
 {
     sessionStatePtr_t result = sessionState::matchSessionByParticipant(participant_id);
 
-	return result;
+    return result;
 }
 
 LLVivoxVoiceClient::sessionStatePtr_t LLVivoxVoiceClient::addSession(const std::string &uri, const std::string &handle)
 {
     sessionStatePtr_t result;
 
-	if(handle.empty())
-	{
+    if(handle.empty())
+    {
         // No handle supplied.
         // Check whether there's already a session with this URI
         result = sessionState::matchSessionByURI(uri);
-	}
-	else // (!handle.empty())
-	{
-		// Check for an existing session with this handle
-		sessionMap::iterator iter = mSessionsByHandle.find(handle);
-
-		if(iter != mSessionsByHandle.end())
-		{
-			result = iter->second;
-		}
-	}
-
-	if(!result)
-	{
-		// No existing session found.
-
-		LL_DEBUGS("Voice") << "adding new session: handle \"" << handle << "\" URI " << uri << LL_ENDL;
+    }
+    else // (!handle.empty())
+    {
+        // Check for an existing session with this handle
+        sessionMap::iterator iter = mSessionsByHandle.find(handle);
+
+        if(iter != mSessionsByHandle.end())
+        {
+            result = iter->second;
+        }
+    }
+
+    if(!result)
+    {
+        // No existing session found.
+
+        LL_DEBUGS("Voice") << "adding new session: handle \"" << handle << "\" URI " << uri << LL_ENDL;
         result = sessionState::createSession();
-		result->mSIPURI = uri;
-		result->mHandle = handle;
+        result->mSIPURI = uri;
+        result->mHandle = handle;
 
-		if (LLVoiceClient::instance().getVoiceEffectEnabled())
-		{
-			result->mVoiceFontID = LLVoiceClient::instance().getVoiceEffectDefault();
-		}
+        if (LLVoiceClient::instance().getVoiceEffectEnabled())
+        {
+            result->mVoiceFontID = LLVoiceClient::instance().getVoiceEffectDefault();
+        }
 
-		if(!result->mHandle.empty())
-		{
+        if(!result->mHandle.empty())
+        {
             // *TODO: Rider: This concerns me.  There is a path (via switchChannel) where
             // we do not track the session.  In theory this means that we could end up with
             // a mAuidoSession that does not match the session tracked in mSessionsByHandle
-			mSessionsByHandle.insert(sessionMap::value_type(result->mHandle, result));
-		}
-	}
-	else
-	{
-		// Found an existing session
-
-		if(uri != result->mSIPURI)
-		{
-			// TODO: Should this be an internal error?
-			LL_DEBUGS("Voice") << "changing uri from " << result->mSIPURI << " to " << uri << LL_ENDL;
-			setSessionURI(result, uri);
-		}
-
-		if(handle != result->mHandle)
-		{
-			if(handle.empty())
-			{
-				// There's at least one race condition where where addSession was clearing an existing session handle, which caused things to break.
-				LL_DEBUGS("Voice") << "NOT clearing handle " << result->mHandle << LL_ENDL;
-			}
-			else
-			{
-				// TODO: Should this be an internal error?
-				LL_DEBUGS("Voice") << "changing handle from " << result->mHandle << " to " << handle << LL_ENDL;
-				setSessionHandle(result, handle);
-			}
-		}
-
-		LL_DEBUGS("Voice") << "returning existing session: handle " << handle << " URI " << uri << LL_ENDL;
-	}
-
-	verifySessionState();
-
-	return result;
+            mSessionsByHandle.insert(sessionMap::value_type(result->mHandle, result));
+        }
+    }
+    else
+    {
+        // Found an existing session
+
+        if(uri != result->mSIPURI)
+        {
+            // TODO: Should this be an internal error?
+            LL_DEBUGS("Voice") << "changing uri from " << result->mSIPURI << " to " << uri << LL_ENDL;
+            setSessionURI(result, uri);
+        }
+
+        if(handle != result->mHandle)
+        {
+            if(handle.empty())
+            {
+                // There's at least one race condition where where addSession was clearing an existing session handle, which caused things to break.
+                LL_DEBUGS("Voice") << "NOT clearing handle " << result->mHandle << LL_ENDL;
+            }
+            else
+            {
+                // TODO: Should this be an internal error?
+                LL_DEBUGS("Voice") << "changing handle from " << result->mHandle << " to " << handle << LL_ENDL;
+                setSessionHandle(result, handle);
+            }
+        }
+
+        LL_DEBUGS("Voice") << "returning existing session: handle " << handle << " URI " << uri << LL_ENDL;
+    }
+
+    verifySessionState();
+
+    return result;
 }
 
 void LLVivoxVoiceClient::clearSessionHandle(const sessionStatePtr_t &session)
@@ -6082,88 +6082,88 @@ void LLVivoxVoiceClient::clearSessionHandle(const sessionStatePtr_t &session)
 
 void LLVivoxVoiceClient::setSessionHandle(const sessionStatePtr_t &session, const std::string &handle)
 {
-	// Have to remove the session from the handle-indexed map before changing the handle, or things will break badly.
-
-	if(!session->mHandle.empty())
-	{
-		// Remove session from the map if it should have been there.
-		sessionMap::iterator iter = mSessionsByHandle.find(session->mHandle);
-		if(iter != mSessionsByHandle.end())
-		{
-			if(iter->second != session)
-			{
-				LL_WARNS("Voice") << "Internal error: session mismatch! Session may have been duplicated. Removing version in map." << LL_ENDL;
-			}
-
-			mSessionsByHandle.erase(iter);
-		}
-		else
-		{
+    // Have to remove the session from the handle-indexed map before changing the handle, or things will break badly.
+
+    if(!session->mHandle.empty())
+    {
+        // Remove session from the map if it should have been there.
+        sessionMap::iterator iter = mSessionsByHandle.find(session->mHandle);
+        if(iter != mSessionsByHandle.end())
+        {
+            if(iter->second != session)
+            {
+                LL_WARNS("Voice") << "Internal error: session mismatch! Session may have been duplicated. Removing version in map." << LL_ENDL;
+            }
+
+            mSessionsByHandle.erase(iter);
+        }
+        else
+        {
             LL_WARNS("Voice") << "Attempt to remove session with handle " << session->mHandle << " not found in map!" << LL_ENDL;
-		}
-	}
+        }
+    }
 
-	session->mHandle = handle;
+    session->mHandle = handle;
 
-	if(!handle.empty())
-	{
-		mSessionsByHandle.insert(sessionMap::value_type(session->mHandle, session));
-	}
+    if(!handle.empty())
+    {
+        mSessionsByHandle.insert(sessionMap::value_type(session->mHandle, session));
+    }
 
-	verifySessionState();
+    verifySessionState();
 }
 
 void LLVivoxVoiceClient::setSessionURI(const sessionStatePtr_t &session, const std::string &uri)
 {
-	// There used to be a map of session URIs to sessions, which made this complex....
-	session->mSIPURI = uri;
+    // There used to be a map of session URIs to sessions, which made this complex....
+    session->mSIPURI = uri;
 
-	verifySessionState();
+    verifySessionState();
 }
 
 void LLVivoxVoiceClient::deleteSession(const sessionStatePtr_t &session)
 {
-	// Remove the session from the handle map
-	if(!session->mHandle.empty())
-	{
-		sessionMap::iterator iter = mSessionsByHandle.find(session->mHandle);
-		if(iter != mSessionsByHandle.end())
-		{
-			if(iter->second != session)
-			{
-				LL_WARNS("Voice") << "Internal error: session mismatch, removing session in map." << LL_ENDL;
-			}
-			mSessionsByHandle.erase(iter);
-		}
-	}
-
-	// At this point, the session should be unhooked from all lists and all state should be consistent.
-	verifySessionState();
-
-	// If this is the current audio session, clean up the pointer which will soon be dangling.
-	if(mAudioSession == session)
-	{
-		mAudioSession.reset();
-		mAudioSessionChanged = true;
-	}
-
-	// ditto for the next audio session
-	if(mNextAudioSession == session)
-	{
-		mNextAudioSession.reset();
-	}
+    // Remove the session from the handle map
+    if(!session->mHandle.empty())
+    {
+        sessionMap::iterator iter = mSessionsByHandle.find(session->mHandle);
+        if(iter != mSessionsByHandle.end())
+        {
+            if(iter->second != session)
+            {
+                LL_WARNS("Voice") << "Internal error: session mismatch, removing session in map." << LL_ENDL;
+            }
+            mSessionsByHandle.erase(iter);
+        }
+    }
+
+    // At this point, the session should be unhooked from all lists and all state should be consistent.
+    verifySessionState();
+
+    // If this is the current audio session, clean up the pointer which will soon be dangling.
+    if(mAudioSession == session)
+    {
+        mAudioSession.reset();
+        mAudioSessionChanged = true;
+    }
+
+    // ditto for the next audio session
+    if(mNextAudioSession == session)
+    {
+        mNextAudioSession.reset();
+    }
 
 }
 
 void LLVivoxVoiceClient::deleteAllSessions()
 {
-	LL_DEBUGS("Voice") << LL_ENDL;
+    LL_DEBUGS("Voice") << LL_ENDL;
 
     while (!mSessionsByHandle.empty())
-	{
+    {
         const sessionStatePtr_t session = mSessionsByHandle.begin()->second;
         deleteSession(session);
-	}
+    }
 
 }
 
@@ -6175,35 +6175,35 @@ void LLVivoxVoiceClient::verifySessionState(void)
 
 void LLVivoxVoiceClient::addObserver(LLVoiceClientParticipantObserver* observer)
 {
-	mParticipantObservers.insert(observer);
+    mParticipantObservers.insert(observer);
 }
 
 void LLVivoxVoiceClient::removeObserver(LLVoiceClientParticipantObserver* observer)
 {
-	mParticipantObservers.erase(observer);
+    mParticipantObservers.erase(observer);
 }
 
 void LLVivoxVoiceClient::notifyParticipantObservers()
 {
-	for (observer_set_t::iterator it = mParticipantObservers.begin();
-		it != mParticipantObservers.end();
-		)
-	{
-		LLVoiceClientParticipantObserver* observer = *it;
-		observer->onParticipantsChanged();
-		// In case onParticipantsChanged() deleted an entry.
-		it = mParticipantObservers.upper_bound(observer);
-	}
+    for (observer_set_t::iterator it = mParticipantObservers.begin();
+        it != mParticipantObservers.end();
+        )
+    {
+        LLVoiceClientParticipantObserver* observer = *it;
+        observer->onParticipantsChanged();
+        // In case onParticipantsChanged() deleted an entry.
+        it = mParticipantObservers.upper_bound(observer);
+    }
 }
 
 void LLVivoxVoiceClient::addObserver(LLVoiceClientStatusObserver* observer)
 {
-	mStatusObservers.insert(observer);
+    mStatusObservers.insert(observer);
 }
 
 void LLVivoxVoiceClient::removeObserver(LLVoiceClientStatusObserver* observer)
 {
-	mStatusObservers.erase(observer);
+    mStatusObservers.erase(observer);
 }
 
 void LLVivoxVoiceClient::notifyStatusObservers(LLVoiceClientStatusObserver::EStatusType status)
@@ -6212,124 +6212,124 @@ void LLVivoxVoiceClient::notifyStatusObservers(LLVoiceClientStatusObserver::ESta
                        << " mAudioSession=" << mAudioSession
                        << LL_ENDL;
 
-	if(mAudioSession)
-	{
-		if(status == LLVoiceClientStatusObserver::ERROR_UNKNOWN)
-		{
-			switch(mAudioSession->mErrorStatusCode)
-			{
-				case 20713:		status = LLVoiceClientStatusObserver::ERROR_CHANNEL_FULL; 		break;
-				case 20714:		status = LLVoiceClientStatusObserver::ERROR_CHANNEL_LOCKED; 	break;
-				case 20715:
-					//invalid channel, we may be using a set of poorly cached
-					//info
-					status = LLVoiceClientStatusObserver::ERROR_NOT_AVAILABLE;
-					break;
-				case 1009:
-					//invalid username and password
-					status = LLVoiceClientStatusObserver::ERROR_NOT_AVAILABLE;
-					break;
-			}
-
-			// Reset the error code to make sure it won't be reused later by accident.
-			mAudioSession->mErrorStatusCode = 0;
-		}
-		else if(status == LLVoiceClientStatusObserver::STATUS_LEFT_CHANNEL)
-		{
-			switch(mAudioSession->mErrorStatusCode)
-			{
-				case HTTP_NOT_FOUND:	// NOT_FOUND
-				// *TODO: Should this be 503?
-				case 480:	// TEMPORARILY_UNAVAILABLE
-				case HTTP_REQUEST_TIME_OUT:	// REQUEST_TIMEOUT
-					// call failed because other user was not available
-					// treat this as an error case
-					status = LLVoiceClientStatusObserver::ERROR_NOT_AVAILABLE;
-
-					// Reset the error code to make sure it won't be reused later by accident.
-					mAudioSession->mErrorStatusCode = 0;
-				break;
-			}
-		}
-	}
-
-	LL_DEBUGS("Voice")
-		<< " " << LLVoiceClientStatusObserver::status2string(status)
-		<< ", session channelInfo " << getAudioSessionChannelInfo()
-		<< ", proximal is " << inSpatialChannel()
+    if(mAudioSession)
+    {
+        if(status == LLVoiceClientStatusObserver::ERROR_UNKNOWN)
+        {
+            switch(mAudioSession->mErrorStatusCode)
+            {
+                case 20713:     status = LLVoiceClientStatusObserver::ERROR_CHANNEL_FULL;       break;
+                case 20714:     status = LLVoiceClientStatusObserver::ERROR_CHANNEL_LOCKED;     break;
+                case 20715:
+                    //invalid channel, we may be using a set of poorly cached
+                    //info
+                    status = LLVoiceClientStatusObserver::ERROR_NOT_AVAILABLE;
+                    break;
+                case 1009:
+                    //invalid username and password
+                    status = LLVoiceClientStatusObserver::ERROR_NOT_AVAILABLE;
+                    break;
+            }
+
+            // Reset the error code to make sure it won't be reused later by accident.
+            mAudioSession->mErrorStatusCode = 0;
+        }
+        else if(status == LLVoiceClientStatusObserver::STATUS_LEFT_CHANNEL)
+        {
+            switch(mAudioSession->mErrorStatusCode)
+            {
+                case HTTP_NOT_FOUND:    // NOT_FOUND
+                // *TODO: Should this be 503?
+                case 480:   // TEMPORARILY_UNAVAILABLE
+                case HTTP_REQUEST_TIME_OUT: // REQUEST_TIMEOUT
+                    // call failed because other user was not available
+                    // treat this as an error case
+                    status = LLVoiceClientStatusObserver::ERROR_NOT_AVAILABLE;
+
+                    // Reset the error code to make sure it won't be reused later by accident.
+                    mAudioSession->mErrorStatusCode = 0;
+                break;
+            }
+        }
+    }
+
+    LL_DEBUGS("Voice")
+        << " " << LLVoiceClientStatusObserver::status2string(status)
+        << ", session channelInfo " << getAudioSessionChannelInfo()
+        << ", proximal is " << inSpatialChannel()
         << LL_ENDL;
 
-	if (!mProcessChannels)
-	{
-		// we're not processing...another voice module is.
-		// so nobody wants to hear from us.
+    if (!mProcessChannels)
+    {
+        // we're not processing...another voice module is.
+        // so nobody wants to hear from us.
         return;
-	}
-	for (status_observer_set_t::iterator it = mStatusObservers.begin();
-		it != mStatusObservers.end();
-		)
-	{
-		LLVoiceClientStatusObserver* observer = *it;
+    }
+    for (status_observer_set_t::iterator it = mStatusObservers.begin();
+        it != mStatusObservers.end();
+        )
+    {
+        LLVoiceClientStatusObserver* observer = *it;
         observer->onChange(status, getAudioSessionChannelInfo(), inSpatialChannel());
-		// In case onError() deleted an entry.
-		it = mStatusObservers.upper_bound(observer);
-	}
+        // In case onError() deleted an entry.
+        it = mStatusObservers.upper_bound(observer);
+    }
 
-	// skipped to avoid speak button blinking
-	if (   status != LLVoiceClientStatusObserver::STATUS_JOINING
-		&& status != LLVoiceClientStatusObserver::STATUS_LEFT_CHANNEL
-		&& status != LLVoiceClientStatusObserver::STATUS_VOICE_DISABLED)
-	{
-		bool voice_status = LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();
+    // skipped to avoid speak button blinking
+    if (   status != LLVoiceClientStatusObserver::STATUS_JOINING
+        && status != LLVoiceClientStatusObserver::STATUS_LEFT_CHANNEL
+        && status != LLVoiceClientStatusObserver::STATUS_VOICE_DISABLED)
+    {
+        bool voice_status = LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();
 
-		LL_WARNS("Voice") << "Setting voice connected " << (voice_status ? "True" : "False") << LL_ENDL;
-		gAgent.setVoiceConnected(voice_status);
+        LL_WARNS("Voice") << "Setting voice connected " << (voice_status ? "True" : "False") << LL_ENDL;
+        gAgent.setVoiceConnected(voice_status);
 
-		if (voice_status)
-		{
-			LLFirstUse::speak(true);
-		}
-	}
+        if (voice_status)
+        {
+            LLFirstUse::speak(true);
+        }
+    }
 }
 
 void LLVivoxVoiceClient::addObserver(LLFriendObserver* observer)
 {
-	mFriendObservers.insert(observer);
+    mFriendObservers.insert(observer);
 }
 
 void LLVivoxVoiceClient::removeObserver(LLFriendObserver* observer)
 {
-	mFriendObservers.erase(observer);
+    mFriendObservers.erase(observer);
 }
 
 void LLVivoxVoiceClient::notifyFriendObservers()
 {
-	for (friend_observer_set_t::iterator it = mFriendObservers.begin();
-		it != mFriendObservers.end();
-		)
-	{
-		LLFriendObserver* observer = *it;
-		it++;
-		// The only friend-related thing we notify on is online/offline transitions.
-		observer->changed(LLFriendObserver::ONLINE);
-	}
+    for (friend_observer_set_t::iterator it = mFriendObservers.begin();
+        it != mFriendObservers.end();
+        )
+    {
+        LLFriendObserver* observer = *it;
+        it++;
+        // The only friend-related thing we notify on is online/offline transitions.
+        observer->changed(LLFriendObserver::ONLINE);
+    }
 }
 
 void LLVivoxVoiceClient::lookupName(const LLUUID &id)
 {
-	if (mAvatarNameCacheConnection.connected())
-	{
-		mAvatarNameCacheConnection.disconnect();
-	}
-	mAvatarNameCacheConnection = LLAvatarNameCache::get(id, boost::bind(&LLVivoxVoiceClient::onAvatarNameCache, this, _1, _2));
+    if (mAvatarNameCacheConnection.connected())
+    {
+        mAvatarNameCacheConnection.disconnect();
+    }
+    mAvatarNameCacheConnection = LLAvatarNameCache::get(id, boost::bind(&LLVivoxVoiceClient::onAvatarNameCache, this, _1, _2));
 }
 
 void LLVivoxVoiceClient::onAvatarNameCache(const LLUUID& agent_id,
-										   const LLAvatarName& av_name)
+                                           const LLAvatarName& av_name)
 {
-	mAvatarNameCacheConnection.disconnect();
-	std::string display_name = av_name.getDisplayName();
-	avatarNameResolved(agent_id, display_name);
+    mAvatarNameCacheConnection.disconnect();
+    std::string display_name = av_name.getDisplayName();
+    avatarNameResolved(agent_id, display_name);
 }
 
 void LLVivoxVoiceClient::predAvatarNameResolution(const LLVivoxVoiceClient::sessionStatePtr_t &session, LLUUID id, std::string name)
@@ -6376,80 +6376,80 @@ void LLVivoxVoiceClient::avatarNameResolved(const LLUUID &id, const std::string
 
 bool LLVivoxVoiceClient::setVoiceEffect(const LLUUID& id)
 {
-	if (!mAudioSession)
-	{
-		return false;
-	}
+    if (!mAudioSession)
+    {
+        return false;
+    }
 
-	if (!id.isNull())
-	{
-		if (mVoiceFontMap.empty())
-		{
-			LL_DEBUGS("Voice") << "Voice fonts not available." << LL_ENDL;
-			return false;
-		}
-		else if (mVoiceFontMap.find(id) == mVoiceFontMap.end())
-		{
-			LL_DEBUGS("Voice") << "Invalid voice font " << id << LL_ENDL;
-			return false;
-		}
-	}
+    if (!id.isNull())
+    {
+        if (mVoiceFontMap.empty())
+        {
+            LL_DEBUGS("Voice") << "Voice fonts not available." << LL_ENDL;
+            return false;
+        }
+        else if (mVoiceFontMap.find(id) == mVoiceFontMap.end())
+        {
+            LL_DEBUGS("Voice") << "Invalid voice font " << id << LL_ENDL;
+            return false;
+        }
+    }
 
-	// *TODO: Check for expired fonts?
-	mAudioSession->mVoiceFontID = id;
+    // *TODO: Check for expired fonts?
+    mAudioSession->mVoiceFontID = id;
 
-	// *TODO: Separate voice font defaults for spatial chat and IM?
-	gSavedPerAccountSettings.setString("VoiceEffectDefault", id.asString());
+    // *TODO: Separate voice font defaults for spatial chat and IM?
+    gSavedPerAccountSettings.setString("VoiceEffectDefault", id.asString());
 
-	sessionSetVoiceFontSendMessage(mAudioSession);
-	notifyVoiceFontObservers();
+    sessionSetVoiceFontSendMessage(mAudioSession);
+    notifyVoiceFontObservers();
 
-	return true;
+    return true;
 }
 
 const LLUUID LLVivoxVoiceClient::getVoiceEffect()
 {
-	return mAudioSession ? mAudioSession->mVoiceFontID : LLUUID::null;
+    return mAudioSession ? mAudioSession->mVoiceFontID : LLUUID::null;
 }
 
 LLSD LLVivoxVoiceClient::getVoiceEffectProperties(const LLUUID& id)
 {
-	LLSD sd;
-
-	voice_font_map_t::iterator iter = mVoiceFontMap.find(id);
-	if (iter != mVoiceFontMap.end())
-	{
-		sd["template_only"] = false;
-	}
-	else
-	{
-		// Voice effect is not in the voice font map, see if there is a template
-		iter = mVoiceFontTemplateMap.find(id);
-		if (iter == mVoiceFontTemplateMap.end())
-		{
-			LL_WARNS("Voice") << "Voice effect " << id << "not found." << LL_ENDL;
-			return sd;
-		}
-		sd["template_only"] = true;
-	}
-
-	voiceFontEntry *font = iter->second;
-	sd["name"] = font->mName;
-	sd["expiry_date"] = font->mExpirationDate;
-	sd["is_new"] = font->mIsNew;
-
-	return sd;
+    LLSD sd;
+
+    voice_font_map_t::iterator iter = mVoiceFontMap.find(id);
+    if (iter != mVoiceFontMap.end())
+    {
+        sd["template_only"] = false;
+    }
+    else
+    {
+        // Voice effect is not in the voice font map, see if there is a template
+        iter = mVoiceFontTemplateMap.find(id);
+        if (iter == mVoiceFontTemplateMap.end())
+        {
+            LL_WARNS("Voice") << "Voice effect " << id << "not found." << LL_ENDL;
+            return sd;
+        }
+        sd["template_only"] = true;
+    }
+
+    voiceFontEntry *font = iter->second;
+    sd["name"] = font->mName;
+    sd["expiry_date"] = font->mExpirationDate;
+    sd["is_new"] = font->mIsNew;
+
+    return sd;
 }
 
 LLVivoxVoiceClient::voiceFontEntry::voiceFontEntry(LLUUID& id) :
-	mID(id),
-	mFontIndex(0),
-	mFontType(VOICE_FONT_TYPE_NONE),
-	mFontStatus(VOICE_FONT_STATUS_NONE),
-	mIsNew(false)
+    mID(id),
+    mFontIndex(0),
+    mFontType(VOICE_FONT_TYPE_NONE),
+    mFontStatus(VOICE_FONT_STATUS_NONE),
+    mIsNew(false)
 {
-	mExpiryTimer.stop();
-	mExpiryWarningTimer.stop();
+    mExpiryTimer.stop();
+    mExpiryWarningTimer.stop();
 }
 
 LLVivoxVoiceClient::voiceFontEntry::~voiceFontEntry()
@@ -6458,369 +6458,369 @@ LLVivoxVoiceClient::voiceFontEntry::~voiceFontEntry()
 
 void LLVivoxVoiceClient::refreshVoiceEffectLists(bool clear_lists)
 {
-	if (clear_lists)
-	{
-		mVoiceFontsReceived = false;
-		deleteAllVoiceFonts();
-		deleteVoiceFontTemplates();
-	}
+    if (clear_lists)
+    {
+        mVoiceFontsReceived = false;
+        deleteAllVoiceFonts();
+        deleteVoiceFontTemplates();
+    }
 
-	accountGetSessionFontsSendMessage();
-	accountGetTemplateFontsSendMessage();
+    accountGetSessionFontsSendMessage();
+    accountGetTemplateFontsSendMessage();
 }
 
 const voice_effect_list_t& LLVivoxVoiceClient::getVoiceEffectList() const
 {
-	return mVoiceFontList;
+    return mVoiceFontList;
 }
 
 const voice_effect_list_t& LLVivoxVoiceClient::getVoiceEffectTemplateList() const
 {
-	return mVoiceFontTemplateList;
+    return mVoiceFontTemplateList;
 }
 
 void LLVivoxVoiceClient::addVoiceFont(const S32 font_index,
-								 const std::string &name,
-								 const std::string &description,
-								 const LLDate &expiration_date,
-								 bool has_expired,
-								 const S32 font_type,
-								 const S32 font_status,
-								 const bool template_font)
-{
-	// Vivox SessionFontIDs are not guaranteed to remain the same between
-	// sessions or grids so use a UUID for the name.
-
-	// If received name is not a UUID, fudge one by hashing the name and type.
-	LLUUID font_id;
-	if (LLUUID::validate(name))
-	{
-		font_id = LLUUID(name);
-	}
-	else
-	{
-		font_id.generate(STRINGIZE(font_type << ":" << name));
-	}
-
-	voiceFontEntry *font = NULL;
-
-	voice_font_map_t& font_map = template_font ? mVoiceFontTemplateMap : mVoiceFontMap;
-	voice_effect_list_t& font_list = template_font ? mVoiceFontTemplateList : mVoiceFontList;
-
-	// Check whether we've seen this font before.
-	voice_font_map_t::iterator iter = font_map.find(font_id);
-	bool new_font = (iter == font_map.end());
-
-	// Override the has_expired flag if we have passed the expiration_date as a double check.
-	if (expiration_date.secondsSinceEpoch() < (LLDate::now().secondsSinceEpoch() + VOICE_FONT_EXPIRY_INTERVAL))
-	{
-		has_expired = true;
-	}
-
-	if (has_expired)
-	{
-		LL_DEBUGS("VoiceFont") << "Expired " << (template_font ? "Template " : "")
-		<< expiration_date.asString() << " " << font_id
-		<< " (" << font_index << ") " << name << LL_ENDL;
-
-		// Remove existing session fonts that have expired since we last saw them.
-		if (!new_font && !template_font)
-		{
-			deleteVoiceFont(font_id);
-		}
-		return;
-	}
-
-	if (new_font)
-	{
-		// If it is a new font create a new entry.
-		font = new voiceFontEntry(font_id);
-	}
-	else
-	{
-		// Not a new font, update the existing entry
-		font = iter->second;
-	}
-
-	if (font)
-	{
-		font->mFontIndex = font_index;
-		// Use the description for the human readable name if available, as the
-		// "name" may be a UUID.
-		font->mName = description.empty() ? name : description;
-		font->mFontType = font_type;
-		font->mFontStatus = font_status;
-
-		// If the font is new or the expiration date has changed the expiry timers need updating.
-		if (!template_font && (new_font || font->mExpirationDate != expiration_date))
-		{
-			font->mExpirationDate = expiration_date;
-
-			// Set the expiry timer to trigger a notification when the voice font can no longer be used.
-			font->mExpiryTimer.start();
-			font->mExpiryTimer.setExpiryAt(expiration_date.secondsSinceEpoch() - VOICE_FONT_EXPIRY_INTERVAL);
-
-			// Set the warning timer to some interval before actual expiry.
-			S32 warning_time = gSavedSettings.getS32("VoiceEffectExpiryWarningTime");
-			if (warning_time != 0)
-			{
-				font->mExpiryWarningTimer.start();
-				F64 expiry_time = (expiration_date.secondsSinceEpoch() - (F64)warning_time);
-				font->mExpiryWarningTimer.setExpiryAt(expiry_time - VOICE_FONT_EXPIRY_INTERVAL);
-			}
-			else
-			{
-				// Disable the warning timer.
-				font->mExpiryWarningTimer.stop();
-			}
-
-			 // Only flag new session fonts after the first time we have fetched the list.
-			if (mVoiceFontsReceived)
-			{
-				font->mIsNew = true;
-				mVoiceFontsNew = true;
-			}
-		}
-
-		LL_DEBUGS("VoiceFont") << (template_font ? "Template " : "")
-			<< font->mExpirationDate.asString() << " " << font->mID
-			<< " (" << font->mFontIndex << ") " << name << LL_ENDL;
-
-		if (new_font)
-		{
-			font_map.insert(voice_font_map_t::value_type(font->mID, font));
-			font_list.insert(voice_effect_list_t::value_type(font->mName, font->mID));
-		}
-
-		mVoiceFontListDirty = true;
-
-		// Debugging stuff
-
-		if (font_type < VOICE_FONT_TYPE_NONE || font_type >= VOICE_FONT_TYPE_UNKNOWN)
-		{
-			LL_WARNS("VoiceFont") << "Unknown voice font type: " << font_type << LL_ENDL;
-		}
-		if (font_status < VOICE_FONT_STATUS_NONE || font_status >= VOICE_FONT_STATUS_UNKNOWN)
-		{
-			LL_WARNS("VoiceFont") << "Unknown voice font status: " << font_status << LL_ENDL;
-		}
-	}
+                                 const std::string &name,
+                                 const std::string &description,
+                                 const LLDate &expiration_date,
+                                 bool has_expired,
+                                 const S32 font_type,
+                                 const S32 font_status,
+                                 const bool template_font)
+{
+    // Vivox SessionFontIDs are not guaranteed to remain the same between
+    // sessions or grids so use a UUID for the name.
+
+    // If received name is not a UUID, fudge one by hashing the name and type.
+    LLUUID font_id;
+    if (LLUUID::validate(name))
+    {
+        font_id = LLUUID(name);
+    }
+    else
+    {
+        font_id.generate(STRINGIZE(font_type << ":" << name));
+    }
+
+    voiceFontEntry *font = NULL;
+
+    voice_font_map_t& font_map = template_font ? mVoiceFontTemplateMap : mVoiceFontMap;
+    voice_effect_list_t& font_list = template_font ? mVoiceFontTemplateList : mVoiceFontList;
+
+    // Check whether we've seen this font before.
+    voice_font_map_t::iterator iter = font_map.find(font_id);
+    bool new_font = (iter == font_map.end());
+
+    // Override the has_expired flag if we have passed the expiration_date as a double check.
+    if (expiration_date.secondsSinceEpoch() < (LLDate::now().secondsSinceEpoch() + VOICE_FONT_EXPIRY_INTERVAL))
+    {
+        has_expired = true;
+    }
+
+    if (has_expired)
+    {
+        LL_DEBUGS("VoiceFont") << "Expired " << (template_font ? "Template " : "")
+        << expiration_date.asString() << " " << font_id
+        << " (" << font_index << ") " << name << LL_ENDL;
+
+        // Remove existing session fonts that have expired since we last saw them.
+        if (!new_font && !template_font)
+        {
+            deleteVoiceFont(font_id);
+        }
+        return;
+    }
+
+    if (new_font)
+    {
+        // If it is a new font create a new entry.
+        font = new voiceFontEntry(font_id);
+    }
+    else
+    {
+        // Not a new font, update the existing entry
+        font = iter->second;
+    }
+
+    if (font)
+    {
+        font->mFontIndex = font_index;
+        // Use the description for the human readable name if available, as the
+        // "name" may be a UUID.
+        font->mName = description.empty() ? name : description;
+        font->mFontType = font_type;
+        font->mFontStatus = font_status;
+
+        // If the font is new or the expiration date has changed the expiry timers need updating.
+        if (!template_font && (new_font || font->mExpirationDate != expiration_date))
+        {
+            font->mExpirationDate = expiration_date;
+
+            // Set the expiry timer to trigger a notification when the voice font can no longer be used.
+            font->mExpiryTimer.start();
+            font->mExpiryTimer.setExpiryAt(expiration_date.secondsSinceEpoch() - VOICE_FONT_EXPIRY_INTERVAL);
+
+            // Set the warning timer to some interval before actual expiry.
+            S32 warning_time = gSavedSettings.getS32("VoiceEffectExpiryWarningTime");
+            if (warning_time != 0)
+            {
+                font->mExpiryWarningTimer.start();
+                F64 expiry_time = (expiration_date.secondsSinceEpoch() - (F64)warning_time);
+                font->mExpiryWarningTimer.setExpiryAt(expiry_time - VOICE_FONT_EXPIRY_INTERVAL);
+            }
+            else
+            {
+                // Disable the warning timer.
+                font->mExpiryWarningTimer.stop();
+            }
+
+             // Only flag new session fonts after the first time we have fetched the list.
+            if (mVoiceFontsReceived)
+            {
+                font->mIsNew = true;
+                mVoiceFontsNew = true;
+            }
+        }
+
+        LL_DEBUGS("VoiceFont") << (template_font ? "Template " : "")
+            << font->mExpirationDate.asString() << " " << font->mID
+            << " (" << font->mFontIndex << ") " << name << LL_ENDL;
+
+        if (new_font)
+        {
+            font_map.insert(voice_font_map_t::value_type(font->mID, font));
+            font_list.insert(voice_effect_list_t::value_type(font->mName, font->mID));
+        }
+
+        mVoiceFontListDirty = true;
+
+        // Debugging stuff
+
+        if (font_type < VOICE_FONT_TYPE_NONE || font_type >= VOICE_FONT_TYPE_UNKNOWN)
+        {
+            LL_WARNS("VoiceFont") << "Unknown voice font type: " << font_type << LL_ENDL;
+        }
+        if (font_status < VOICE_FONT_STATUS_NONE || font_status >= VOICE_FONT_STATUS_UNKNOWN)
+        {
+            LL_WARNS("VoiceFont") << "Unknown voice font status: " << font_status << LL_ENDL;
+        }
+    }
 }
 
 void LLVivoxVoiceClient::expireVoiceFonts()
 {
-	// *TODO: If we are selling voice fonts in packs, there are probably
-	// going to be a number of fonts with the same expiration time, so would
-	// be more efficient to just keep a list of expiration times rather
-	// than checking each font individually.
-
-	bool have_expired = false;
-	bool will_expire = false;
-	bool expired_in_use = false;
-
-	LLUUID current_effect = LLVoiceClient::instance().getVoiceEffectDefault();
-
-	voice_font_map_t::iterator iter;
-	for (iter = mVoiceFontMap.begin(); iter != mVoiceFontMap.end(); ++iter)
-	{
-		voiceFontEntry* voice_font = iter->second;
-		LLFrameTimer& expiry_timer  = voice_font->mExpiryTimer;
-		LLFrameTimer& warning_timer = voice_font->mExpiryWarningTimer;
-
-		// Check for expired voice fonts
-		if (expiry_timer.getStarted() && expiry_timer.hasExpired())
-		{
-			// Check whether it is the active voice font
-			if (voice_font->mID == current_effect)
-			{
-				// Reset to no voice effect.
-				setVoiceEffect(LLUUID::null);
-				expired_in_use = true;
-			}
-
-			LL_DEBUGS("Voice") << "Voice Font " << voice_font->mName << " has expired." << LL_ENDL;
-			deleteVoiceFont(voice_font->mID);
-			have_expired = true;
-		}
-
-		// Check for voice fonts that will expire in less that the warning time
-		if (warning_timer.getStarted() && warning_timer.hasExpired())
-		{
-			LL_DEBUGS("VoiceFont") << "Voice Font " << voice_font->mName << " will expire soon." << LL_ENDL;
-			will_expire = true;
-			warning_timer.stop();
-		}
-	}
-
-	LLSD args;
-	args["URL"] = LLTrans::getString("voice_morphing_url");
-	args["PREMIUM_URL"] = LLTrans::getString("premium_voice_morphing_url");
-
-	// Give a notification if any voice fonts have expired.
-	if (have_expired)
-	{
-		if (expired_in_use)
-		{
-			LLNotificationsUtil::add("VoiceEffectsExpiredInUse", args);
-		}
-		else
-		{
-			LLNotificationsUtil::add("VoiceEffectsExpired", args);
-		}
-
-		// Refresh voice font lists in the UI.
-		notifyVoiceFontObservers();
-	}
-
-	// Give a warning notification if any voice fonts are due to expire.
-	if (will_expire)
-	{
-		S32Seconds seconds(gSavedSettings.getS32("VoiceEffectExpiryWarningTime"));
-		args["INTERVAL"] = llformat("%d", LLUnit<S32, LLUnits::Days>(seconds).value());
-
-		LLNotificationsUtil::add("VoiceEffectsWillExpire", args);
-	}
+    // *TODO: If we are selling voice fonts in packs, there are probably
+    // going to be a number of fonts with the same expiration time, so would
+    // be more efficient to just keep a list of expiration times rather
+    // than checking each font individually.
+
+    bool have_expired = false;
+    bool will_expire = false;
+    bool expired_in_use = false;
+
+    LLUUID current_effect = LLVoiceClient::instance().getVoiceEffectDefault();
+
+    voice_font_map_t::iterator iter;
+    for (iter = mVoiceFontMap.begin(); iter != mVoiceFontMap.end(); ++iter)
+    {
+        voiceFontEntry* voice_font = iter->second;
+        LLFrameTimer& expiry_timer  = voice_font->mExpiryTimer;
+        LLFrameTimer& warning_timer = voice_font->mExpiryWarningTimer;
+
+        // Check for expired voice fonts
+        if (expiry_timer.getStarted() && expiry_timer.hasExpired())
+        {
+            // Check whether it is the active voice font
+            if (voice_font->mID == current_effect)
+            {
+                // Reset to no voice effect.
+                setVoiceEffect(LLUUID::null);
+                expired_in_use = true;
+            }
+
+            LL_DEBUGS("Voice") << "Voice Font " << voice_font->mName << " has expired." << LL_ENDL;
+            deleteVoiceFont(voice_font->mID);
+            have_expired = true;
+        }
+
+        // Check for voice fonts that will expire in less that the warning time
+        if (warning_timer.getStarted() && warning_timer.hasExpired())
+        {
+            LL_DEBUGS("VoiceFont") << "Voice Font " << voice_font->mName << " will expire soon." << LL_ENDL;
+            will_expire = true;
+            warning_timer.stop();
+        }
+    }
+
+    LLSD args;
+    args["URL"] = LLTrans::getString("voice_morphing_url");
+    args["PREMIUM_URL"] = LLTrans::getString("premium_voice_morphing_url");
+
+    // Give a notification if any voice fonts have expired.
+    if (have_expired)
+    {
+        if (expired_in_use)
+        {
+            LLNotificationsUtil::add("VoiceEffectsExpiredInUse", args);
+        }
+        else
+        {
+            LLNotificationsUtil::add("VoiceEffectsExpired", args);
+        }
+
+        // Refresh voice font lists in the UI.
+        notifyVoiceFontObservers();
+    }
+
+    // Give a warning notification if any voice fonts are due to expire.
+    if (will_expire)
+    {
+        S32Seconds seconds(gSavedSettings.getS32("VoiceEffectExpiryWarningTime"));
+        args["INTERVAL"] = llformat("%d", LLUnit<S32, LLUnits::Days>(seconds).value());
+
+        LLNotificationsUtil::add("VoiceEffectsWillExpire", args);
+    }
 }
 
 void LLVivoxVoiceClient::deleteVoiceFont(const LLUUID& id)
 {
-	// Remove the entry from the voice font list.
-	voice_effect_list_t::iterator list_iter = mVoiceFontList.begin();
-	while (list_iter != mVoiceFontList.end())
-	{
-		if (list_iter->second == id)
-		{
-			LL_DEBUGS("VoiceFont") << "Removing " << id << " from the voice font list." << LL_ENDL;
+    // Remove the entry from the voice font list.
+    voice_effect_list_t::iterator list_iter = mVoiceFontList.begin();
+    while (list_iter != mVoiceFontList.end())
+    {
+        if (list_iter->second == id)
+        {
+            LL_DEBUGS("VoiceFont") << "Removing " << id << " from the voice font list." << LL_ENDL;
             list_iter = mVoiceFontList.erase(list_iter);
-			mVoiceFontListDirty = true;
-		}
-		else
-		{
-			++list_iter;
-		}
-	}
+            mVoiceFontListDirty = true;
+        }
+        else
+        {
+            ++list_iter;
+        }
+    }
 
-	// Find the entry in the voice font map and erase its data.
-	voice_font_map_t::iterator map_iter = mVoiceFontMap.find(id);
-	if (map_iter != mVoiceFontMap.end())
-	{
-		delete map_iter->second;
-	}
+    // Find the entry in the voice font map and erase its data.
+    voice_font_map_t::iterator map_iter = mVoiceFontMap.find(id);
+    if (map_iter != mVoiceFontMap.end())
+    {
+        delete map_iter->second;
+    }
 
-	// Remove the entry from the voice font map.
-	mVoiceFontMap.erase(map_iter);
+    // Remove the entry from the voice font map.
+    mVoiceFontMap.erase(map_iter);
 }
 
 void LLVivoxVoiceClient::deleteAllVoiceFonts()
 {
-	mVoiceFontList.clear();
+    mVoiceFontList.clear();
 
-	voice_font_map_t::iterator iter;
-	for (iter = mVoiceFontMap.begin(); iter != mVoiceFontMap.end(); ++iter)
-	{
-		delete iter->second;
-	}
-	mVoiceFontMap.clear();
+    voice_font_map_t::iterator iter;
+    for (iter = mVoiceFontMap.begin(); iter != mVoiceFontMap.end(); ++iter)
+    {
+        delete iter->second;
+    }
+    mVoiceFontMap.clear();
 }
 
 void LLVivoxVoiceClient::deleteVoiceFontTemplates()
 {
-	mVoiceFontTemplateList.clear();
+    mVoiceFontTemplateList.clear();
 
-	voice_font_map_t::iterator iter;
-	for (iter = mVoiceFontTemplateMap.begin(); iter != mVoiceFontTemplateMap.end(); ++iter)
-	{
-		delete iter->second;
-	}
-	mVoiceFontTemplateMap.clear();
+    voice_font_map_t::iterator iter;
+    for (iter = mVoiceFontTemplateMap.begin(); iter != mVoiceFontTemplateMap.end(); ++iter)
+    {
+        delete iter->second;
+    }
+    mVoiceFontTemplateMap.clear();
 }
 
 S32 LLVivoxVoiceClient::getVoiceFontIndex(const LLUUID& id) const
 {
-	S32 result = 0;
-	if (!id.isNull())
-	{
-		voice_font_map_t::const_iterator it = mVoiceFontMap.find(id);
-		if (it != mVoiceFontMap.end())
-		{
-			result = it->second->mFontIndex;
-		}
-		else
-		{
-			LL_WARNS("VoiceFont") << "Selected voice font " << id << " is not available." << LL_ENDL;
-		}
-	}
-	return result;
+    S32 result = 0;
+    if (!id.isNull())
+    {
+        voice_font_map_t::const_iterator it = mVoiceFontMap.find(id);
+        if (it != mVoiceFontMap.end())
+        {
+            result = it->second->mFontIndex;
+        }
+        else
+        {
+            LL_WARNS("VoiceFont") << "Selected voice font " << id << " is not available." << LL_ENDL;
+        }
+    }
+    return result;
 }
 
 S32 LLVivoxVoiceClient::getVoiceFontTemplateIndex(const LLUUID& id) const
 {
-	S32 result = 0;
-	if (!id.isNull())
-	{
-		voice_font_map_t::const_iterator it = mVoiceFontTemplateMap.find(id);
-		if (it != mVoiceFontTemplateMap.end())
-		{
-			result = it->second->mFontIndex;
-		}
-		else
-		{
-			LL_WARNS("VoiceFont") << "Selected voice font template " << id << " is not available." << LL_ENDL;
-		}
-	}
-	return result;
+    S32 result = 0;
+    if (!id.isNull())
+    {
+        voice_font_map_t::const_iterator it = mVoiceFontTemplateMap.find(id);
+        if (it != mVoiceFontTemplateMap.end())
+        {
+            result = it->second->mFontIndex;
+        }
+        else
+        {
+            LL_WARNS("VoiceFont") << "Selected voice font template " << id << " is not available." << LL_ENDL;
+        }
+    }
+    return result;
 }
 
 void LLVivoxVoiceClient::accountGetSessionFontsSendMessage()
 {
-	if(mAccountLoggedIn)
-	{
-		std::ostringstream stream;
+    if(mAccountLoggedIn)
+    {
+        std::ostringstream stream;
 
-		LL_DEBUGS("VoiceFont") << "Requesting voice font list." << LL_ENDL;
+        LL_DEBUGS("VoiceFont") << "Requesting voice font list." << LL_ENDL;
 
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.GetSessionFonts.1\">"
-		<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-		<< "</Request>"
-		<< "\n\n\n";
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.GetSessionFonts.1\">"
+        << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+        << "</Request>"
+        << "\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::accountGetTemplateFontsSendMessage()
 {
-	if(mAccountLoggedIn)
-	{
-		std::ostringstream stream;
+    if(mAccountLoggedIn)
+    {
+        std::ostringstream stream;
 
-		LL_DEBUGS("VoiceFont") << "Requesting voice font template list." << LL_ENDL;
+        LL_DEBUGS("VoiceFont") << "Requesting voice font template list." << LL_ENDL;
 
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.GetTemplateFonts.1\">"
-		<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-		<< "</Request>"
-		<< "\n\n\n";
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Account.GetTemplateFonts.1\">"
+        << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+        << "</Request>"
+        << "\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::sessionSetVoiceFontSendMessage(const sessionStatePtr_t &session)
 {
-	S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
-	LL_DEBUGS("VoiceFont") << "Requesting voice font: " << session->mVoiceFontID << " (" << font_index << "), session handle: " << session->mHandle << LL_ENDL;
+    S32 font_index = getVoiceFontIndex(session->mVoiceFontID);
+    LL_DEBUGS("VoiceFont") << "Requesting voice font: " << session->mVoiceFontID << " (" << font_index << "), session handle: " << session->mHandle << LL_ENDL;
 
-	std::ostringstream stream;
+    std::ostringstream stream;
 
-	stream
-	<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.SetVoiceFont.1\">"
-	<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
-	<< "<SessionFontID>" << font_index << "</SessionFontID>"
-	<< "</Request>\n\n\n";
+    stream
+    << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Session.SetVoiceFont.1\">"
+    << "<SessionHandle>" << session->mHandle << "</SessionHandle>"
+    << "<SessionFontID>" << font_index << "</SessionFontID>"
+    << "</Request>\n\n\n";
 
-	writeString(stream.str());
+    writeString(stream.str());
 }
 
 void LLVivoxVoiceClient::accountGetSessionFontsResponse(int statusCode, const std::string &statusString)
@@ -6833,117 +6833,117 @@ void LLVivoxVoiceClient::accountGetSessionFontsResponse(int statusCode, const st
 
         mVivoxPump.post(result);
     }
-	notifyVoiceFontObservers();
-	mVoiceFontsReceived = true;
+    notifyVoiceFontObservers();
+    mVoiceFontsReceived = true;
 }
 
 void LLVivoxVoiceClient::accountGetTemplateFontsResponse(int statusCode, const std::string &statusString)
 {
-	// Voice font list entries were updated via addVoiceFont() during parsing.
-	notifyVoiceFontObservers();
+    // Voice font list entries were updated via addVoiceFont() during parsing.
+    notifyVoiceFontObservers();
 }
 void LLVivoxVoiceClient::addObserver(LLVoiceEffectObserver* observer)
 {
-	mVoiceFontObservers.insert(observer);
+    mVoiceFontObservers.insert(observer);
 }
 
 void LLVivoxVoiceClient::removeObserver(LLVoiceEffectObserver* observer)
 {
-	mVoiceFontObservers.erase(observer);
+    mVoiceFontObservers.erase(observer);
 }
 
 // method checks the item in VoiceMorphing menu for appropriate current voice font
 bool LLVivoxVoiceClient::onCheckVoiceEffect(const std::string& voice_effect_name)
 {
-	LLVoiceEffectInterface * effect_interfacep = LLVoiceClient::instance().getVoiceEffectInterface();
-	if (NULL != effect_interfacep)
-	{
-		const LLUUID& currect_voice_effect_id = effect_interfacep->getVoiceEffect();
-
-		if (currect_voice_effect_id.isNull())
-		{
-			if (voice_effect_name == "NoVoiceMorphing")
-			{
-				return true;
-			}
-		}
-		else
-		{
-			const LLSD& voice_effect_props = effect_interfacep->getVoiceEffectProperties(currect_voice_effect_id);
-			if (voice_effect_props["name"].asString() == voice_effect_name)
-			{
-				return true;
-			}
-		}
-	}
-
-	return false;
+    LLVoiceEffectInterface * effect_interfacep = LLVoiceClient::instance().getVoiceEffectInterface();
+    if (NULL != effect_interfacep)
+    {
+        const LLUUID& currect_voice_effect_id = effect_interfacep->getVoiceEffect();
+
+        if (currect_voice_effect_id.isNull())
+        {
+            if (voice_effect_name == "NoVoiceMorphing")
+            {
+                return true;
+            }
+        }
+        else
+        {
+            const LLSD& voice_effect_props = effect_interfacep->getVoiceEffectProperties(currect_voice_effect_id);
+            if (voice_effect_props["name"].asString() == voice_effect_name)
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
 }
 
 // method changes voice font for selected VoiceMorphing menu item
 void LLVivoxVoiceClient::onClickVoiceEffect(const std::string& voice_effect_name)
 {
-	LLVoiceEffectInterface * effect_interfacep = LLVoiceClient::instance().getVoiceEffectInterface();
-	if (NULL != effect_interfacep)
-	{
-		if (voice_effect_name == "NoVoiceMorphing")
-		{
-			effect_interfacep->setVoiceEffect(LLUUID());
-			return;
-		}
-		const voice_effect_list_t& effect_list = effect_interfacep->getVoiceEffectList();
-		if (!effect_list.empty())
-		{
-			for (voice_effect_list_t::const_iterator it = effect_list.begin(); it != effect_list.end(); ++it)
-			{
-				if (voice_effect_name == it->first)
-				{
-					effect_interfacep->setVoiceEffect(it->second);
-					return;
-				}
-			}
-		}
-	}
+    LLVoiceEffectInterface * effect_interfacep = LLVoiceClient::instance().getVoiceEffectInterface();
+    if (NULL != effect_interfacep)
+    {
+        if (voice_effect_name == "NoVoiceMorphing")
+        {
+            effect_interfacep->setVoiceEffect(LLUUID());
+            return;
+        }
+        const voice_effect_list_t& effect_list = effect_interfacep->getVoiceEffectList();
+        if (!effect_list.empty())
+        {
+            for (voice_effect_list_t::const_iterator it = effect_list.begin(); it != effect_list.end(); ++it)
+            {
+                if (voice_effect_name == it->first)
+                {
+                    effect_interfacep->setVoiceEffect(it->second);
+                    return;
+                }
+            }
+        }
+    }
 }
 
 // it updates VoiceMorphing menu items in accordance with purchased properties
 void LLVivoxVoiceClient::updateVoiceMorphingMenu()
 {
-	if (mVoiceFontListDirty)
-	{
-		LLVoiceEffectInterface * effect_interfacep = LLVoiceClient::instance().getVoiceEffectInterface();
-		if (effect_interfacep)
-		{
-			const voice_effect_list_t& effect_list = effect_interfacep->getVoiceEffectList();
-			if (!effect_list.empty())
-			{
-				LLMenuGL * voice_morphing_menup = gMenuBarView->findChildMenuByName("VoiceMorphing", TRUE);
-
-				if (NULL != voice_morphing_menup)
-				{
-					S32 items = voice_morphing_menup->getItemCount();
-					if (items > 0)
-					{
-						voice_morphing_menup->erase(1, items - 3, false);
-
-						S32 pos = 1;
-						for (voice_effect_list_t::const_iterator it = effect_list.begin(); it != effect_list.end(); ++it)
-						{
-							LLMenuItemCheckGL::Params p;
-							p.name = it->first;
-							p.label = it->first;
-							p.on_check.function(boost::bind(&LLVivoxVoiceClient::onCheckVoiceEffect, this, it->first));
-							p.on_click.function(boost::bind(&LLVivoxVoiceClient::onClickVoiceEffect, this, it->first));
-							LLMenuItemCheckGL * voice_effect_itemp = LLUICtrlFactory::create<LLMenuItemCheckGL>(p);
-							voice_morphing_menup->insert(pos++, voice_effect_itemp, false);
-						}
-
-						voice_morphing_menup->needsArrange();
-					}
-				}
-			}
-		}
-	}
+    if (mVoiceFontListDirty)
+    {
+        LLVoiceEffectInterface * effect_interfacep = LLVoiceClient::instance().getVoiceEffectInterface();
+        if (effect_interfacep)
+        {
+            const voice_effect_list_t& effect_list = effect_interfacep->getVoiceEffectList();
+            if (!effect_list.empty())
+            {
+                LLMenuGL * voice_morphing_menup = gMenuBarView->findChildMenuByName("VoiceMorphing", TRUE);
+
+                if (NULL != voice_morphing_menup)
+                {
+                    S32 items = voice_morphing_menup->getItemCount();
+                    if (items > 0)
+                    {
+                        voice_morphing_menup->erase(1, items - 3, false);
+
+                        S32 pos = 1;
+                        for (voice_effect_list_t::const_iterator it = effect_list.begin(); it != effect_list.end(); ++it)
+                        {
+                            LLMenuItemCheckGL::Params p;
+                            p.name = it->first;
+                            p.label = it->first;
+                            p.on_check.function(boost::bind(&LLVivoxVoiceClient::onCheckVoiceEffect, this, it->first));
+                            p.on_click.function(boost::bind(&LLVivoxVoiceClient::onClickVoiceEffect, this, it->first));
+                            LLMenuItemCheckGL * voice_effect_itemp = LLUICtrlFactory::create<LLMenuItemCheckGL>(p);
+                            voice_morphing_menup->insert(pos++, voice_effect_itemp, false);
+                        }
+
+                        voice_morphing_menup->needsArrange();
+                    }
+                }
+            }
+        }
+    }
 }
 void LLVivoxVoiceClient::notifyVoiceFontObservers()
 {
@@ -6961,7 +6961,7 @@ void LLVivoxVoiceClient::notifyVoiceFontObservers()
     }
     mVoiceFontListDirty = false;
 
-	// If new Voice Fonts have been added notify the user.
+    // If new Voice Fonts have been added notify the user.
     if (mVoiceFontsNew)
     {
         if (mVoiceFontsReceived)
@@ -6984,23 +6984,23 @@ void LLVivoxVoiceClient::enablePreviewBuffer(bool enable)
 
     mVivoxPump.post(result);
 
-	if(mCaptureBufferMode && mIsInChannel)
-	{
-		LL_DEBUGS("Voice") << "no channel" << LL_ENDL;
-		sessionTerminate();
-	}
+    if(mCaptureBufferMode && mIsInChannel)
+    {
+        LL_DEBUGS("Voice") << "no channel" << LL_ENDL;
+        sessionTerminate();
+    }
 }
 
 void LLVivoxVoiceClient::recordPreviewBuffer()
 {
-	if (!mCaptureBufferMode)
-	{
-		LL_DEBUGS("Voice") << "Not in voice effect preview mode, cannot start recording." << LL_ENDL;
-		mCaptureBufferRecording = false;
-		return;
-	}
+    if (!mCaptureBufferMode)
+    {
+        LL_DEBUGS("Voice") << "Not in voice effect preview mode, cannot start recording." << LL_ENDL;
+        mCaptureBufferRecording = false;
+        return;
+    }
 
-	mCaptureBufferRecording = true;
+    mCaptureBufferRecording = true;
 
     LLSD result(LLSDMap("recplay", "record"));
     mVivoxPump.post(result);
@@ -7008,22 +7008,22 @@ void LLVivoxVoiceClient::recordPreviewBuffer()
 
 void LLVivoxVoiceClient::playPreviewBuffer(const LLUUID& effect_id)
 {
-	if (!mCaptureBufferMode)
-	{
-		LL_DEBUGS("Voice") << "Not in voice effect preview mode, no buffer to play." << LL_ENDL;
-		mCaptureBufferRecording = false;
-		return;
-	}
+    if (!mCaptureBufferMode)
+    {
+        LL_DEBUGS("Voice") << "Not in voice effect preview mode, no buffer to play." << LL_ENDL;
+        mCaptureBufferRecording = false;
+        return;
+    }
 
-	if (!mCaptureBufferRecorded)
-	{
-		// Can't play until we have something recorded!
-		mCaptureBufferPlaying = false;
-		return;
-	}
+    if (!mCaptureBufferRecorded)
+    {
+        // Can't play until we have something recorded!
+        mCaptureBufferPlaying = false;
+        return;
+    }
 
-	mPreviewVoiceFont = effect_id;
-	mCaptureBufferPlaying = true;
+    mPreviewVoiceFont = effect_id;
+    mCaptureBufferPlaying = true;
 
     LLSD result(LLSDMap("recplay", "playback"));
     mVivoxPump.post(result);
@@ -7031,8 +7031,8 @@ void LLVivoxVoiceClient::playPreviewBuffer(const LLUUID& effect_id)
 
 void LLVivoxVoiceClient::stopPreviewBuffer()
 {
-	mCaptureBufferRecording = false;
-	mCaptureBufferPlaying = false;
+    mCaptureBufferRecording = false;
+    mCaptureBufferPlaying = false;
 
     LLSD result(LLSDMap("recplay", "quit"));
     mVivoxPump.post(result);
@@ -7040,236 +7040,236 @@ void LLVivoxVoiceClient::stopPreviewBuffer()
 
 bool LLVivoxVoiceClient::isPreviewRecording()
 {
-	return (mCaptureBufferMode && mCaptureBufferRecording);
+    return (mCaptureBufferMode && mCaptureBufferRecording);
 }
 
 bool LLVivoxVoiceClient::isPreviewPlaying()
 {
-	return (mCaptureBufferMode && mCaptureBufferPlaying);
+    return (mCaptureBufferMode && mCaptureBufferPlaying);
 }
 
 void LLVivoxVoiceClient::captureBufferRecordStartSendMessage()
-{	if(mAccountLoggedIn)
-	{
-		std::ostringstream stream;
+{   if(mAccountLoggedIn)
+    {
+        std::ostringstream stream;
 
-		LL_DEBUGS("Voice") << "Starting audio capture to buffer." << LL_ENDL;
+        LL_DEBUGS("Voice") << "Starting audio capture to buffer." << LL_ENDL;
 
-		// Start capture
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.StartBufferCapture.1\">"
-		<< "</Request>"
-		<< "\n\n\n";
+        // Start capture
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.StartBufferCapture.1\">"
+        << "</Request>"
+        << "\n\n\n";
 
-		// Unmute the mic
-		stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalMic.1\">"
-			<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-			<< "<Value>false</Value>"
-		<< "</Request>\n\n\n";
+        // Unmute the mic
+        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalMic.1\">"
+            << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+            << "<Value>false</Value>"
+        << "</Request>\n\n\n";
 
-		// Dirty the mute mic state so that it will get reset when we finishing previewing
-		mMuteMicDirty = true;
+        // Dirty the mute mic state so that it will get reset when we finishing previewing
+        mMuteMicDirty = true;
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::captureBufferRecordStopSendMessage()
 {
-	if(mAccountLoggedIn)
-	{
-		std::ostringstream stream;
+    if(mAccountLoggedIn)
+    {
+        std::ostringstream stream;
 
-		LL_DEBUGS("Voice") << "Stopping audio capture to buffer." << LL_ENDL;
+        LL_DEBUGS("Voice") << "Stopping audio capture to buffer." << LL_ENDL;
 
-		// Mute the mic. Mic mute state was dirtied at recording start, so will be reset when finished previewing.
-		stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalMic.1\">"
-			<< "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
-			<< "<Value>true</Value>"
-		<< "</Request>\n\n\n";
+        // Mute the mic. Mic mute state was dirtied at recording start, so will be reset when finished previewing.
+        stream << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Connector.MuteLocalMic.1\">"
+            << "<ConnectorHandle>" << LLVivoxSecurity::getInstance()->connectorHandle() << "</ConnectorHandle>"
+            << "<Value>true</Value>"
+        << "</Request>\n\n\n";
 
-		// Stop capture
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.CaptureAudioStop.1\">"
-			<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-		<< "</Request>"
-		<< "\n\n\n";
+        // Stop capture
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.CaptureAudioStop.1\">"
+            << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+        << "</Request>"
+        << "\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::captureBufferPlayStartSendMessage(const LLUUID& voice_font_id)
 {
-	if(mAccountLoggedIn)
-	{
-		// Track how may play requests are sent, so we know how many stop events to
-		// expect before play actually stops.
-		++mPlayRequestCount;
+    if(mAccountLoggedIn)
+    {
+        // Track how may play requests are sent, so we know how many stop events to
+        // expect before play actually stops.
+        ++mPlayRequestCount;
 
-		std::ostringstream stream;
+        std::ostringstream stream;
 
-		LL_DEBUGS("Voice") << "Starting audio buffer playback." << LL_ENDL;
+        LL_DEBUGS("Voice") << "Starting audio buffer playback." << LL_ENDL;
 
-		S32 font_index = getVoiceFontTemplateIndex(voice_font_id);
-		LL_DEBUGS("Voice") << "With voice font: " << voice_font_id << " (" << font_index << ")" << LL_ENDL;
+        S32 font_index = getVoiceFontTemplateIndex(voice_font_id);
+        LL_DEBUGS("Voice") << "With voice font: " << voice_font_id << " (" << font_index << ")" << LL_ENDL;
 
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.PlayAudioBuffer.1\">"
-			<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-			<< "<TemplateFontID>" << font_index << "</TemplateFontID>"
-			<< "<FontDelta />"
-		<< "</Request>"
-		<< "\n\n\n";
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.PlayAudioBuffer.1\">"
+            << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+            << "<TemplateFontID>" << font_index << "</TemplateFontID>"
+            << "<FontDelta />"
+        << "</Request>"
+        << "\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 void LLVivoxVoiceClient::captureBufferPlayStopSendMessage()
 {
-	if(mAccountLoggedIn)
-	{
-		std::ostringstream stream;
+    if(mAccountLoggedIn)
+    {
+        std::ostringstream stream;
 
-		LL_DEBUGS("Voice") << "Stopping audio buffer playback." << LL_ENDL;
+        LL_DEBUGS("Voice") << "Stopping audio buffer playback." << LL_ENDL;
 
-		stream
-		<< "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.RenderAudioStop.1\">"
-			<< "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
-		<< "</Request>"
-		<< "\n\n\n";
+        stream
+        << "<Request requestId=\"" << mCommandCookie++ << "\" action=\"Aux.RenderAudioStop.1\">"
+            << "<AccountHandle>" << LLVivoxSecurity::getInstance()->accountHandle() << "</AccountHandle>"
+        << "</Request>"
+        << "\n\n\n";
 
-		writeString(stream.str());
-	}
+        writeString(stream.str());
+    }
 }
 
 LLVivoxProtocolParser::LLVivoxProtocolParser()
 {
-	parser = XML_ParserCreate(NULL);
+    parser = XML_ParserCreate(NULL);
 
-	reset();
+    reset();
 }
 
 void LLVivoxProtocolParser::reset()
 {
-	responseDepth = 0;
-	ignoringTags = false;
-	accumulateText = false;
-	energy = 0.f;
-	hasText = false;
-	hasAudio = false;
-	hasVideo = false;
-	terminated = false;
-	ignoreDepth = 0;
-	isChannel = false;
-	incoming = false;
-	enabled = false;
-	isEvent = false;
-	isLocallyMuted = false;
-	isModeratorMuted = false;
-	isSpeaking = false;
-	participantType = 0;
-	returnCode = -1;
-	state = 0;
-	statusCode = 0;
-	volume = 0;
-	textBuffer.clear();
-	alias.clear();
-	numberOfAliases = 0;
-	applicationString.clear();
+    responseDepth = 0;
+    ignoringTags = false;
+    accumulateText = false;
+    energy = 0.f;
+    hasText = false;
+    hasAudio = false;
+    hasVideo = false;
+    terminated = false;
+    ignoreDepth = 0;
+    isChannel = false;
+    incoming = false;
+    enabled = false;
+    isEvent = false;
+    isLocallyMuted = false;
+    isModeratorMuted = false;
+    isSpeaking = false;
+    participantType = 0;
+    returnCode = -1;
+    state = 0;
+    statusCode = 0;
+    volume = 0;
+    textBuffer.clear();
+    alias.clear();
+    numberOfAliases = 0;
+    applicationString.clear();
 }
 
 //virtual
 LLVivoxProtocolParser::~LLVivoxProtocolParser()
 {
-	if (parser)
-		XML_ParserFree(parser);
+    if (parser)
+        XML_ParserFree(parser);
 }
 
 static LLTrace::BlockTimerStatHandle FTM_VIVOX_PROCESS("Vivox Process");
 
 // virtual
 LLIOPipe::EStatus LLVivoxProtocolParser::process_impl(
-													  const LLChannelDescriptors& channels,
-													  buffer_ptr_t& buffer,
-													  bool& eos,
-													  LLSD& context,
-													  LLPumpIO* pump)
-{
-	LL_RECORD_BLOCK_TIME(FTM_VIVOX_PROCESS);
-	LLBufferStream istr(channels, buffer.get());
-	std::ostringstream ostr;
-	while (istr.good())
-	{
-		char buf[1024];
-		istr.read(buf, sizeof(buf));
-		mInput.append(buf, istr.gcount());
-	}
-
-	// Look for input delimiter(s) in the input buffer.  If one is found, send the message to the xml parser.
-	int start = 0;
-	int delim;
-	while((delim = mInput.find("\n\n\n", start)) != std::string::npos)
-	{
-
-		// Reset internal state of the LLVivoxProtocolParser (no effect on the expat parser)
-		reset();
-
-		XML_ParserReset(parser, NULL);
-		XML_SetElementHandler(parser, ExpatStartTag, ExpatEndTag);
-		XML_SetCharacterDataHandler(parser, ExpatCharHandler);
-		XML_SetUserData(parser, this);
-		XML_Parse(parser, mInput.data() + start, delim - start, false);
+                                                      const LLChannelDescriptors& channels,
+                                                      buffer_ptr_t& buffer,
+                                                      bool& eos,
+                                                      LLSD& context,
+                                                      LLPumpIO* pump)
+{
+    LL_RECORD_BLOCK_TIME(FTM_VIVOX_PROCESS);
+    LLBufferStream istr(channels, buffer.get());
+    std::ostringstream ostr;
+    while (istr.good())
+    {
+        char buf[1024];
+        istr.read(buf, sizeof(buf));
+        mInput.append(buf, istr.gcount());
+    }
+
+    // Look for input delimiter(s) in the input buffer.  If one is found, send the message to the xml parser.
+    int start = 0;
+    int delim;
+    while((delim = mInput.find("\n\n\n", start)) != std::string::npos)
+    {
+
+        // Reset internal state of the LLVivoxProtocolParser (no effect on the expat parser)
+        reset();
+
+        XML_ParserReset(parser, NULL);
+        XML_SetElementHandler(parser, ExpatStartTag, ExpatEndTag);
+        XML_SetCharacterDataHandler(parser, ExpatCharHandler);
+        XML_SetUserData(parser, this);
+        XML_Parse(parser, mInput.data() + start, delim - start, false);
 
         LL_DEBUGS("VivoxProtocolParser") << "parsing: " << mInput.substr(start, delim - start) << LL_ENDL;
-		start = delim + 3;
-	}
+        start = delim + 3;
+    }
 
-	if(start != 0)
-		mInput = mInput.substr(start);
+    if(start != 0)
+        mInput = mInput.substr(start);
 
-	LL_DEBUGS("VivoxProtocolParser") << "at end, mInput is: " << mInput << LL_ENDL;
+    LL_DEBUGS("VivoxProtocolParser") << "at end, mInput is: " << mInput << LL_ENDL;
 
-	if(!LLVivoxVoiceClient::sConnected)
-	{
-		// If voice has been disabled, we just want to close the socket.  This does so.
-		LL_INFOS("Voice") << "returning STATUS_STOP" << LL_ENDL;
-		return STATUS_STOP;
-	}
+    if(!LLVivoxVoiceClient::sConnected)
+    {
+        // If voice has been disabled, we just want to close the socket.  This does so.
+        LL_INFOS("Voice") << "returning STATUS_STOP" << LL_ENDL;
+        return STATUS_STOP;
+    }
 
-	return STATUS_OK;
+    return STATUS_OK;
 }
 
 void XMLCALL LLVivoxProtocolParser::ExpatStartTag(void *data, const char *el, const char **attr)
 {
-	if (data)
-	{
-		LLVivoxProtocolParser	*object = (LLVivoxProtocolParser*)data;
-		object->StartTag(el, attr);
-	}
+    if (data)
+    {
+        LLVivoxProtocolParser   *object = (LLVivoxProtocolParser*)data;
+        object->StartTag(el, attr);
+    }
 }
 
 // --------------------------------------------------------------------------------
 
 void XMLCALL LLVivoxProtocolParser::ExpatEndTag(void *data, const char *el)
 {
-	if (data)
-	{
-		LLVivoxProtocolParser	*object = (LLVivoxProtocolParser*)data;
-		object->EndTag(el);
-	}
+    if (data)
+    {
+        LLVivoxProtocolParser   *object = (LLVivoxProtocolParser*)data;
+        object->EndTag(el);
+    }
 }
 
 // --------------------------------------------------------------------------------
 
 void XMLCALL LLVivoxProtocolParser::ExpatCharHandler(void *data, const XML_Char *s, int len)
 {
-	if (data)
-	{
-		LLVivoxProtocolParser	*object = (LLVivoxProtocolParser*)data;
-		object->CharData(s, len);
-	}
+    if (data)
+    {
+        LLVivoxProtocolParser   *object = (LLVivoxProtocolParser*)data;
+        object->CharData(s, len);
+    }
 }
 
 // --------------------------------------------------------------------------------
@@ -7277,623 +7277,623 @@ void XMLCALL LLVivoxProtocolParser::ExpatCharHandler(void *data, const XML_Char
 
 void LLVivoxProtocolParser::StartTag(const char *tag, const char **attr)
 {
-	// Reset the text accumulator. We shouldn't have strings that are inturrupted by new tags
-	textBuffer.clear();
-	// only accumulate text if we're not ignoring tags.
-	accumulateText = !ignoringTags;
-
-	if (responseDepth == 0)
-	{
-		isEvent = !stricmp("Event", tag);
-
-		if (!stricmp("Response", tag) || isEvent)
-		{
-			// Grab the attributes
-			while (*attr)
-			{
-				const char	*key = *attr++;
-				const char	*value = *attr++;
-
-				if (!stricmp("requestId", key))
-				{
-					requestId = value;
-				}
-				else if (!stricmp("action", key))
-				{
-					actionString = value;
-				}
-				else if (!stricmp("type", key))
-				{
-					eventTypeString = value;
-				}
-			}
-		}
-		LL_DEBUGS("VivoxProtocolParser") << tag << " (" << responseDepth << ")"  << LL_ENDL;
-	}
-	else
-	{
-		if (ignoringTags)
-		{
-			LL_DEBUGS("VivoxProtocolParser") << "ignoring tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
-		}
-		else
-		{
-			LL_DEBUGS("VivoxProtocolParser") << tag << " (" << responseDepth << ")"  << LL_ENDL;
-
-			// Ignore the InputXml stuff so we don't get confused
-			if (!stricmp("InputXml", tag))
-			{
-				ignoringTags = true;
-				ignoreDepth = responseDepth;
-				accumulateText = false;
-
-				LL_DEBUGS("VivoxProtocolParser") << "starting ignore, ignoreDepth is " << ignoreDepth << LL_ENDL;
-			}
-			else if (!stricmp("CaptureDevices", tag))
-			{
-				LLVivoxVoiceClient::getInstance()->clearCaptureDevices();
-			}
-			else if (!stricmp("RenderDevices", tag))
-			{
-				LLVivoxVoiceClient::getInstance()->clearRenderDevices();
-			}
-			else if (!stricmp("CaptureDevice", tag))
-			{
-				deviceString.clear();
-			}
-			else if (!stricmp("RenderDevice", tag))
-			{
-				deviceString.clear();
-			}
-			else if (!stricmp("SessionFont", tag))
-			{
-				id = 0;
-				nameString.clear();
-				descriptionString.clear();
-				expirationDate = LLDate();
-				hasExpired = false;
-				fontType = 0;
-				fontStatus = 0;
-			}
-			else if (!stricmp("TemplateFont", tag))
-			{
-				id = 0;
-				nameString.clear();
-				descriptionString.clear();
-				expirationDate = LLDate();
-				hasExpired = false;
-				fontType = 0;
-				fontStatus = 0;
-			}
-			else if (!stricmp("MediaCompletionType", tag))
-			{
-				mediaCompletionType.clear();
-			}
-		}
-	}
-	responseDepth++;
+    // Reset the text accumulator. We shouldn't have strings that are inturrupted by new tags
+    textBuffer.clear();
+    // only accumulate text if we're not ignoring tags.
+    accumulateText = !ignoringTags;
+
+    if (responseDepth == 0)
+    {
+        isEvent = !stricmp("Event", tag);
+
+        if (!stricmp("Response", tag) || isEvent)
+        {
+            // Grab the attributes
+            while (*attr)
+            {
+                const char  *key = *attr++;
+                const char  *value = *attr++;
+
+                if (!stricmp("requestId", key))
+                {
+                    requestId = value;
+                }
+                else if (!stricmp("action", key))
+                {
+                    actionString = value;
+                }
+                else if (!stricmp("type", key))
+                {
+                    eventTypeString = value;
+                }
+            }
+        }
+        LL_DEBUGS("VivoxProtocolParser") << tag << " (" << responseDepth << ")"  << LL_ENDL;
+    }
+    else
+    {
+        if (ignoringTags)
+        {
+            LL_DEBUGS("VivoxProtocolParser") << "ignoring tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
+        }
+        else
+        {
+            LL_DEBUGS("VivoxProtocolParser") << tag << " (" << responseDepth << ")"  << LL_ENDL;
+
+            // Ignore the InputXml stuff so we don't get confused
+            if (!stricmp("InputXml", tag))
+            {
+                ignoringTags = true;
+                ignoreDepth = responseDepth;
+                accumulateText = false;
+
+                LL_DEBUGS("VivoxProtocolParser") << "starting ignore, ignoreDepth is " << ignoreDepth << LL_ENDL;
+            }
+            else if (!stricmp("CaptureDevices", tag))
+            {
+                LLVivoxVoiceClient::getInstance()->clearCaptureDevices();
+            }
+            else if (!stricmp("RenderDevices", tag))
+            {
+                LLVivoxVoiceClient::getInstance()->clearRenderDevices();
+            }
+            else if (!stricmp("CaptureDevice", tag))
+            {
+                deviceString.clear();
+            }
+            else if (!stricmp("RenderDevice", tag))
+            {
+                deviceString.clear();
+            }
+            else if (!stricmp("SessionFont", tag))
+            {
+                id = 0;
+                nameString.clear();
+                descriptionString.clear();
+                expirationDate = LLDate();
+                hasExpired = false;
+                fontType = 0;
+                fontStatus = 0;
+            }
+            else if (!stricmp("TemplateFont", tag))
+            {
+                id = 0;
+                nameString.clear();
+                descriptionString.clear();
+                expirationDate = LLDate();
+                hasExpired = false;
+                fontType = 0;
+                fontStatus = 0;
+            }
+            else if (!stricmp("MediaCompletionType", tag))
+            {
+                mediaCompletionType.clear();
+            }
+        }
+    }
+    responseDepth++;
 }
 
 // --------------------------------------------------------------------------------
 
 void LLVivoxProtocolParser::EndTag(const char *tag)
 {
-	const std::string& string = textBuffer;
-
-	responseDepth--;
-
-	if (ignoringTags)
-	{
-		if (ignoreDepth == responseDepth)
-		{
-			LL_DEBUGS("VivoxProtocolParser") << "end of ignore" << LL_ENDL;
-			ignoringTags = false;
-		}
-		else
-		{
-			LL_DEBUGS("VivoxProtocolParser") << "ignoring tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
-		}
-	}
-
-	if (!ignoringTags)
-	{
-		LL_DEBUGS("VivoxProtocolParser") << "processing tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
-
-		// Closing a tag. Finalize the text we've accumulated and reset
-		if (!stricmp("ReturnCode", tag))
-			returnCode = strtol(string.c_str(), NULL, 10);
-		else if (!stricmp("SessionHandle", tag))
-			sessionHandle = string;
-		else if (!stricmp("SessionGroupHandle", tag))
-			sessionGroupHandle = string;
-		else if (!stricmp("StatusCode", tag))
-			statusCode = strtol(string.c_str(), NULL, 10);
-		else if (!stricmp("StatusString", tag))
-			statusString = string;
-		else if (!stricmp("ParticipantURI", tag))
-			uriString = string;
-		else if (!stricmp("Volume", tag))
-			volume = strtol(string.c_str(), NULL, 10);
-		else if (!stricmp("Energy", tag))
-			energy = (F32)strtod(string.c_str(), NULL);
-		else if (!stricmp("IsModeratorMuted", tag))
-			isModeratorMuted = !stricmp(string.c_str(), "true");
-		else if (!stricmp("IsSpeaking", tag))
-			isSpeaking = !stricmp(string.c_str(), "true");
-		else if (!stricmp("Alias", tag))
-			alias = string;
-		else if (!stricmp("NumberOfAliases", tag))
-			numberOfAliases = strtol(string.c_str(), NULL, 10);
-		else if (!stricmp("Application", tag))
-			applicationString = string;
-		else if (!stricmp("ConnectorHandle", tag))
-			connectorHandle = string;
-		else if (!stricmp("VersionID", tag))
-			versionID = string;
-		else if (!stricmp("Version", tag))
-			mBuildID = string;
-		else if (!stricmp("AccountHandle", tag))
-			accountHandle = string;
-		else if (!stricmp("State", tag))
-			state = strtol(string.c_str(), NULL, 10);
-		else if (!stricmp("URI", tag))
-			uriString = string;
-		else if (!stricmp("IsChannel", tag))
-			isChannel = !stricmp(string.c_str(), "true");
-		else if (!stricmp("Incoming", tag))
-			incoming = !stricmp(string.c_str(), "true");
-		else if (!stricmp("Enabled", tag))
-			enabled = !stricmp(string.c_str(), "true");
-		else if (!stricmp("Name", tag))
-			nameString = string;
-		else if (!stricmp("AudioMedia", tag))
-			audioMediaString = string;
-		else if (!stricmp("ChannelName", tag))
-			nameString = string;
-		else if (!stricmp("DisplayName", tag))
-			displayNameString = string;
-		else if (!stricmp("Device", tag))
-			deviceString = string;
-		else if (!stricmp("AccountName", tag))
-			nameString = string;
-		else if (!stricmp("ParticipantType", tag))
-			participantType = strtol(string.c_str(), NULL, 10);
-		else if (!stricmp("IsLocallyMuted", tag))
-			isLocallyMuted = !stricmp(string.c_str(), "true");
-		else if (!stricmp("MicEnergy", tag))
-			energy = (F32)strtod(string.c_str(), NULL);
-		else if (!stricmp("ChannelName", tag))
-			nameString = string;
-		else if (!stricmp("ChannelURI", tag))
-			uriString = string;
-		else if (!stricmp("BuddyURI", tag))
-			uriString = string;
-		else if (!stricmp("Presence", tag))
-			statusString = string;
-		else if (!stricmp("CaptureDevices", tag))
-		{
-			LLVivoxVoiceClient::getInstance()->setDevicesListUpdated(true);
-		}
-		else if (!stricmp("RenderDevices", tag))
-		{
-			LLVivoxVoiceClient::getInstance()->setDevicesListUpdated(true);
-		}
-		else if (!stricmp("CaptureDevice", tag))
-		{
-			LLVivoxVoiceClient::getInstance()->addCaptureDevice(LLVoiceDevice(displayNameString, deviceString));
-		}
-		else if (!stricmp("RenderDevice", tag))
-		{
-			LLVivoxVoiceClient::getInstance()->addRenderDevice(LLVoiceDevice(displayNameString, deviceString));
-		}
-		else if (!stricmp("BlockMask", tag))
-			blockMask = string;
-		else if (!stricmp("PresenceOnly", tag))
-			presenceOnly = string;
-		else if (!stricmp("AutoAcceptMask", tag))
-			autoAcceptMask = string;
-		else if (!stricmp("AutoAddAsBuddy", tag))
-			autoAddAsBuddy = string;
-		else if (!stricmp("MessageHeader", tag))
-			messageHeader = string;
-		else if (!stricmp("MessageBody", tag))
-			messageBody = string;
-		else if (!stricmp("NotificationType", tag))
-			notificationType = string;
-		else if (!stricmp("HasText", tag))
-			hasText = !stricmp(string.c_str(), "true");
-		else if (!stricmp("HasAudio", tag))
-			hasAudio = !stricmp(string.c_str(), "true");
-		else if (!stricmp("HasVideo", tag))
-			hasVideo = !stricmp(string.c_str(), "true");
-		else if (!stricmp("Terminated", tag))
-			terminated = !stricmp(string.c_str(), "true");
-		else if (!stricmp("SubscriptionHandle", tag))
-			subscriptionHandle = string;
-		else if (!stricmp("SubscriptionType", tag))
-			subscriptionType = string;
-		else if (!stricmp("SessionFont", tag))
-		{
-			LLVivoxVoiceClient::getInstance()->addVoiceFont(id, nameString, descriptionString, expirationDate, hasExpired, fontType, fontStatus, false);
-		}
-		else if (!stricmp("TemplateFont", tag))
-		{
-			LLVivoxVoiceClient::getInstance()->addVoiceFont(id, nameString, descriptionString, expirationDate, hasExpired, fontType, fontStatus, true);
-		}
-		else if (!stricmp("ID", tag))
-		{
-			id = strtol(string.c_str(), NULL, 10);
-		}
-		else if (!stricmp("Description", tag))
-		{
-			descriptionString = string;
-		}
-		else if (!stricmp("ExpirationDate", tag))
-		{
-			expirationDate = expiryTimeStampToLLDate(string);
-		}
-		else if (!stricmp("Expired", tag))
-		{
-			hasExpired = !stricmp(string.c_str(), "1");
-		}
-		else if (!stricmp("Type", tag))
-		{
-			fontType = strtol(string.c_str(), NULL, 10);
-		}
-		else if (!stricmp("Status", tag))
-		{
-			fontStatus = strtol(string.c_str(), NULL, 10);
-		}
-		else if (!stricmp("MediaCompletionType", tag))
-		{
-			mediaCompletionType = string;;
-		}
-
-		textBuffer.clear();
-		accumulateText= false;
-
-		if (responseDepth == 0)
-		{
-			// We finished all of the XML, process the data
-			processResponse(tag);
-		}
-	}
+    const std::string& string = textBuffer;
+
+    responseDepth--;
+
+    if (ignoringTags)
+    {
+        if (ignoreDepth == responseDepth)
+        {
+            LL_DEBUGS("VivoxProtocolParser") << "end of ignore" << LL_ENDL;
+            ignoringTags = false;
+        }
+        else
+        {
+            LL_DEBUGS("VivoxProtocolParser") << "ignoring tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
+        }
+    }
+
+    if (!ignoringTags)
+    {
+        LL_DEBUGS("VivoxProtocolParser") << "processing tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
+
+        // Closing a tag. Finalize the text we've accumulated and reset
+        if (!stricmp("ReturnCode", tag))
+            returnCode = strtol(string.c_str(), NULL, 10);
+        else if (!stricmp("SessionHandle", tag))
+            sessionHandle = string;
+        else if (!stricmp("SessionGroupHandle", tag))
+            sessionGroupHandle = string;
+        else if (!stricmp("StatusCode", tag))
+            statusCode = strtol(string.c_str(), NULL, 10);
+        else if (!stricmp("StatusString", tag))
+            statusString = string;
+        else if (!stricmp("ParticipantURI", tag))
+            uriString = string;
+        else if (!stricmp("Volume", tag))
+            volume = strtol(string.c_str(), NULL, 10);
+        else if (!stricmp("Energy", tag))
+            energy = (F32)strtod(string.c_str(), NULL);
+        else if (!stricmp("IsModeratorMuted", tag))
+            isModeratorMuted = !stricmp(string.c_str(), "true");
+        else if (!stricmp("IsSpeaking", tag))
+            isSpeaking = !stricmp(string.c_str(), "true");
+        else if (!stricmp("Alias", tag))
+            alias = string;
+        else if (!stricmp("NumberOfAliases", tag))
+            numberOfAliases = strtol(string.c_str(), NULL, 10);
+        else if (!stricmp("Application", tag))
+            applicationString = string;
+        else if (!stricmp("ConnectorHandle", tag))
+            connectorHandle = string;
+        else if (!stricmp("VersionID", tag))
+            versionID = string;
+        else if (!stricmp("Version", tag))
+            mBuildID = string;
+        else if (!stricmp("AccountHandle", tag))
+            accountHandle = string;
+        else if (!stricmp("State", tag))
+            state = strtol(string.c_str(), NULL, 10);
+        else if (!stricmp("URI", tag))
+            uriString = string;
+        else if (!stricmp("IsChannel", tag))
+            isChannel = !stricmp(string.c_str(), "true");
+        else if (!stricmp("Incoming", tag))
+            incoming = !stricmp(string.c_str(), "true");
+        else if (!stricmp("Enabled", tag))
+            enabled = !stricmp(string.c_str(), "true");
+        else if (!stricmp("Name", tag))
+            nameString = string;
+        else if (!stricmp("AudioMedia", tag))
+            audioMediaString = string;
+        else if (!stricmp("ChannelName", tag))
+            nameString = string;
+        else if (!stricmp("DisplayName", tag))
+            displayNameString = string;
+        else if (!stricmp("Device", tag))
+            deviceString = string;
+        else if (!stricmp("AccountName", tag))
+            nameString = string;
+        else if (!stricmp("ParticipantType", tag))
+            participantType = strtol(string.c_str(), NULL, 10);
+        else if (!stricmp("IsLocallyMuted", tag))
+            isLocallyMuted = !stricmp(string.c_str(), "true");
+        else if (!stricmp("MicEnergy", tag))
+            energy = (F32)strtod(string.c_str(), NULL);
+        else if (!stricmp("ChannelName", tag))
+            nameString = string;
+        else if (!stricmp("ChannelURI", tag))
+            uriString = string;
+        else if (!stricmp("BuddyURI", tag))
+            uriString = string;
+        else if (!stricmp("Presence", tag))
+            statusString = string;
+        else if (!stricmp("CaptureDevices", tag))
+        {
+            LLVivoxVoiceClient::getInstance()->setDevicesListUpdated(true);
+        }
+        else if (!stricmp("RenderDevices", tag))
+        {
+            LLVivoxVoiceClient::getInstance()->setDevicesListUpdated(true);
+        }
+        else if (!stricmp("CaptureDevice", tag))
+        {
+            LLVivoxVoiceClient::getInstance()->addCaptureDevice(LLVoiceDevice(displayNameString, deviceString));
+        }
+        else if (!stricmp("RenderDevice", tag))
+        {
+            LLVivoxVoiceClient::getInstance()->addRenderDevice(LLVoiceDevice(displayNameString, deviceString));
+        }
+        else if (!stricmp("BlockMask", tag))
+            blockMask = string;
+        else if (!stricmp("PresenceOnly", tag))
+            presenceOnly = string;
+        else if (!stricmp("AutoAcceptMask", tag))
+            autoAcceptMask = string;
+        else if (!stricmp("AutoAddAsBuddy", tag))
+            autoAddAsBuddy = string;
+        else if (!stricmp("MessageHeader", tag))
+            messageHeader = string;
+        else if (!stricmp("MessageBody", tag))
+            messageBody = string;
+        else if (!stricmp("NotificationType", tag))
+            notificationType = string;
+        else if (!stricmp("HasText", tag))
+            hasText = !stricmp(string.c_str(), "true");
+        else if (!stricmp("HasAudio", tag))
+            hasAudio = !stricmp(string.c_str(), "true");
+        else if (!stricmp("HasVideo", tag))
+            hasVideo = !stricmp(string.c_str(), "true");
+        else if (!stricmp("Terminated", tag))
+            terminated = !stricmp(string.c_str(), "true");
+        else if (!stricmp("SubscriptionHandle", tag))
+            subscriptionHandle = string;
+        else if (!stricmp("SubscriptionType", tag))
+            subscriptionType = string;
+        else if (!stricmp("SessionFont", tag))
+        {
+            LLVivoxVoiceClient::getInstance()->addVoiceFont(id, nameString, descriptionString, expirationDate, hasExpired, fontType, fontStatus, false);
+        }
+        else if (!stricmp("TemplateFont", tag))
+        {
+            LLVivoxVoiceClient::getInstance()->addVoiceFont(id, nameString, descriptionString, expirationDate, hasExpired, fontType, fontStatus, true);
+        }
+        else if (!stricmp("ID", tag))
+        {
+            id = strtol(string.c_str(), NULL, 10);
+        }
+        else if (!stricmp("Description", tag))
+        {
+            descriptionString = string;
+        }
+        else if (!stricmp("ExpirationDate", tag))
+        {
+            expirationDate = expiryTimeStampToLLDate(string);
+        }
+        else if (!stricmp("Expired", tag))
+        {
+            hasExpired = !stricmp(string.c_str(), "1");
+        }
+        else if (!stricmp("Type", tag))
+        {
+            fontType = strtol(string.c_str(), NULL, 10);
+        }
+        else if (!stricmp("Status", tag))
+        {
+            fontStatus = strtol(string.c_str(), NULL, 10);
+        }
+        else if (!stricmp("MediaCompletionType", tag))
+        {
+            mediaCompletionType = string;;
+        }
+
+        textBuffer.clear();
+        accumulateText= false;
+
+        if (responseDepth == 0)
+        {
+            // We finished all of the XML, process the data
+            processResponse(tag);
+        }
+    }
 }
 
 // --------------------------------------------------------------------------------
 
 void LLVivoxProtocolParser::CharData(const char *buffer, int length)
 {
-	/*
-	 This method is called for anything that isn't a tag, which can be text you
-	 want that lies between tags, and a lot of stuff you don't want like file formatting
-	 (tabs, spaces, CR/LF, etc).
+    /*
+     This method is called for anything that isn't a tag, which can be text you
+     want that lies between tags, and a lot of stuff you don't want like file formatting
+     (tabs, spaces, CR/LF, etc).
 
-	 Only copy text if we are in accumulate mode...
-	 */
-	if (accumulateText)
-		textBuffer.append(buffer, length);
+     Only copy text if we are in accumulate mode...
+     */
+    if (accumulateText)
+        textBuffer.append(buffer, length);
 }
 
 // --------------------------------------------------------------------------------
 
 LLDate LLVivoxProtocolParser::expiryTimeStampToLLDate(const std::string& vivox_ts)
 {
-	// *HACK: Vivox reports the time incorrectly. LLDate also only parses a
-	// subset of valid ISO 8601 dates (only handles Z, not offsets).
-	// So just use the date portion and fix the time here.
-	std::string time_stamp = vivox_ts.substr(0, 10);
-	time_stamp += VOICE_FONT_EXPIRY_TIME;
+    // *HACK: Vivox reports the time incorrectly. LLDate also only parses a
+    // subset of valid ISO 8601 dates (only handles Z, not offsets).
+    // So just use the date portion and fix the time here.
+    std::string time_stamp = vivox_ts.substr(0, 10);
+    time_stamp += VOICE_FONT_EXPIRY_TIME;
 
-	LL_DEBUGS("VivoxProtocolParser") << "Vivox timestamp " << vivox_ts << " modified to: " << time_stamp << LL_ENDL;
+    LL_DEBUGS("VivoxProtocolParser") << "Vivox timestamp " << vivox_ts << " modified to: " << time_stamp << LL_ENDL;
 
-	return LLDate(time_stamp);
+    return LLDate(time_stamp);
 }
 
 // --------------------------------------------------------------------------------
 
 void LLVivoxProtocolParser::processResponse(std::string tag)
 {
-	LL_DEBUGS("VivoxProtocolParser") << tag << LL_ENDL;
+    LL_DEBUGS("VivoxProtocolParser") << tag << LL_ENDL;
 
-	// SLIM SDK: the SDK now returns a statusCode of "200" (OK) for success.  This is a change vs. previous SDKs.
-	// According to Mike S., "The actual API convention is that responses with return codes of 0 are successful, regardless of the status code returned",
-	// so I believe this will give correct behavior.
+    // SLIM SDK: the SDK now returns a statusCode of "200" (OK) for success.  This is a change vs. previous SDKs.
+    // According to Mike S., "The actual API convention is that responses with return codes of 0 are successful, regardless of the status code returned",
+    // so I believe this will give correct behavior.
 
-	if(returnCode == 0)
-		statusCode = 0;
+    if(returnCode == 0)
+        statusCode = 0;
 
-	if (isEvent)
-	{
-		const char *eventTypeCstr = eventTypeString.c_str();
+    if (isEvent)
+    {
+        const char *eventTypeCstr = eventTypeString.c_str();
         LL_DEBUGS("LowVoice") << eventTypeCstr << LL_ENDL;
 
-		if (!stricmp(eventTypeCstr, "ParticipantUpdatedEvent"))
-		{
-			// These happen so often that logging them is pretty useless.
+        if (!stricmp(eventTypeCstr, "ParticipantUpdatedEvent"))
+        {
+            // These happen so often that logging them is pretty useless.
             LL_DEBUGS("LowVoice") << "Updated Params: " << sessionHandle << ", " << sessionGroupHandle << ", " << uriString << ", " << alias << ", " << isModeratorMuted << ", " << isSpeaking << ", " << volume << ", " << energy << LL_ENDL;
             LLVivoxVoiceClient::getInstance()->participantUpdatedEvent(sessionHandle, sessionGroupHandle, uriString, alias, isModeratorMuted, isSpeaking, volume, energy);
-		}
-		else if (!stricmp(eventTypeCstr, "AccountLoginStateChangeEvent"))
-		{
-			LLVivoxVoiceClient::getInstance()->accountLoginStateChangeEvent(accountHandle, statusCode, statusString, state);
-		}
-		else if (!stricmp(eventTypeCstr, "SessionAddedEvent"))
-		{
-			/*
-			 <Event type="SessionAddedEvent">
-			 <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
-			 <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
-			 <Uri>sip:confctl-1408789@bhr.vivox.com</Uri>
-			 <IsChannel>true</IsChannel>
-			 <Incoming>false</Incoming>
-			 <ChannelName />
-			 </Event>
-			 */
-			LLVivoxVoiceClient::getInstance()->sessionAddedEvent(uriString, alias, sessionHandle, sessionGroupHandle, isChannel, incoming, nameString, applicationString);
-		}
-		else if (!stricmp(eventTypeCstr, "SessionRemovedEvent"))
-		{
-			LLVivoxVoiceClient::getInstance()->sessionRemovedEvent(sessionHandle, sessionGroupHandle);
-		}
-		else if (!stricmp(eventTypeCstr, "SessionGroupUpdatedEvent"))
-		{
-			//nothng useful to process for this event, but we should not WARN that we have received it.
-		}
-		else if (!stricmp(eventTypeCstr, "SessionGroupAddedEvent"))
-		{
-			LLVivoxVoiceClient::getInstance()->sessionGroupAddedEvent(sessionGroupHandle);
-		}
-		else if (!stricmp(eventTypeCstr, "MediaStreamUpdatedEvent"))
-		{
-			/*
-			 <Event type="MediaStreamUpdatedEvent">
-			 <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
-			 <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
-			 <StatusCode>200</StatusCode>
-			 <StatusString>OK</StatusString>
-			 <State>2</State>
-			 <Incoming>false</Incoming>
-			 </Event>
-			 */
-			LLVivoxVoiceClient::getInstance()->mediaStreamUpdatedEvent(sessionHandle, sessionGroupHandle, statusCode, statusString, state, incoming);
-		}
-		else if (!stricmp(eventTypeCstr, "MediaCompletionEvent"))
-		{
-			/*
-			<Event type="MediaCompletionEvent">
-			<SessionGroupHandle />
-			<MediaCompletionType>AuxBufferAudioCapture</MediaCompletionType>
-			</Event>
-			*/
-			LLVivoxVoiceClient::getInstance()->mediaCompletionEvent(sessionGroupHandle, mediaCompletionType);
-		}
-		else if (!stricmp(eventTypeCstr, "ParticipantAddedEvent"))
-		{
-			/*
-			 <Event type="ParticipantAddedEvent">
-			 <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg4</SessionGroupHandle>
-			 <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==4</SessionHandle>
-			 <ParticipantUri>sip:xI5auBZ60SJWIk606-1JGRQ==@bhr.vivox.com</ParticipantUri>
-			 <AccountName>xI5auBZ60SJWIk606-1JGRQ==</AccountName>
-			 <DisplayName />
-			 <ParticipantType>0</ParticipantType>
-			 </Event>
-			 */
+        }
+        else if (!stricmp(eventTypeCstr, "AccountLoginStateChangeEvent"))
+        {
+            LLVivoxVoiceClient::getInstance()->accountLoginStateChangeEvent(accountHandle, statusCode, statusString, state);
+        }
+        else if (!stricmp(eventTypeCstr, "SessionAddedEvent"))
+        {
+            /*
+             <Event type="SessionAddedEvent">
+             <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
+             <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
+             <Uri>sip:confctl-1408789@bhr.vivox.com</Uri>
+             <IsChannel>true</IsChannel>
+             <Incoming>false</Incoming>
+             <ChannelName />
+             </Event>
+             */
+            LLVivoxVoiceClient::getInstance()->sessionAddedEvent(uriString, alias, sessionHandle, sessionGroupHandle, isChannel, incoming, nameString, applicationString);
+        }
+        else if (!stricmp(eventTypeCstr, "SessionRemovedEvent"))
+        {
+            LLVivoxVoiceClient::getInstance()->sessionRemovedEvent(sessionHandle, sessionGroupHandle);
+        }
+        else if (!stricmp(eventTypeCstr, "SessionGroupUpdatedEvent"))
+        {
+            //nothng useful to process for this event, but we should not WARN that we have received it.
+        }
+        else if (!stricmp(eventTypeCstr, "SessionGroupAddedEvent"))
+        {
+            LLVivoxVoiceClient::getInstance()->sessionGroupAddedEvent(sessionGroupHandle);
+        }
+        else if (!stricmp(eventTypeCstr, "MediaStreamUpdatedEvent"))
+        {
+            /*
+             <Event type="MediaStreamUpdatedEvent">
+             <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
+             <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
+             <StatusCode>200</StatusCode>
+             <StatusString>OK</StatusString>
+             <State>2</State>
+             <Incoming>false</Incoming>
+             </Event>
+             */
+            LLVivoxVoiceClient::getInstance()->mediaStreamUpdatedEvent(sessionHandle, sessionGroupHandle, statusCode, statusString, state, incoming);
+        }
+        else if (!stricmp(eventTypeCstr, "MediaCompletionEvent"))
+        {
+            /*
+            <Event type="MediaCompletionEvent">
+            <SessionGroupHandle />
+            <MediaCompletionType>AuxBufferAudioCapture</MediaCompletionType>
+            </Event>
+            */
+            LLVivoxVoiceClient::getInstance()->mediaCompletionEvent(sessionGroupHandle, mediaCompletionType);
+        }
+        else if (!stricmp(eventTypeCstr, "ParticipantAddedEvent"))
+        {
+            /*
+             <Event type="ParticipantAddedEvent">
+             <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg4</SessionGroupHandle>
+             <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==4</SessionHandle>
+             <ParticipantUri>sip:xI5auBZ60SJWIk606-1JGRQ==@bhr.vivox.com</ParticipantUri>
+             <AccountName>xI5auBZ60SJWIk606-1JGRQ==</AccountName>
+             <DisplayName />
+             <ParticipantType>0</ParticipantType>
+             </Event>
+             */
             LL_DEBUGS("LowVoice") << "Added Params: " << sessionHandle << ", " << sessionGroupHandle << ", " << uriString << ", " << alias << ", " << nameString << ", " << displayNameString << ", " << participantType << LL_ENDL;
-			LLVivoxVoiceClient::getInstance()->participantAddedEvent(sessionHandle, sessionGroupHandle, uriString, alias, nameString, displayNameString, participantType);
-		}
-		else if (!stricmp(eventTypeCstr, "ParticipantRemovedEvent"))
-		{
-			/*
-			 <Event type="ParticipantRemovedEvent">
-			 <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg4</SessionGroupHandle>
-			 <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==4</SessionHandle>
-			 <ParticipantUri>sip:xtx7YNV-3SGiG7rA1fo5Ndw==@bhr.vivox.com</ParticipantUri>
-			 <AccountName>xtx7YNV-3SGiG7rA1fo5Ndw==</AccountName>
-			 </Event>
-			 */
+            LLVivoxVoiceClient::getInstance()->participantAddedEvent(sessionHandle, sessionGroupHandle, uriString, alias, nameString, displayNameString, participantType);
+        }
+        else if (!stricmp(eventTypeCstr, "ParticipantRemovedEvent"))
+        {
+            /*
+             <Event type="ParticipantRemovedEvent">
+             <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg4</SessionGroupHandle>
+             <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==4</SessionHandle>
+             <ParticipantUri>sip:xtx7YNV-3SGiG7rA1fo5Ndw==@bhr.vivox.com</ParticipantUri>
+             <AccountName>xtx7YNV-3SGiG7rA1fo5Ndw==</AccountName>
+             </Event>
+             */
             LL_DEBUGS("LowVoice") << "Removed params:" << sessionHandle << ", " << sessionGroupHandle << ", " << uriString << ", " << alias << ", " << nameString << LL_ENDL;
 
-			LLVivoxVoiceClient::getInstance()->participantRemovedEvent(sessionHandle, sessionGroupHandle, uriString, alias, nameString);
-		}
-		else if (!stricmp(eventTypeCstr, "AuxAudioPropertiesEvent"))
-		{
-			// These are really spammy in tuning mode
-			LLVivoxVoiceClient::getInstance()->auxAudioPropertiesEvent(energy);
-		}
-		else if (!stricmp(eventTypeCstr, "MessageEvent"))
-		{
-			//TODO:  This probably is not received any more, it was used to support SLim clients
-			LLVivoxVoiceClient::getInstance()->messageEvent(sessionHandle, uriString, alias, messageHeader, messageBody, applicationString);
-		}
-		else if (!stricmp(eventTypeCstr, "SessionNotificationEvent"))
-		{
-			//TODO:  This probably is not received any more, it was used to support SLim clients
-			LLVivoxVoiceClient::getInstance()->sessionNotificationEvent(sessionHandle, uriString, notificationType);
-		}
-		else if (!stricmp(eventTypeCstr, "SessionUpdatedEvent"))
-		{
-			/*
-			 <Event type="SessionUpdatedEvent">
-			 <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
-			 <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
-			 <Uri>sip:confctl-9@bhd.vivox.com</Uri>
-			 <IsMuted>0</IsMuted>
-			 <Volume>50</Volume>
-			 <TransmitEnabled>1</TransmitEnabled>
-			 <IsFocused>0</IsFocused>
-			 <SpeakerPosition><Position><X>0</X><Y>0</Y><Z>0</Z></Position></SpeakerPosition>
-			 <SessionFontID>0</SessionFontID>
-			 </Event>
-			 */
-			// We don't need to process this, but we also shouldn't warn on it, since that confuses people.
-		}
-		else if (!stricmp(eventTypeCstr, "SessionGroupRemovedEvent"))
-		{
-			// We don't need to process this, but we also shouldn't warn on it, since that confuses people.
-		}
-		else if (!stricmp(eventTypeCstr, "VoiceServiceConnectionStateChangedEvent"))
-		{
-			LLVivoxVoiceClient::getInstance()->voiceServiceConnectionStateChangedEvent(statusCode, statusString, mBuildID);
-		}
-		else if (!stricmp(eventTypeCstr, "AudioDeviceHotSwapEvent"))
-		{
-			/*
-			<Event type = "AudioDeviceHotSwapEvent">
-			<EventType>RenderDeviceChanged< / EventType>
-			<RelevantDevice>
-			<Device>Speakers(Turtle Beach P11 Headset)< / Device>
-			<DisplayName>Speakers(Turtle Beach P11 Headset)< / DisplayName>
-			<Type>SpecificDevice< / Type>
-			< / RelevantDevice>
-			< / Event>
-			*/
-			// an audio device was removed or added, fetch and update the local list of audio devices.
-			LLVivoxVoiceClient::getInstance()->getCaptureDevicesSendMessage();
-			LLVivoxVoiceClient::getInstance()->getRenderDevicesSendMessage();
-		}
-		else
-		{
-			LL_WARNS("VivoxProtocolParser") << "Unknown event type " << eventTypeString << LL_ENDL;
-		}
-	}
-	else
-	{
-		const char *actionCstr = actionString.c_str();
+            LLVivoxVoiceClient::getInstance()->participantRemovedEvent(sessionHandle, sessionGroupHandle, uriString, alias, nameString);
+        }
+        else if (!stricmp(eventTypeCstr, "AuxAudioPropertiesEvent"))
+        {
+            // These are really spammy in tuning mode
+            LLVivoxVoiceClient::getInstance()->auxAudioPropertiesEvent(energy);
+        }
+        else if (!stricmp(eventTypeCstr, "MessageEvent"))
+        {
+            //TODO:  This probably is not received any more, it was used to support SLim clients
+            LLVivoxVoiceClient::getInstance()->messageEvent(sessionHandle, uriString, alias, messageHeader, messageBody, applicationString);
+        }
+        else if (!stricmp(eventTypeCstr, "SessionNotificationEvent"))
+        {
+            //TODO:  This probably is not received any more, it was used to support SLim clients
+            LLVivoxVoiceClient::getInstance()->sessionNotificationEvent(sessionHandle, uriString, notificationType);
+        }
+        else if (!stricmp(eventTypeCstr, "SessionUpdatedEvent"))
+        {
+            /*
+             <Event type="SessionUpdatedEvent">
+             <SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
+             <SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
+             <Uri>sip:confctl-9@bhd.vivox.com</Uri>
+             <IsMuted>0</IsMuted>
+             <Volume>50</Volume>
+             <TransmitEnabled>1</TransmitEnabled>
+             <IsFocused>0</IsFocused>
+             <SpeakerPosition><Position><X>0</X><Y>0</Y><Z>0</Z></Position></SpeakerPosition>
+             <SessionFontID>0</SessionFontID>
+             </Event>
+             */
+            // We don't need to process this, but we also shouldn't warn on it, since that confuses people.
+        }
+        else if (!stricmp(eventTypeCstr, "SessionGroupRemovedEvent"))
+        {
+            // We don't need to process this, but we also shouldn't warn on it, since that confuses people.
+        }
+        else if (!stricmp(eventTypeCstr, "VoiceServiceConnectionStateChangedEvent"))
+        {
+            LLVivoxVoiceClient::getInstance()->voiceServiceConnectionStateChangedEvent(statusCode, statusString, mBuildID);
+        }
+        else if (!stricmp(eventTypeCstr, "AudioDeviceHotSwapEvent"))
+        {
+            /*
+            <Event type = "AudioDeviceHotSwapEvent">
+            <EventType>RenderDeviceChanged< / EventType>
+            <RelevantDevice>
+            <Device>Speakers(Turtle Beach P11 Headset)< / Device>
+            <DisplayName>Speakers(Turtle Beach P11 Headset)< / DisplayName>
+            <Type>SpecificDevice< / Type>
+            < / RelevantDevice>
+            < / Event>
+            */
+            // an audio device was removed or added, fetch and update the local list of audio devices.
+            LLVivoxVoiceClient::getInstance()->getCaptureDevicesSendMessage();
+            LLVivoxVoiceClient::getInstance()->getRenderDevicesSendMessage();
+        }
+        else
+        {
+            LL_WARNS("VivoxProtocolParser") << "Unknown event type " << eventTypeString << LL_ENDL;
+        }
+    }
+    else
+    {
+        const char *actionCstr = actionString.c_str();
         LL_DEBUGS("LowVoice") << actionCstr << LL_ENDL;
 
-		if (!stricmp(actionCstr, "Session.Set3DPosition.1"))
-		{
-			// We don't need to process these
-		}
-		else if (!stricmp(actionCstr, "Connector.Create.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->connectorCreateResponse(statusCode, statusString, connectorHandle, versionID);
-		}
-		else if (!stricmp(actionCstr, "Account.Login.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->loginResponse(statusCode, statusString, accountHandle, numberOfAliases);
-		}
-		else if (!stricmp(actionCstr, "Session.Create.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->sessionCreateResponse(requestId, statusCode, statusString, sessionHandle);
-		}
-		else if (!stricmp(actionCstr, "SessionGroup.AddSession.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->sessionGroupAddSessionResponse(requestId, statusCode, statusString, sessionHandle);
-		}
-		else if (!stricmp(actionCstr, "Session.Connect.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->sessionConnectResponse(requestId, statusCode, statusString);
-		}
-		else if (!stricmp(actionCstr, "Account.Logout.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->logoutResponse(statusCode, statusString);
-		}
-		else if (!stricmp(actionCstr, "Connector.InitiateShutdown.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->connectorShutdownResponse(statusCode, statusString);
-		}
-		else if (!stricmp(actionCstr, "Account.GetSessionFonts.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->accountGetSessionFontsResponse(statusCode, statusString);
-		}
-		else if (!stricmp(actionCstr, "Account.GetTemplateFonts.1"))
-		{
-			LLVivoxVoiceClient::getInstance()->accountGetTemplateFontsResponse(statusCode, statusString);
-		}
-		else if (!stricmp(actionCstr, "Aux.SetVadProperties.1"))
-		{
-			// both values of statusCode (old and more recent) indicate valid requests
-			if (statusCode != 0 && statusCode != 200)
-			{
-				LL_WARNS("Voice") << "Aux.SetVadProperties.1 request failed: "
-					<< "statusCode: " << statusCode
-					<< " and "
-					<< "statusString: " << statusString
-					<< LL_ENDL;
-			}
-		}
-		/*
-		 else if (!stricmp(actionCstr, "Account.ChannelGetList.1"))
-		 {
-		 LLVoiceClient::getInstance()->channelGetListResponse(statusCode, statusString);
-		 }
-		 else if (!stricmp(actionCstr, "Connector.AccountCreate.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Connector.MuteLocalMic.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Connector.MuteLocalSpeaker.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Connector.SetLocalMicVolume.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Connector.SetLocalSpeakerVolume.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Session.ListenerSetPosition.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Session.SpeakerSetPosition.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Session.AudioSourceSetPosition.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Session.GetChannelParticipants.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelCreate.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelUpdate.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelDelete.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelCreateAndInvite.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelFolderCreate.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelFolderUpdate.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelFolderDelete.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelAddModerator.1"))
-		 {
-
-		 }
-		 else if (!stricmp(actionCstr, "Account.ChannelDeleteModerator.1"))
-		 {
-
-		 }
-		 */
-	}
+        if (!stricmp(actionCstr, "Session.Set3DPosition.1"))
+        {
+            // We don't need to process these
+        }
+        else if (!stricmp(actionCstr, "Connector.Create.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->connectorCreateResponse(statusCode, statusString, connectorHandle, versionID);
+        }
+        else if (!stricmp(actionCstr, "Account.Login.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->loginResponse(statusCode, statusString, accountHandle, numberOfAliases);
+        }
+        else if (!stricmp(actionCstr, "Session.Create.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->sessionCreateResponse(requestId, statusCode, statusString, sessionHandle);
+        }
+        else if (!stricmp(actionCstr, "SessionGroup.AddSession.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->sessionGroupAddSessionResponse(requestId, statusCode, statusString, sessionHandle);
+        }
+        else if (!stricmp(actionCstr, "Session.Connect.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->sessionConnectResponse(requestId, statusCode, statusString);
+        }
+        else if (!stricmp(actionCstr, "Account.Logout.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->logoutResponse(statusCode, statusString);
+        }
+        else if (!stricmp(actionCstr, "Connector.InitiateShutdown.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->connectorShutdownResponse(statusCode, statusString);
+        }
+        else if (!stricmp(actionCstr, "Account.GetSessionFonts.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->accountGetSessionFontsResponse(statusCode, statusString);
+        }
+        else if (!stricmp(actionCstr, "Account.GetTemplateFonts.1"))
+        {
+            LLVivoxVoiceClient::getInstance()->accountGetTemplateFontsResponse(statusCode, statusString);
+        }
+        else if (!stricmp(actionCstr, "Aux.SetVadProperties.1"))
+        {
+            // both values of statusCode (old and more recent) indicate valid requests
+            if (statusCode != 0 && statusCode != 200)
+            {
+                LL_WARNS("Voice") << "Aux.SetVadProperties.1 request failed: "
+                    << "statusCode: " << statusCode
+                    << " and "
+                    << "statusString: " << statusString
+                    << LL_ENDL;
+            }
+        }
+        /*
+         else if (!stricmp(actionCstr, "Account.ChannelGetList.1"))
+         {
+         LLVoiceClient::getInstance()->channelGetListResponse(statusCode, statusString);
+         }
+         else if (!stricmp(actionCstr, "Connector.AccountCreate.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Connector.MuteLocalMic.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Connector.MuteLocalSpeaker.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Connector.SetLocalMicVolume.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Connector.SetLocalSpeakerVolume.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Session.ListenerSetPosition.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Session.SpeakerSetPosition.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Session.AudioSourceSetPosition.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Session.GetChannelParticipants.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelCreate.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelUpdate.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelDelete.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelCreateAndInvite.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelFolderCreate.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelFolderUpdate.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelFolderDelete.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelAddModerator.1"))
+         {
+
+         }
+         else if (!stricmp(actionCstr, "Account.ChannelDeleteModerator.1"))
+         {
+
+         }
+         */
+    }
 }
 
 LLVivoxSecurity::LLVivoxSecurity()