1HEADmaster

1 files changed, 1566 insertions, 0 deletions

diff --git a/engine/audio/private/voice.cpp b/engine/audio/private/voice.cpp
new file mode 100644
index 0000000..ce506d1
--- /dev/null
+++ b/engine/audio/private/voice.cpp
@@ -0,0 +1,1566 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "audio_pch.h"
+#include "circularbuffer.h"
+#include "voice.h"
+#include "voice_wavefile.h"
+#include "r_efx.h"
+#include "cdll_int.h"
+#include "voice_gain.h"
+#include "voice_mixer_controls.h"
+
+#include "ivoicerecord.h"
+#include "ivoicecodec.h"
+#include "filesystem.h"
+#include "../../filesystem_engine.h"
+#include "tier1/utlbuffer.h"
+#if defined( _X360 )
+#include "xauddefs.h"
+#endif
+
+#include "steam/steam_api.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static CSteamAPIContext g_SteamAPIContext;
+static CSteamAPIContext *steamapicontext = NULL;
+
+void Voice_EndChannel( int iChannel );
+void VoiceTweak_EndVoiceTweakMode();
+void EngineTool_OverrideSampleRate( int& rate );
+
+// A fallback codec that should be the most likely to work for local/offline use
+#define VOICE_FALLBACK_CODEC	"vaudio_celt"
+
+// Special entity index used for tweak mode.
+#define TWEAKMODE_ENTITYINDEX				-500
+
+// Special channel index passed to Voice_AddIncomingData when in tweak mode.
+#define TWEAKMODE_CHANNELINDEX				-100
+
+
+// How long does the sign stay above someone's head when they talk?
+#define SPARK_TIME		0.2
+
+// How long a voice channel has to be inactive before we free it.
+#define DIE_COUNTDOWN	0.5
+
+#define VOICE_RECEIVE_BUFFER_SIZE			(VOICE_OUTPUT_SAMPLE_RATE_MAX * BYTES_PER_SAMPLE)
+
+#define LOCALPLAYERTALKING_TIMEOUT			0.2f	// How long it takes for the client to decide the server isn't sending acks
+													// of voice data back.
+
+// If this is defined, then the data is converted to 8-bit and sent otherwise uncompressed.
+// #define VOICE_SEND_RAW_TEST
+
+// The format we sample voice in.
+WAVEFORMATEX g_VoiceSampleFormat =
+{
+	WAVE_FORMAT_PCM,		// wFormatTag
+	1,						// nChannels
+	// These two can be dynamically changed by voice_init
+	VOICE_OUTPUT_SAMPLE_RATE_LOW,				// nSamplesPerSec
+	VOICE_OUTPUT_SAMPLE_RATE_LOW*2,				// nAvgBytesPerSec
+	2,						// nBlockAlign
+	16,						// wBitsPerSample
+	sizeof(WAVEFORMATEX)	// cbSize
+};
+
+static bool Voice_SetSampleRate( DWORD rate )
+{
+	if ( g_VoiceSampleFormat.nSamplesPerSec != rate ||
+	     g_VoiceSampleFormat.nAvgBytesPerSec != rate * 2 )
+	{
+		g_VoiceSampleFormat.nSamplesPerSec = rate;
+		g_VoiceSampleFormat.nAvgBytesPerSec = rate * 2;
+		return true;
+	}
+
+	return false;
+}
+
+int Voice_SamplesPerSec()
+{
+	int rate = g_VoiceSampleFormat.nSamplesPerSec;
+	EngineTool_OverrideSampleRate( rate );
+	return rate;
+}
+
+int Voice_AvgBytesPerSec()
+{
+	int rate = g_VoiceSampleFormat.nSamplesPerSec;
+	EngineTool_OverrideSampleRate( rate );
+	return ( rate * g_VoiceSampleFormat.wBitsPerSample ) >> 3;
+}
+
+ConVar voice_avggain( "voice_avggain", "0.5" );
+ConVar voice_maxgain( "voice_maxgain", "10" );
+ConVar voice_scale( "voice_scale", "1", FCVAR_ARCHIVE );
+
+ConVar voice_loopback( "voice_loopback", "0", FCVAR_USERINFO );
+ConVar voice_fadeouttime( "voice_fadeouttime", "0.1" );	// It fades to no sound at the tail end of your voice data when you release the key.
+
+// Debugging cvars.
+ConVar voice_profile( "voice_profile", "0" );
+ConVar voice_showchannels( "voice_showchannels", "0" );	// 1 = list channels
+															// 2 = show timing info, etc
+ConVar voice_showincoming( "voice_showincoming", "0" );	// show incoming voice data
+
+ConVar voice_enable( "voice_enable", "1", FCVAR_ARCHIVE );		// Globally enable or disable voice.
+#ifdef VOICE_VOX_ENABLE
+ConVar voice_threshold( "voice_threshold", "2000", FCVAR_ARCHIVE );
+#endif // VOICE_VOX_ENABLE
+
+// Have it force your mixer control settings so waveIn comes from the microphone. 
+// CD rippers change your waveIn to come from the CD drive
+ConVar voice_forcemicrecord( "voice_forcemicrecord", "1", FCVAR_ARCHIVE );
+
+// This should not be lower than the maximum difference between clients' frame durations (due to cmdrate/updaterate),
+// plus some jitter allowance.
+ConVar voice_buffer_ms( "voice_buffer_ms", "100", FCVAR_INTERNAL_USE,
+                        "How many milliseconds of voice to buffer to avoid dropouts due to jitter and frame time differences." );
+
+int g_nVoiceFadeSamples		= 1;							// Calculated each frame from the cvar.
+float g_VoiceFadeMul		= 1;							// 1 / (g_nVoiceFadeSamples - 1).
+
+// While in tweak mode, you can't hear anything anyone else is saying, and your own voice data
+// goes directly to the speakers.
+bool g_bInTweakMode = false;
+int g_VoiceTweakSpeakingVolume = 0;
+
+bool g_bVoiceAtLeastPartiallyInitted = false;
+
+// The codec and sample rate passed to Voice_Init. "" and -1 if voice is not initialized
+char g_szVoiceCodec[_MAX_PATH] = { 0 };
+int g_nVoiceRequestedSampleRate = -1;
+
+const char *Voice_ConfiguredCodec() { return g_szVoiceCodec; }
+int Voice_ConfiguredSampleRate() { return g_nVoiceRequestedSampleRate; }
+
+// Timing info for each frame.
+static double	g_CompressTime = 0;
+static double	g_DecompressTime = 0;
+static double	g_GainTime = 0;
+static double	g_UpsampleTime = 0;
+
+class CVoiceTimer
+{
+public:
+	inline void		Start()
+	{
+		if( voice_profile.GetInt() )
+		{
+			m_StartTime = Plat_FloatTime();
+		}
+	}
+	
+	inline void		End(double *out)
+	{
+		if( voice_profile.GetInt() )
+		{
+			*out += Plat_FloatTime() - m_StartTime;
+		}
+	}
+
+	double			m_StartTime;
+};
+
+
+static bool		g_bLocalPlayerTalkingAck = false;
+static float	g_LocalPlayerTalkingTimeout = 0;
+
+
+CSysModule *g_hVoiceCodecDLL = 0;
+
+// Voice recorder. Can be waveIn, DSound, or whatever.
+static IVoiceRecord *g_pVoiceRecord = NULL;
+static IVoiceCodec  *g_pEncodeCodec = NULL;
+
+static bool			g_bVoiceRecording = false;	// Are we recording at the moment?
+static bool			g_bVoiceRecordStopping = false;	// Are we waiting to stop?
+bool				g_bUsingSteamVoice = false;
+
+#ifdef WIN32
+extern IVoiceRecord* CreateVoiceRecord_DSound(int nSamplesPerSec);
+#elif defined( OSX )
+extern IVoiceRecord* CreateVoiceRecord_AudioQueue(int sampleRate);
+#endif
+
+#ifdef POSIX
+extern IVoiceRecord* CreateVoiceRecord_OpenAL(int sampleRate);
+#endif
+
+
+static bool VoiceRecord_Start()
+{
+	if ( g_bUsingSteamVoice )
+	{
+		if ( steamapicontext && steamapicontext->SteamUser() )
+		{
+			steamapicontext->SteamUser()->StartVoiceRecording();
+			return true;
+		}
+	}
+	else if ( g_pVoiceRecord )
+	{
+		return g_pVoiceRecord->RecordStart();
+	}
+	return false;
+}
+
+static void VoiceRecord_Stop()
+{
+	if ( g_bUsingSteamVoice )
+	{
+		if ( steamapicontext && steamapicontext->SteamUser() )
+		{
+			steamapicontext->SteamUser()->StopVoiceRecording();
+		}
+	}
+	else if ( g_pVoiceRecord )
+	{
+		return g_pVoiceRecord->RecordStop();
+	}
+}
+
+//
+// Used for storing incoming voice data from an entity.
+//
+class CVoiceChannel
+{
+public:
+									CVoiceChannel();
+
+	// Called when someone speaks and a new voice channel is setup to hold the data.
+	void							Init(int nEntity);
+
+public:
+	int								m_iEntity;		// Number of the entity speaking on this channel (index into cl_entities).
+													// This is -1 when the channel is unused.
+
+	
+	CSizedCircularBuffer
+		<VOICE_RECEIVE_BUFFER_SIZE>	m_Buffer;		// Circular buffer containing the voice data.
+
+	// Used for upsampling..
+	double							m_LastFraction;	// Fraction between m_LastSample and the next sample.
+	short							m_LastSample;
+	
+	bool							m_bStarved;		// Set to true when the channel runs out of data for the mixer.
+													// The channel is killed at that point.
+
+	float							m_TimePad;		// Set to TIME_PADDING when the first voice packet comes in from a sender.
+													// We add time padding (for frametime differences)
+													// by waiting a certain amount of time before starting to output the sound.
+
+	IVoiceCodec						*m_pVoiceCodec;	// Each channel gets is own IVoiceCodec instance so the codec can maintain state.
+
+	CAutoGain						m_AutoGain;		// Gain we're applying to this channel
+
+	CVoiceChannel					*m_pNext;
+	
+	bool							m_bProximity;
+	int								m_nViewEntityIndex;
+	int								m_nSoundGuid;
+};
+
+
+CVoiceChannel::CVoiceChannel()
+{
+	m_iEntity = -1;
+	m_pVoiceCodec = NULL;
+	m_nViewEntityIndex = -1;
+	m_nSoundGuid = -1;
+}
+
+void CVoiceChannel::Init(int nEntity)
+{
+	m_iEntity = nEntity;
+	m_bStarved = false;
+	m_Buffer.Flush();
+	m_TimePad = Clamp( voice_buffer_ms.GetFloat(), 1.f, 5000.f ) / 1000.f;
+	m_LastSample = 0;
+	m_LastFraction = 0.999;
+
+	m_AutoGain.Reset( 128, voice_maxgain.GetFloat(), voice_avggain.GetFloat(), voice_scale.GetFloat() );
+}
+
+
+
+// Incoming voice channels.
+CVoiceChannel g_VoiceChannels[VOICE_NUM_CHANNELS];
+
+
+// These are used for recording the wave data into files for debugging.
+#define MAX_WAVEFILEDATA_LEN	1024*1024
+char *g_pUncompressedFileData = NULL;
+int g_nUncompressedDataBytes = 0;
+const char *g_pUncompressedDataFilename = NULL;
+
+char *g_pDecompressedFileData = NULL;
+int g_nDecompressedDataBytes = 0;
+const char *g_pDecompressedDataFilename = NULL;
+
+char *g_pMicInputFileData = NULL;
+int g_nMicInputFileBytes = 0;
+int g_CurMicInputFileByte = 0;
+double g_MicStartTime;
+
+static ConVar voice_writevoices( "voice_writevoices", "0", 0, "Saves each speaker's voice data into separate .wav files\n" );
+class CVoiceWriterData
+{
+public:
+	CVoiceWriterData() :
+		m_pChannel( NULL ),
+		m_nCount( 0 ),
+		m_Buffer()
+	{
+	}
+
+	// Copy ctor is needed to insert into CVoiceWriter's CUtlRBTree.
+	CVoiceWriterData(const CVoiceWriterData& other) :
+		m_pChannel( other.m_pChannel ),
+		m_nCount( other.m_nCount ),
+		m_Buffer( )
+	{
+		m_Buffer.CopyBuffer( other.m_Buffer );
+	}
+
+	static bool Less( const CVoiceWriterData &lhs, const CVoiceWriterData &rhs )
+	{
+		return lhs.m_pChannel < rhs.m_pChannel;
+	}
+
+	CVoiceChannel	*m_pChannel;
+	int				m_nCount;
+	CUtlBuffer		m_Buffer;
+
+private:
+	CVoiceWriterData& operator=(const CVoiceWriterData&);
+};
+
+class CVoiceWriter
+{
+public:
+	CVoiceWriter() :
+		m_VoiceWriter( 0, 0, CVoiceWriterData::Less )
+	{
+	}
+
+	void Flush()
+	{
+		for ( int i = m_VoiceWriter.FirstInorder(); i != m_VoiceWriter.InvalidIndex(); i = m_VoiceWriter.NextInorder( i ) )
+		{
+			CVoiceWriterData *data = &m_VoiceWriter[ i ];
+
+			if ( data->m_Buffer.TellPut() <= 0 )
+				continue;
+			data->m_Buffer.Purge();
+		}
+	}
+
+	void Finish()
+	{
+		if ( !g_pSoundServices->IsConnected() )
+		{
+			Flush();
+			return;
+		}
+
+		for ( int i = m_VoiceWriter.FirstInorder(); i != m_VoiceWriter.InvalidIndex(); i = m_VoiceWriter.NextInorder( i ) )
+		{
+			CVoiceWriterData *data = &m_VoiceWriter[ i ];
+			
+			if ( data->m_Buffer.TellPut() <= 0 )
+				continue;
+
+			int index = data->m_pChannel - g_VoiceChannels;
+			Assert( index >= 0 && index < (int)ARRAYSIZE( g_VoiceChannels ) );
+
+			char path[ MAX_PATH ];
+			Q_snprintf( path, sizeof( path ), "%s/voice", g_pSoundServices->GetGameDir() );
+			g_pFileSystem->CreateDirHierarchy( path );
+
+			char fn[ MAX_PATH ];
+			Q_snprintf( fn, sizeof( fn ), "%s/pl%02d_slot%d-time%d.wav", path, index, data->m_nCount, (int)g_pSoundServices->GetClientTime() );
+
+			WriteWaveFile( fn, (const char *)data->m_Buffer.Base(), data->m_Buffer.TellPut(), g_VoiceSampleFormat.wBitsPerSample, g_VoiceSampleFormat.nChannels, Voice_SamplesPerSec() );
+
+			Msg( "Writing file %s\n", fn );
+
+			++data->m_nCount;
+			data->m_Buffer.Purge();
+		}
+	}
+
+
+	void AddDecompressedData( CVoiceChannel *ch, const byte *data, size_t datalen )
+	{
+		if ( !voice_writevoices.GetBool() )
+			return;
+
+		CVoiceWriterData search;
+		search.m_pChannel = ch;
+		int idx = m_VoiceWriter.Find( search ); 
+		if ( idx == m_VoiceWriter.InvalidIndex() )
+		{
+			idx = m_VoiceWriter.Insert( search );
+		}
+
+		CVoiceWriterData *slot = &m_VoiceWriter[ idx ];
+		slot->m_Buffer.Put( data, datalen );
+	}
+private:
+
+	CUtlRBTree< CVoiceWriterData > m_VoiceWriter;
+};
+
+static CVoiceWriter g_VoiceWriter;
+
+inline void ApplyFadeToSamples(short *pSamples, int nSamples, int fadeOffset, float fadeMul)
+{
+	for(int i=0; i < nSamples; i++)
+	{
+		float percent = (i+fadeOffset) * fadeMul;
+		pSamples[i] = (short)(pSamples[i] * (1 - percent));
+	}
+}
+
+
+bool Voice_Enabled( void )
+{
+	return voice_enable.GetBool();
+}
+
+
+int Voice_GetOutputData(
+	const int iChannel,			//! The voice channel it wants samples from.
+	char *copyBufBytes,			//! The buffer to copy the samples into.
+	const int copyBufSize,		//! Maximum size of copyBuf.
+	const int samplePosition,	//! Which sample to start at.
+	const int sampleCount		//! How many samples to get.
+)
+{
+	CVoiceChannel *pChannel = &g_VoiceChannels[iChannel];	
+	short *pCopyBuf = (short*)copyBufBytes;
+
+
+	int maxOutSamples = copyBufSize / BYTES_PER_SAMPLE;
+
+	// Find out how much we want and get it from the received data channel.	
+	CCircularBuffer *pBuffer = &pChannel->m_Buffer;
+	int nBytesToRead = pBuffer->GetReadAvailable();
+	nBytesToRead = min(min(nBytesToRead, (int)maxOutSamples), sampleCount * BYTES_PER_SAMPLE);
+	int nSamplesGotten = pBuffer->Read(pCopyBuf, nBytesToRead) / BYTES_PER_SAMPLE;
+
+	// Are we at the end of the buffer's data? If so, fade data to silence so it doesn't clip.
+	int readSamplesAvail = pBuffer->GetReadAvailable() / BYTES_PER_SAMPLE;
+	if(readSamplesAvail < g_nVoiceFadeSamples)
+	{
+		int bufferFadeOffset = max((readSamplesAvail + nSamplesGotten) - g_nVoiceFadeSamples, 0);
+		int globalFadeOffset = max(g_nVoiceFadeSamples - (readSamplesAvail + nSamplesGotten), 0);
+		
+		ApplyFadeToSamples(
+			&pCopyBuf[bufferFadeOffset], 
+			nSamplesGotten - bufferFadeOffset,
+			globalFadeOffset,
+			g_VoiceFadeMul);
+	}
+	
+	// If there weren't enough samples in the received data channel, 
+	//   pad it with a copy of the most recent data, and if there 
+	//   isn't any, then use zeros.
+	if ( nSamplesGotten < sampleCount )
+	{
+		int wantedSampleCount = min( sampleCount, maxOutSamples );
+		int nAdditionalNeeded = (wantedSampleCount - nSamplesGotten);
+		if ( nSamplesGotten > 0 )
+		{
+			short *dest = (short *)&pCopyBuf[ nSamplesGotten ];
+			int nSamplesToDuplicate = min( nSamplesGotten, nAdditionalNeeded );
+			const short *src = (short *)&pCopyBuf[ nSamplesGotten - nSamplesToDuplicate ];
+
+			Q_memcpy( dest, src, nSamplesToDuplicate * BYTES_PER_SAMPLE );
+
+			//Msg( "duplicating %d samples\n", nSamplesToDuplicate );
+
+			nAdditionalNeeded -= nSamplesToDuplicate;
+			if ( nAdditionalNeeded > 0  )
+			{
+				dest = (short *)&pCopyBuf[ nSamplesGotten + nSamplesToDuplicate ];
+				Q_memset(dest, 0, nAdditionalNeeded * BYTES_PER_SAMPLE);
+
+				// Msg( "zeroing %d samples\n", nAdditionalNeeded );
+
+				Assert( ( nAdditionalNeeded + nSamplesGotten + nSamplesToDuplicate ) == wantedSampleCount );
+			}
+		}
+		else
+		{
+			Q_memset( &pCopyBuf[ nSamplesGotten ], 0, nAdditionalNeeded * BYTES_PER_SAMPLE );
+		}
+		nSamplesGotten = wantedSampleCount;
+	}
+
+	// If the buffer is out of data, mark this channel to go away.
+	if(pBuffer->GetReadAvailable() == 0)
+	{
+		pChannel->m_bStarved = true;
+	}
+
+	if(voice_showchannels.GetInt() >= 2)
+	{
+		Msg("Voice - mixed %d samples from channel %d\n", nSamplesGotten, iChannel);
+	}
+
+	VoiceSE_MoveMouth(pChannel->m_iEntity, (short*)copyBufBytes, nSamplesGotten);
+	return nSamplesGotten;
+}
+
+
+void Voice_OnAudioSourceShutdown( int iChannel )
+{
+	Voice_EndChannel( iChannel );
+}
+
+
+// ------------------------------------------------------------------------ //
+// Internal stuff.
+// ------------------------------------------------------------------------ //
+
+CVoiceChannel* GetVoiceChannel(int iChannel, bool bAssert=true)
+{
+	if(iChannel < 0 || iChannel >= VOICE_NUM_CHANNELS)
+	{
+		if(bAssert)
+		{
+			Assert(false);
+		}
+		return NULL;
+	}
+	else
+	{
+		return &g_VoiceChannels[iChannel];
+	}
+}
+
+// Helper for doing a default-init with some codec if we weren't passed specific parameters
+bool Voice_InitWithDefault( const char *pCodecName )
+{
+	if ( !pCodecName || !*pCodecName )
+	{
+		return false;
+	}
+
+	int nRate = Voice_GetDefaultSampleRate( pCodecName );
+	if ( nRate < 0 )
+	{
+		Msg( "Voice_InitWithDefault: Unable to determine defaults for codec \"%s\"\n", pCodecName );
+		return false;
+	}
+
+	return Voice_Init( pCodecName, Voice_GetDefaultSampleRate( pCodecName ) );
+}
+
+bool Voice_Init( const char *pCodecName, int nSampleRate )
+{
+	if ( voice_enable.GetInt() == 0 )
+	{
+		return false;
+	}
+
+	if ( !pCodecName || !pCodecName[0] )
+	{
+		return false;
+	}
+
+	bool bSpeex = Q_stricmp( pCodecName, "vaudio_speex" ) == 0;
+	bool bCelt  = Q_stricmp( pCodecName, "vaudio_celt" )  == 0;
+	bool bSteam = Q_stricmp( pCodecName, "steam" )        == 0;
+	// Miles has not been in use for voice in a long long time.  Not worth the surface to support ancient demos that may
+	// use it (and probably do not work for other reasons)
+	// "vaudio_miles"
+
+	if ( !( bSpeex || bCelt || bSteam ) )
+	{
+		Msg( "Voice_Init Failed: invalid voice codec %s.\n", pCodecName );
+		return false;
+	}
+
+	Voice_Deinit();
+
+	g_bVoiceAtLeastPartiallyInitted = true;
+	V_strncpy( g_szVoiceCodec, pCodecName, sizeof(g_szVoiceCodec) );
+	g_nVoiceRequestedSampleRate = nSampleRate;
+
+	g_bUsingSteamVoice = bSteam;
+
+	if ( !steamapicontext )
+	{
+		steamapicontext = &g_SteamAPIContext;
+		steamapicontext->Init();
+	}
+
+	if ( g_bUsingSteamVoice )
+	{
+		if ( !steamapicontext->SteamFriends() || !steamapicontext->SteamUser() )
+		{
+			Msg( "Voice_Init: Requested Steam voice, but cannot access API.  Voice will not function\n" );
+			return false;
+		}
+	}
+
+	// For steam, nSampleRate 0 means "use optimal steam sample rate".
+	if ( bSteam && nSampleRate == 0 )
+	{
+		Msg( "Voice_Init: Using Steam voice optimal sample rate %d\n",
+		     steamapicontext->SteamUser()->GetVoiceOptimalSampleRate() );
+		// Steam's sample rate may change and not be supported by our rather unflexible sound engine. However, steam
+		// will resample as necessary in DecompressVoice, so we can pretend we're outputting at native rates.
+		//
+		// Behind the scenes, we'll request steam give us the encoded stream at its "optimal" rate, then we'll try to
+		// decompress the output at this rate, making it transparent to us that the encoded stream is not at our output
+		// rate.
+		Voice_SetSampleRate( SOUND_DMA_SPEED );
+	}
+	else
+	{
+		Voice_SetSampleRate( nSampleRate );
+	}
+
+	if(!VoiceSE_Init())
+		return false;
+
+	// Get the voice input device.
+#ifdef OSX
+	g_pVoiceRecord = CreateVoiceRecord_AudioQueue( Voice_SamplesPerSec() );
+	if ( !g_pVoiceRecord )
+	{
+		// Fall back to OpenAL
+		g_pVoiceRecord = CreateVoiceRecord_OpenAL( Voice_SamplesPerSec() );
+	}
+#elif defined( WIN32 )
+	g_pVoiceRecord = CreateVoiceRecord_DSound( Voice_SamplesPerSec() );
+#else
+	g_pVoiceRecord = CreateVoiceRecord_OpenAL( Voice_SamplesPerSec() );
+#endif
+
+	if( !g_pVoiceRecord )
+	{
+		Msg( "Unable to initialize sound capture. You won't be able to speak to other players." );
+	}
+
+	// Init codec DLL for non-steam
+	if ( !bSteam )
+	{
+		// CELT's qualities are 0-3, we historically just passed 4 to the other two even though they don't really map to the
+		// same thing.
+		//
+		// Changing the quality level we use here will require either extending SVC_VoiceInit to pass down which quality is
+		// in use or using a different codec name (vaudio_celtHD!) for backwards compatibility
+		int quality = bCelt ? 3 : 4;
+
+		// Get the codec.
+		CreateInterfaceFn createCodecFn = NULL;
+		g_hVoiceCodecDLL = FileSystem_LoadModule(pCodecName);
+
+		if ( !g_hVoiceCodecDLL || (createCodecFn = Sys_GetFactory(g_hVoiceCodecDLL)) == NULL ||
+		     (g_pEncodeCodec = (IVoiceCodec*)createCodecFn(pCodecName, NULL)) == NULL || !g_pEncodeCodec->Init( quality ) )
+		{
+			Msg("Unable to load voice codec '%s'. Voice disabled. (module %i, iface %i, codec %i)\n",
+			    pCodecName, !!g_hVoiceCodecDLL, !!createCodecFn, !!g_pEncodeCodec);
+			Voice_Deinit();
+			return false;
+		}
+
+		for (int i=0; i < VOICE_NUM_CHANNELS; i++)
+		{
+			CVoiceChannel *pChannel = &g_VoiceChannels[i];
+
+			if ((pChannel->m_pVoiceCodec = (IVoiceCodec*)createCodecFn(pCodecName, NULL)) == NULL || !pChannel->m_pVoiceCodec->Init( quality ))
+			{
+				Voice_Deinit();
+				return false;
+			}
+		}
+	}
+
+	// XXX(JohnS): These don't do much in Steam codec mode, but code below uses their presence to mean 'voice fully
+	//             initialized' and other things assume they will succeed.
+	InitMixerControls();
+
+	// Steam mode uses steam for raw input so this isn't meaningful and could have side-effects
+	if( voice_forcemicrecord.GetInt() && !bSteam )
+	{
+		if( g_pMixerControls )
+			g_pMixerControls->SelectMicrophoneForWaveInput();
+	}
+
+	return true;
+}
+
+
+void Voice_EndChannel(int iChannel)
+{
+	Assert(iChannel >= 0 && iChannel < VOICE_NUM_CHANNELS);
+
+	CVoiceChannel *pChannel = &g_VoiceChannels[iChannel];
+	
+	if ( pChannel->m_iEntity != -1 )
+	{
+		int iEnt = pChannel->m_iEntity;
+		pChannel->m_iEntity = -1;
+
+		if ( pChannel->m_bProximity == true )
+		{
+			VoiceSE_EndChannel( iChannel, iEnt );
+		}
+		else
+		{
+			VoiceSE_EndChannel( iChannel, pChannel->m_nViewEntityIndex );
+		}
+		
+		g_pSoundServices->OnChangeVoiceStatus( iEnt, false );
+		VoiceSE_CloseMouth( iEnt );
+
+		pChannel->m_nViewEntityIndex = -1;
+		pChannel->m_nSoundGuid = -1;
+
+		// If the tweak mode channel is ending
+		if ( iChannel == 0 && 
+			g_bInTweakMode )
+		{
+			VoiceTweak_EndVoiceTweakMode();
+		}
+	}
+}
+
+
+void Voice_EndAllChannels()
+{
+	for(int i=0; i < VOICE_NUM_CHANNELS; i++)
+	{
+		Voice_EndChannel(i);
+	}
+}
+
+bool EngineTool_SuppressDeInit();
+
+void Voice_Deinit()
+{
+	// This call tends to be expensive and when voice is not enabled it will continually
+	// call in here, so avoid the work if possible.
+	if( !g_bVoiceAtLeastPartiallyInitted )
+		return;
+
+	if ( EngineTool_SuppressDeInit() )
+		return;
+
+	Voice_EndAllChannels();
+
+	Voice_RecordStop();
+
+	for(int i=0; i < VOICE_NUM_CHANNELS; i++)
+	{
+		CVoiceChannel *pChannel = &g_VoiceChannels[i];
+		
+		if ( pChannel->m_pVoiceCodec )
+		{
+			pChannel->m_pVoiceCodec->Release();
+			pChannel->m_pVoiceCodec = NULL;
+		}
+	}
+
+	if( g_pEncodeCodec )
+	{
+		g_pEncodeCodec->Release();
+		g_pEncodeCodec = NULL;
+	}
+
+	if(g_hVoiceCodecDLL)
+	{
+		FileSystem_UnloadModule(g_hVoiceCodecDLL);
+		g_hVoiceCodecDLL = NULL;
+	}
+
+	if(g_pVoiceRecord)
+	{
+		g_pVoiceRecord->Release();
+		g_pVoiceRecord = NULL;
+	}
+
+	VoiceSE_Term();
+
+	g_bVoiceAtLeastPartiallyInitted = false;
+	g_szVoiceCodec[0] = '\0';
+	g_nVoiceRequestedSampleRate = -1;
+	g_bUsingSteamVoice = false;
+}
+
+bool Voice_GetLoopback()
+{
+	return !!voice_loopback.GetInt();
+}
+
+
+void Voice_LocalPlayerTalkingAck()
+{
+	if(!g_bLocalPlayerTalkingAck)
+	{
+		// Tell the client DLL when this changes.
+		g_pSoundServices->OnChangeVoiceStatus(-2, TRUE);
+	}
+
+	g_bLocalPlayerTalkingAck = true;
+	g_LocalPlayerTalkingTimeout = 0;
+}
+
+
+void Voice_UpdateVoiceTweakMode()
+{
+	if(!g_bInTweakMode || !g_pVoiceRecord)
+		return;
+
+	CVoiceChannel *pTweakChannel = GetVoiceChannel( 0 );
+
+	if ( pTweakChannel->m_nSoundGuid != -1 &&
+		!S_IsSoundStillPlaying( pTweakChannel->m_nSoundGuid ) )
+	{
+		VoiceTweak_EndVoiceTweakMode();
+		return;
+	}
+
+	char uchVoiceData[4096];
+	bool bFinal = false;
+	int nDataLength = Voice_GetCompressedData(uchVoiceData, sizeof(uchVoiceData), bFinal);
+
+	Voice_AddIncomingData(TWEAKMODE_CHANNELINDEX, uchVoiceData, nDataLength, 0);
+}
+
+
+void Voice_Idle(float frametime)
+{
+	if( voice_enable.GetInt() == 0 )
+	{
+		Voice_Deinit();
+		return;
+	}
+
+	if( g_bLocalPlayerTalkingAck )
+	{
+		g_LocalPlayerTalkingTimeout += frametime;
+		if(g_LocalPlayerTalkingTimeout > LOCALPLAYERTALKING_TIMEOUT)
+		{
+			g_bLocalPlayerTalkingAck = false;
+			
+			// Tell the client DLL.
+			g_pSoundServices->OnChangeVoiceStatus(-2, FALSE);
+		}
+	}
+
+	// Precalculate these to speedup the voice fadeout.
+	g_nVoiceFadeSamples = max((int)(voice_fadeouttime.GetFloat() * g_VoiceSampleFormat.nSamplesPerSec ), 2);
+	g_VoiceFadeMul = 1.0f / (g_nVoiceFadeSamples - 1);
+
+	if(g_pVoiceRecord)
+		g_pVoiceRecord->Idle();
+
+	// If we're in voice tweak mode, feed our own data back to us.
+	Voice_UpdateVoiceTweakMode();
+
+	// Age the channels.
+	int nActive = 0;
+	for(int i=0; i < VOICE_NUM_CHANNELS; i++)
+	{
+		CVoiceChannel *pChannel = &g_VoiceChannels[i];
+		
+		if(pChannel->m_iEntity != -1)
+		{
+			if(pChannel->m_bStarved)
+			{
+				// Kill the channel. It's done playing.
+				Voice_EndChannel(i);
+				pChannel->m_nSoundGuid = -1;
+			}
+			else
+			{
+				float oldpad = pChannel->m_TimePad;
+				pChannel->m_TimePad -= frametime;
+				if(oldpad > 0 && pChannel->m_TimePad <= 0)
+				{
+					// Start its audio.
+					pChannel->m_nViewEntityIndex = g_pSoundServices->GetViewEntity();
+					pChannel->m_nSoundGuid = VoiceSE_StartChannel( i, pChannel->m_iEntity, pChannel->m_bProximity, pChannel->m_nViewEntityIndex );
+					g_pSoundServices->OnChangeVoiceStatus(pChannel->m_iEntity, TRUE);
+					
+					VoiceSE_InitMouth(pChannel->m_iEntity);
+				}
+
+				++nActive;
+			}
+		}
+	}
+
+	if(nActive == 0)
+		VoiceSE_EndOverdrive();
+
+	VoiceSE_Idle(frametime);
+
+	// voice_showchannels.
+	if( voice_showchannels.GetInt() >= 1 )
+	{
+		for(int i=0; i < VOICE_NUM_CHANNELS; i++)
+		{
+			CVoiceChannel *pChannel = &g_VoiceChannels[i];
+			
+			if(pChannel->m_iEntity == -1)
+				continue;
+
+			Msg("Voice - chan %d, ent %d, bufsize: %d\n", i, pChannel->m_iEntity, pChannel->m_Buffer.GetReadAvailable());
+		}
+	}
+
+	// Show profiling data?
+	if( voice_profile.GetInt() )
+	{
+		Msg("Voice - compress: %7.2fu, decompress: %7.2fu, gain: %7.2fu, upsample: %7.2fu, total: %7.2fu\n", 
+			g_CompressTime*1000000.0, 
+			g_DecompressTime*1000000.0, 
+			g_GainTime*1000000.0, 
+			g_UpsampleTime*1000000.0,
+			(g_CompressTime+g_DecompressTime+g_GainTime+g_UpsampleTime)*1000000.0
+			);
+
+		g_CompressTime = g_DecompressTime = g_GainTime = g_UpsampleTime = 0;
+	}
+}
+
+
+bool Voice_IsRecording()
+{
+	return g_bVoiceRecording && !g_bInTweakMode;
+}
+
+
+bool Voice_RecordStart(
+	const char *pUncompressedFile, 
+	const char *pDecompressedFile,
+	const char *pMicInputFile)
+{
+	if( !g_pEncodeCodec && !g_bUsingSteamVoice )
+		return false;
+
+	g_VoiceWriter.Flush();
+
+	Voice_RecordStop();
+
+	if ( !g_bUsingSteamVoice )
+	{
+		g_pEncodeCodec->ResetState();
+	}
+	
+	if(pMicInputFile)
+	{
+		int a, b, c;
+		ReadWaveFile(pMicInputFile, g_pMicInputFileData, g_nMicInputFileBytes, a, b, c);
+		g_CurMicInputFileByte = 0;
+		g_MicStartTime = Plat_FloatTime();
+	}
+
+	if(pUncompressedFile)
+	{
+		g_pUncompressedFileData = new char[MAX_WAVEFILEDATA_LEN];
+		g_nUncompressedDataBytes = 0;
+		g_pUncompressedDataFilename = pUncompressedFile;
+	}
+
+	if(pDecompressedFile)
+	{
+		g_pDecompressedFileData = new char[MAX_WAVEFILEDATA_LEN];
+		g_nDecompressedDataBytes = 0;
+		g_pDecompressedDataFilename = pDecompressedFile;
+	}
+
+	g_bVoiceRecording = false;
+	if ( g_pVoiceRecord )
+	{
+		g_bVoiceRecording = VoiceRecord_Start();
+		if ( g_bVoiceRecording )
+		{
+			if ( steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUser() )
+			{
+				// Tell Friends' Voice chat that the local user has started speaking
+				steamapicontext->SteamFriends()->SetInGameVoiceSpeaking( steamapicontext->SteamUser()->GetSteamID(), true );
+			}
+
+			g_pSoundServices->OnChangeVoiceStatus( -1, true );		// Tell the client DLL.
+		}
+	}
+
+	return g_bVoiceRecording;
+}
+
+
+void Voice_UserDesiresStop()
+{
+	if ( g_bVoiceRecordStopping )
+		return;
+
+	g_bVoiceRecordStopping = true;
+	g_pSoundServices->OnChangeVoiceStatus( -1, false );		// Tell the client DLL.
+
+	// If we're using Steam voice, we'll keep recording until Steam tells us we
+	// received all the data.
+	if ( g_bUsingSteamVoice )
+	{
+		steamapicontext->SteamUser()->StopVoiceRecording();
+	}
+	else
+	{
+		VoiceRecord_Stop();
+	}
+}
+
+
+bool Voice_RecordStop()
+{
+	// Write the files out for debugging.
+	if(g_pMicInputFileData)
+	{
+		delete [] g_pMicInputFileData;
+		g_pMicInputFileData = NULL;
+	}
+
+	if(g_pUncompressedFileData)
+	{
+		WriteWaveFile(g_pUncompressedDataFilename, g_pUncompressedFileData, g_nUncompressedDataBytes, g_VoiceSampleFormat.wBitsPerSample, g_VoiceSampleFormat.nChannels, Voice_SamplesPerSec() );
+		delete [] g_pUncompressedFileData;
+		g_pUncompressedFileData = NULL;
+	}
+
+	if(g_pDecompressedFileData)
+	{
+		WriteWaveFile(g_pDecompressedDataFilename, g_pDecompressedFileData, g_nDecompressedDataBytes, g_VoiceSampleFormat.wBitsPerSample, g_VoiceSampleFormat.nChannels, Voice_SamplesPerSec() );
+		delete [] g_pDecompressedFileData;
+		g_pDecompressedFileData = NULL;
+	}
+	
+	g_VoiceWriter.Finish();
+
+	VoiceRecord_Stop();
+
+	if ( g_bVoiceRecording )
+	{
+		if ( steamapicontext->SteamFriends() && steamapicontext->SteamUser() )
+		{
+			// Tell Friends' Voice chat that the local user has stopped speaking
+			steamapicontext->SteamFriends()->SetInGameVoiceSpeaking( steamapicontext->SteamUser()->GetSteamID(), false );
+		}
+	}
+
+	g_bVoiceRecording = false;
+	g_bVoiceRecordStopping = false;
+	return(true);
+}
+
+
+int Voice_GetCompressedData(char *pchDest, int nCount, bool bFinal)
+{
+	// Check g_bVoiceRecordStopping in case g_bUsingSteamVoice changes on us
+	// while waiting for the end of voice data.
+	if ( g_bUsingSteamVoice || g_bVoiceRecordStopping )
+	{
+		uint32 cbCompressedWritten = 0;
+		uint32 cbUncompressedWritten = 0;
+		uint32 cbCompressed = 0;
+		uint32 cbUncompressed = 0;
+		// We're going to always request steam give us the encoded stream at the optimal rate, unless our final output
+		// rate is lower than it.  We'll pass our output rate when we actually extract the data, which Steam will
+		// happily upsample from its optimal rate for us.
+		int nEncodeRate = min( (int)steamapicontext->SteamUser()->GetVoiceOptimalSampleRate(), Voice_SamplesPerSec() );
+		EVoiceResult result = steamapicontext->SteamUser()->GetAvailableVoice( &cbCompressed, &cbUncompressed, nEncodeRate );
+		if ( result == k_EVoiceResultOK )
+		{
+			result = steamapicontext->SteamUser()->GetVoice( true, pchDest, nCount, &cbCompressedWritten, 
+			                                                 g_pUncompressedFileData != NULL, g_pUncompressedFileData,
+			                                                 MAX_WAVEFILEDATA_LEN - g_nUncompressedDataBytes,
+			                                                 &cbUncompressedWritten, nEncodeRate );
+
+			if ( g_pUncompressedFileData )
+			{
+				g_nUncompressedDataBytes += cbUncompressedWritten;
+			}
+			g_pSoundServices->OnChangeVoiceStatus( -3, true );
+		}
+		else
+		{
+			if ( result == k_EVoiceResultNotRecording && g_bVoiceRecording )
+			{
+				Voice_RecordStop();
+			}
+
+			g_pSoundServices->OnChangeVoiceStatus( -3, false );
+		}
+		return cbCompressedWritten;
+	}
+
+	IVoiceCodec *pCodec = g_pEncodeCodec;
+	if( g_pVoiceRecord && pCodec )
+	{
+#ifdef VOICE_VOX_ENABLE	
+		static ConVarRef voice_vox( "voice_vox" );
+#endif // VOICE_VOX_ENABLE	
+
+		short tempData[8192];
+		int samplesWanted = min(nCount/BYTES_PER_SAMPLE, (int)sizeof(tempData)/BYTES_PER_SAMPLE);
+		int gotten = g_pVoiceRecord->GetRecordedData(tempData, samplesWanted);
+
+		// If they want to get the data from a file instead of the mic, use that.
+		if(g_pMicInputFileData)
+		{
+			double curtime = Plat_FloatTime();
+			int nShouldGet = (curtime - g_MicStartTime) * Voice_SamplesPerSec();
+			gotten = min(sizeof(tempData)/BYTES_PER_SAMPLE,
+			             (size_t)min(nShouldGet, (g_nMicInputFileBytes - g_CurMicInputFileByte) / BYTES_PER_SAMPLE));
+			memcpy(tempData, &g_pMicInputFileData[g_CurMicInputFileByte], gotten*BYTES_PER_SAMPLE);
+			g_CurMicInputFileByte += gotten * BYTES_PER_SAMPLE;
+			g_MicStartTime = curtime;
+		}
+#ifdef VOICE_VOX_ENABLE	
+		else if ( gotten && voice_vox.GetBool() == true )
+		{
+			// If the voice data is essentially silent, don't transmit
+			short *pData = tempData;
+			int averageData = 0;
+			int minData = 16384;
+			int maxData = -16384;
+			for ( int i=0; i<gotten; ++i )
+			{
+				short val = *pData;
+				averageData += val;
+				minData = min( val, minData );
+				maxData = max( val, maxData );
+				++pData;
+			}
+			averageData /= gotten;
+			int deltaData = maxData - minData;
+
+			if ( deltaData < voice_threshold.GetFloat() && maxData < voice_threshold.GetFloat() )
+			{
+				// -3 signals that we're silent
+				g_pSoundServices->OnChangeVoiceStatus( -3, false );
+				return 0;
+			}
+		}
+#endif // VOICE_VOX_ENABLE
+
+#ifdef VOICE_SEND_RAW_TEST
+		int nCompressedBytes = min( gotten, nCount );
+		for ( int i=0; i < nCompressedBytes; i++ )
+		{
+			pchDest[i] = (char)(tempData[i] >> 8);
+		}
+#else			
+		int nCompressedBytes = pCodec->Compress((char*)tempData, gotten, pchDest, nCount, !!bFinal);
+#endif
+
+		// Write to our file buffers..
+		if(g_pUncompressedFileData)
+		{
+			int nToWrite = min(gotten*BYTES_PER_SAMPLE, MAX_WAVEFILEDATA_LEN - g_nUncompressedDataBytes);
+			memcpy(&g_pUncompressedFileData[g_nUncompressedDataBytes], tempData, nToWrite);
+			g_nUncompressedDataBytes += nToWrite;
+		}
+#ifdef VOICE_VOX_ENABLE
+		// -3 signals that we're talking
+		g_pSoundServices->OnChangeVoiceStatus( -3, (nCompressedBytes > 0) );
+#endif // VOICE_VOX_ENABLE		
+		return nCompressedBytes;
+	}
+	else
+	{
+#ifdef VOICE_VOX_ENABLE	
+		// -3 signals that we're silent
+		g_pSoundServices->OnChangeVoiceStatus( -3, false );
+#endif // VOICE_VOX_ENABLE
+		return 0;
+	}
+}
+
+
+//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
+// Purpose: Assigns a channel to an entity by searching for either a channel
+//			already assigned to that entity or picking the least recently used
+//			channel. If the LRU channel is picked, it is flushed and all other
+//			channels are aged.
+// Input  : nEntity - entity number to assign to a channel.
+// Output : A channel index to which the entity has been assigned.
+//------------------------------------------------------------------------------
+int Voice_AssignChannel(int nEntity, bool bProximity)
+{
+	if(g_bInTweakMode)
+		return VOICE_CHANNEL_IN_TWEAK_MODE;
+
+	// See if a channel already exists for this entity and if so, just return it.
+	int iFree = -1;
+	for(int i=0; i < VOICE_NUM_CHANNELS; i++)
+	{
+		CVoiceChannel *pChannel = &g_VoiceChannels[i];
+
+		if(pChannel->m_iEntity == nEntity)
+		{
+			return i;
+		}
+		else if(pChannel->m_iEntity == -1 && ( pChannel->m_pVoiceCodec || g_bUsingSteamVoice ) )
+		{
+			// Won't exist in steam voice mode
+			if ( pChannel->m_pVoiceCodec )
+			{
+				pChannel->m_pVoiceCodec->ResetState();
+			}
+			iFree = i;
+			break;
+		}
+	}
+
+	// If they're all used, then don't allow them to make a new channel.
+	if(iFree == -1)
+	{
+		return VOICE_CHANNEL_ERROR;
+	}
+
+	CVoiceChannel *pChannel = &g_VoiceChannels[iFree];
+	pChannel->Init(nEntity);
+	pChannel->m_bProximity = bProximity;
+	VoiceSE_StartOverdrive();
+
+	return iFree;
+}
+
+
+//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
+// Purpose: Determines which channel has been assigened to a given entity.
+// Input  : nEntity - entity number.
+// Output : The index of the channel assigned to the entity, VOICE_CHANNEL_ERROR
+//			if no channel is currently assigned to the given entity.
+//------------------------------------------------------------------------------
+int Voice_GetChannel(int nEntity)
+{
+	for(int i=0; i < VOICE_NUM_CHANNELS; i++)
+		if(g_VoiceChannels[i].m_iEntity == nEntity)
+			return i;
+
+	return VOICE_CHANNEL_ERROR;
+}
+
+
+double UpsampleIntoBuffer(
+	const short *pSrc,
+	int nSrcSamples,
+	CCircularBuffer *pBuffer,
+	double startFraction,
+	double rate)
+{
+	double maxFraction = nSrcSamples - 1;
+
+	while(1)
+	{
+		if(startFraction >= maxFraction)
+			break;
+
+		int iSample = (int)startFraction;
+		double frac = startFraction - floor(startFraction);
+
+		double val1 = pSrc[iSample];
+		double val2 = pSrc[iSample+1];
+		short newSample = (short)(val1 + (val2 - val1) * frac);
+		pBuffer->Write(&newSample, sizeof(newSample));
+
+		startFraction += rate;
+	}
+
+	return startFraction - floor(startFraction);
+}
+
+
+//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
+// Purpose: Adds received voice data to 
+// Input  : 
+// Output : 
+//------------------------------------------------------------------------------
+int Voice_AddIncomingData(int nChannel, const char *pchData, int nCount, int iSequenceNumber)
+{
+	CVoiceChannel *pChannel;
+
+	// If in tweak mode, we call this during Idle with -1 as the channel, so any channel data from the network
+	// gets rejected.
+	if(g_bInTweakMode)
+	{
+		if(nChannel == TWEAKMODE_CHANNELINDEX)
+			nChannel = 0;
+		else
+			return 0;
+	}
+
+	if ( ( pChannel = GetVoiceChannel(nChannel)) == NULL || ( !g_bUsingSteamVoice && !pChannel->m_pVoiceCodec ) )
+	{
+		return(0);
+	}
+
+	pChannel->m_bStarved = false;	// This only really matters if you call Voice_AddIncomingData between the time the mixer
+									// asks for data and Voice_Idle is called.
+
+	// Decompress.
+	// @note Tom Bui: suggested destination buffer for Steam voice is 22kb
+	char decompressed[22528];
+
+#ifdef VOICE_SEND_RAW_TEST
+
+		int nDecompressed = nCount;
+		for ( int i=0; i < nDecompressed; i++ )
+			((short*)decompressed)[i] = pchData[i] << 8;
+
+#else
+
+	int nDecompressed = 0;
+	if ( g_bUsingSteamVoice )
+	{
+		uint32 nBytesWritten = 0;
+		EVoiceResult result = steamapicontext->SteamUser()->DecompressVoice( pchData, nCount,
+		                                                                     decompressed, sizeof( decompressed ),
+		                                                                     &nBytesWritten, Voice_SamplesPerSec() );
+		if ( result == k_EVoiceResultOK )
+		{
+			nDecompressed = nBytesWritten / BYTES_PER_SAMPLE;
+		}
+	}
+	else
+	{
+		nDecompressed = pChannel->m_pVoiceCodec->Decompress(pchData, nCount, decompressed, sizeof(decompressed));
+	}
+
+#endif
+
+	if ( g_bInTweakMode )
+	{
+		short *data = (short *)decompressed;
+		g_VoiceTweakSpeakingVolume = 0;
+
+		// Find the highest value
+		for ( int i=0; i<nDecompressed; ++i )
+		{
+			g_VoiceTweakSpeakingVolume = max((int)abs(data[i]), g_VoiceTweakSpeakingVolume);
+		}
+
+		// Smooth it out
+		g_VoiceTweakSpeakingVolume &= 0xFE00;
+	}
+
+	pChannel->m_AutoGain.ProcessSamples((short*)decompressed, nDecompressed);
+
+	// Upsample into the dest buffer. We could do this in a mixer but it complicates the mixer.
+	pChannel->m_LastFraction = UpsampleIntoBuffer( (short*)decompressed,
+	                                               nDecompressed,
+	                                               &pChannel->m_Buffer,
+	                                               pChannel->m_LastFraction,
+	                                               (double)Voice_SamplesPerSec()/g_VoiceSampleFormat.nSamplesPerSec );
+	pChannel->m_LastSample = decompressed[nDecompressed];
+
+	// Write to our file buffer..
+	if(g_pDecompressedFileData)
+	{
+		int nToWrite = min(nDecompressed*2, MAX_WAVEFILEDATA_LEN - g_nDecompressedDataBytes);
+		memcpy(&g_pDecompressedFileData[g_nDecompressedDataBytes], decompressed, nToWrite);
+		g_nDecompressedDataBytes += nToWrite;
+	}
+
+	g_VoiceWriter.AddDecompressedData( pChannel, (const byte *)decompressed, nDecompressed * 2 );
+
+	if( voice_showincoming.GetInt() != 0 )
+	{
+		Msg("Voice - %d incoming samples added to channel %d\n", nDecompressed, nChannel);
+	}
+
+	return(nChannel);
+}
+
+
+#if DEAD
+//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
+// Purpose: Flushes a given receive channel.
+// Input  : nChannel - index of channel to flush.
+//------------------------------------------------------------------------------
+void Voice_FlushChannel(int nChannel)
+{
+	if ((nChannel < 0) || (nChannel >= VOICE_NUM_CHANNELS))
+	{
+		Assert(false);
+		return;
+	}
+
+	g_VoiceChannels[nChannel].m_Buffer.Flush();
+}
+#endif
+
+
+//------------------------------------------------------------------------------
+// IVoiceTweak implementation.
+//------------------------------------------------------------------------------
+
+int VoiceTweak_StartVoiceTweakMode()
+{
+	// If we're already in voice tweak mode, return an error.
+	if(g_bInTweakMode)
+	{
+		Assert(!"VoiceTweak_StartVoiceTweakMode called while already in tweak mode.");
+		return 0;
+	}
+
+	if ( !g_pMixerControls && voice_enable.GetBool() )
+	{
+		Voice_ForceInit();
+	}
+
+	if( !g_pMixerControls )
+		return 0;
+
+	Voice_EndAllChannels();
+	Voice_RecordStart(NULL, NULL, NULL);
+	Voice_AssignChannel(TWEAKMODE_ENTITYINDEX, false );
+	g_bInTweakMode = true;
+	InitMixerControls();
+
+	return 1;
+}
+
+void VoiceTweak_EndVoiceTweakMode()
+{
+	if(!g_bInTweakMode)
+	{
+		Assert(!"VoiceTweak_EndVoiceTweakMode called when not in tweak mode.");
+		return;
+	}
+
+	g_bInTweakMode = false;
+	Voice_RecordStop();
+}
+
+void VoiceTweak_SetControlFloat(VoiceTweakControl iControl, float flValue)
+{
+	if(!g_pMixerControls)
+		return;
+
+	if(iControl == MicrophoneVolume)
+	{
+		g_pMixerControls->SetValue_Float(IMixerControls::MicVolume, flValue);
+	}
+	else if ( iControl == MicBoost )
+	{
+		g_pMixerControls->SetValue_Float( IMixerControls::MicBoost, flValue );
+	}
+	else if(iControl == OtherSpeakerScale)
+	{
+		voice_scale.SetValue( flValue );
+	}
+}
+
+void Voice_ForceInit()
+{
+	if ( g_pMixerControls || !voice_enable.GetBool() )
+	{
+		// Nothing to do
+		return;
+	}
+
+	// Lacking a better default, just peak at what the server's sv_voicecodec is set to
+	static ConVarRef sv_voicecodec( "sv_voicecodec" );
+	if ( !Voice_InitWithDefault( sv_voicecodec.GetString() ) )
+	{
+		// Try ultimate fallback
+		Voice_InitWithDefault( VOICE_FALLBACK_CODEC );
+	}
+}
+
+float VoiceTweak_GetControlFloat(VoiceTweakControl iControl)
+{
+	Voice_ForceInit();
+
+	if(!g_pMixerControls)
+		return 0;
+
+	if(iControl == MicrophoneVolume)
+	{
+		float value = 1;
+		g_pMixerControls->GetValue_Float(IMixerControls::MicVolume, value);
+		return value;
+	}
+	else if(iControl == OtherSpeakerScale)
+	{
+		return voice_scale.GetFloat();
+	}
+	else if(iControl == SpeakingVolume)
+	{
+		return g_VoiceTweakSpeakingVolume * 1.0f / 32768;
+	}
+	else if ( iControl == MicBoost )
+	{
+		float flValue = 1;
+		g_pMixerControls->GetValue_Float( IMixerControls::MicBoost, flValue );
+		return flValue;
+	}
+	else
+	{
+		return 1;
+	}
+}
+
+bool VoiceTweak_IsStillTweaking()
+{
+	return g_bInTweakMode;
+}
+
+void Voice_Spatialize( channel_t *channel )
+{
+	if ( !g_bInTweakMode )
+		return;
+
+	Assert( channel->sfx );
+	Assert( channel->sfx->pSource );
+	Assert( channel->sfx->pSource->GetType() == CAudioSource::AUDIO_SOURCE_VOICE );
+
+	// Place the tweak mode sound back at the view entity
+	CVoiceChannel *pVoiceChannel = GetVoiceChannel( 0 );
+	Assert( pVoiceChannel );
+	if ( !pVoiceChannel )
+		return;
+
+	if ( pVoiceChannel->m_nSoundGuid != channel->guid )
+		return;
+
+	// No change
+	if ( g_pSoundServices->GetViewEntity() == pVoiceChannel->m_nViewEntityIndex )
+		return;
+
+	DevMsg( 1, "Voice_Spatialize changing voice tweak entity from %d to %d\n", pVoiceChannel->m_nViewEntityIndex, g_pSoundServices->GetViewEntity() );
+
+	pVoiceChannel->m_nViewEntityIndex = g_pSoundServices->GetViewEntity();
+	channel->soundsource = pVoiceChannel->m_nViewEntityIndex;
+}
+
+IVoiceTweak g_VoiceTweakAPI =
+{
+	VoiceTweak_StartVoiceTweakMode,
+	VoiceTweak_EndVoiceTweakMode,
+	VoiceTweak_SetControlFloat,
+	VoiceTweak_GetControlFloat,
+	VoiceTweak_IsStillTweaking,
+};
+
+