csgo/cstrike15_src/engine/audio/private/snd_dev_xaudio.cpp

//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: X360 XAudio Version
//
//=====================================================================================//


#include "audio_pch.h"
#include "snd_dev_xaudio.h"
#include "utllinkedlist.h"
#include "server.h"
#include "client.h"
#include "matchmaking/imatchframework.h"
#include "tier2/tier2.h"
#include "smartptr.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

// The outer code mixes in PAINTBUFFER_SIZE (# of samples) chunks (see MIX_PaintChannels), we will never need more than
// that many samples in a buffer.  This ends up being about 20ms per buffer
#define XAUDIO2_BUFFER_SAMPLES	PAINTBUFFER_SIZE
// buffer return has a latency, so need a decent pool
#define MAX_XAUDIO2_BUFFERS		32

#define SURROUND_HEADPHONES		0
#define SURROUND_STEREO			2
#define SURROUND_DIGITAL5DOT1	5

// 5.1 means there are a max of 6 channels
#define MAX_DEVICE_CHANNELS		6

ConVar snd_xaudio_spew_buffers( "snd_xaudio_spew_buffers", "0", 0, "Spew XAudio buffer delivery" );

extern IVEngineClient *engineClient;

//-----------------------------------------------------------------------------
// Implementation of XAudio
//-----------------------------------------------------------------------------
class CAudioXAudio : public CAudioDeviceBase
{
public:
	CAudioXAudio() : m_pXAudio2(NULL), m_pMasteringVoice(NULL), m_pSourceVoice(NULL), m_pOutputBuffer(NULL)
	{
		memset( m_Buffers, 0, sizeof(m_Buffers) ); //	COMPILE_TIME_ASSERT( sizeof(m_Buffers) == sizeof(XAUDIO2_BUFFER)*MAX_XAUDIO2_BUFFERS  );
		m_pName = "XAudio2 Device";
		m_nChannels = 2;
		m_nSampleBits = 16;
		m_nSampleRate = 44100;
		m_bIsActive = true;
	}
	~CAudioXAudio( void );

	bool		IsActive( void ) { return true; }
	bool		Init( void );
	void		Shutdown( void );

	void		Pause( void );
	void		UnPause( void );
	int64		PaintBegin( float mixAheadTime, int64 soundtime, int64 paintedtime );
	int			GetOutputPosition( void );
	void		ClearBuffer( void );
	void		TransferSamples( int64 end );

	const char *DeviceName( void );
	int			DeviceDmaSpeed( void )		{ return m_nSampleRate; }	
	int			DeviceSampleCount( void )	{ return m_deviceSampleCount; }

	void		XAudio2BufferCallback( int hCompletedBuffer );

	static		CAudioXAudio *m_pSingleton;

	CXboxVoice	*GetVoiceData( void ) { return &m_VoiceData; }
	IXAudio2	*GetXAudio2( void ) { return m_pXAudio2; }

private:
	int			TransferStereo( const portable_samplepair_t *pFront, int paintedTime, int endTime, char *pOutptuBuffer );
	int			TransferSurroundInterleaved( const portable_samplepair_t *pFront, const portable_samplepair_t *pRear, const portable_samplepair_t *pCenter, int paintedTime, int endTime, char *pOutputBuffer );

	int			m_deviceSampleCount;				// count of mono samples in output buffer
	int			m_clockDivider;
	
	IXAudio2				*m_pXAudio2;
	IXAudio2MasteringVoice	*m_pMasteringVoice;
	IXAudio2SourceVoice		*m_pSourceVoice;

	XAUDIO2_BUFFER		m_Buffers[MAX_XAUDIO2_BUFFERS];
	BYTE				*m_pOutputBuffer;
	int					m_bufferSizeBytes;			// size of a single hardware output buffer, in bytes
	CInterlockedUInt	m_BufferTail;
	CInterlockedUInt	m_BufferHead;

	CXboxVoice			m_VoiceData;
};
CAudioXAudio *CAudioXAudio::m_pSingleton = NULL;

class XAudio2VoiceCallback : public IXAudio2VoiceCallback
{
public:
    XAudio2VoiceCallback() {}
    ~XAudio2VoiceCallback() {}

    void OnStreamEnd() {}

    void OnVoiceProcessingPassEnd() {}

    void OnVoiceProcessingPassStart( UINT32 SamplesRequired ) {}

    void OnBufferEnd( void *pBufferContext ) 
	{
		CAudioXAudio::m_pSingleton->XAudio2BufferCallback( (int)pBufferContext );
	}

    void OnBufferStart( void *pBufferContext ) {}

    void OnLoopEnd( void *pBufferContext ) {}

    void OnVoiceError( void *pBufferContext, HRESULT Error ) {}
};
XAudio2VoiceCallback s_XAudio2VoiceCallback;

//-----------------------------------------------------------------------------
// Create XAudio Device
//-----------------------------------------------------------------------------
IAudioDevice *Audio_CreateXAudioDevice( bool bInitVoice )
{
	MEM_ALLOC_CREDIT();

	if ( CommandLine()->CheckParm( "-nosound" ) )
	{
		// respect forced lack of audio
		return NULL;
	}

	if ( !CAudioXAudio::m_pSingleton )
	{
		CAudioXAudio::m_pSingleton = new CAudioXAudio;
		if ( !CAudioXAudio::m_pSingleton->Init() )
		{
			AssertMsg( false, "Failed to init CAudioXAudio\n" );
			delete CAudioXAudio::m_pSingleton;
			CAudioXAudio::m_pSingleton = NULL;
		}
	}

	// need to support early init of XAudio (for bink startup video) without the voice
	// voice requires matchmaking which is not available at this early point
	// this defers the voice init to a later engine init mark
	if ( bInitVoice && CAudioXAudio::m_pSingleton )
	{
		CAudioXAudio::m_pSingleton->GetVoiceData()->VoiceInit();
	}

	return CAudioXAudio::m_pSingleton;
}

CXboxVoice *Audio_GetXVoice( void )
{
	if ( CAudioXAudio::m_pSingleton )
	{
		return CAudioXAudio::m_pSingleton->GetVoiceData();
	}

	return NULL;
}

IXAudio2 *Audio_GetXAudio2( void )
{
	if ( CAudioXAudio::m_pSingleton )
	{
		return CAudioXAudio::m_pSingleton->GetXAudio2();
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Destructor
//-----------------------------------------------------------------------------
CAudioXAudio::~CAudioXAudio( void )
{
	m_pSingleton = NULL;
}

//-----------------------------------------------------------------------------
// Initialize XAudio
//-----------------------------------------------------------------------------
bool CAudioXAudio::Init( void )
{
	XAUDIOSPEAKERCONFIG xAudioConfig = 0;
	XGetSpeakerConfig( &xAudioConfig );
	snd_surround.SetValue( ( xAudioConfig & XAUDIOSPEAKERCONFIG_DIGITAL_DOLBYDIGITAL ) ? SURROUND_DIGITAL5DOT1 : SURROUND_STEREO );

	m_bHeadphone = false;
	m_bSurround = false;
	m_bSurroundCenter = false;

	switch ( snd_surround.GetInt() )
	{
	case SURROUND_HEADPHONES:
		m_bHeadphone = true;
		m_nChannels = 2;
		break;

	default:
	case SURROUND_STEREO:
		m_nChannels = 2;
		break;

	case SURROUND_DIGITAL5DOT1:
		m_bSurround = true;	
		m_bSurroundCenter = true;
		m_nChannels = 6;
		break;
	}

	Assert( m_nChannels <= MAX_DEVICE_CHANNELS );

	m_nSampleBits = 16;
	m_nSampleRate = SOUND_DMA_SPEED;

    // initialize the XAudio Engine
	// Both threads on core 2
	m_pXAudio2 = NULL;
	HRESULT hr = XAudio2Create( &m_pXAudio2, 0, XboxThread5 );
	if ( FAILED( hr ) )
		return false;

	// create the mastering voice, this will upsample to the devices target hw output rate
    m_pMasteringVoice = NULL;
	hr = m_pXAudio2->CreateMasteringVoice( &m_pMasteringVoice );
	if ( FAILED( hr ) )
        return false;
	
	// 16 bit PCM
	WAVEFORMATEX waveFormatEx = { 0 };
	waveFormatEx.wFormatTag = WAVE_FORMAT_PCM;
	waveFormatEx.nChannels = m_nChannels;
	waveFormatEx.nSamplesPerSec = m_nSampleRate;
	waveFormatEx.wBitsPerSample = 16;
	waveFormatEx.nBlockAlign = ( waveFormatEx.nChannels * waveFormatEx.wBitsPerSample ) / 8;
	waveFormatEx.nAvgBytesPerSec = waveFormatEx.nSamplesPerSec * waveFormatEx.nBlockAlign;
	waveFormatEx.cbSize = 0;

	m_pSourceVoice = NULL;
	hr = m_pXAudio2->CreateSourceVoice( 
			&m_pSourceVoice, 
			&waveFormatEx, 
			0,
			XAUDIO2_DEFAULT_FREQ_RATIO,
			&s_XAudio2VoiceCallback,
			NULL,
			NULL );
	if ( FAILED( hr ) )
        return false;

	float volumes[MAX_DEVICE_CHANNELS];
	for ( int i = 0; i < MAX_DEVICE_CHANNELS; i++ )
	{
		if ( !m_bSurround && i >= 2 )
		{
			volumes[i] = 0;
		}
		else
		{
			volumes[i] = 1.0;
		}
	}
	m_pSourceVoice->SetChannelVolumes( m_nChannels, volumes );

	m_bufferSizeBytes = XAUDIO2_BUFFER_SAMPLES * (m_nSampleBits/8) * m_nChannels;
	m_pOutputBuffer = new BYTE[MAX_XAUDIO2_BUFFERS * m_bufferSizeBytes];
	ClearBuffer();

	V_memset( m_Buffers, 0, MAX_XAUDIO2_BUFFERS * sizeof( XAUDIO2_BUFFER ) );
	for ( int i = 0; i < MAX_XAUDIO2_BUFFERS; i++ )
	{
		m_Buffers[i].pAudioData = m_pOutputBuffer + i*m_bufferSizeBytes;
		m_Buffers[i].pContext = (LPVOID)i;
	}
	m_BufferHead = 0;
	m_BufferTail = 0;

	// number of mono samples output buffer may hold
	m_deviceSampleCount = MAX_XAUDIO2_BUFFERS * (m_bufferSizeBytes/(DeviceSampleBytes()));
	
	// NOTE: This really shouldn't be tied to the # of bufferable samples.
	// This just needs to be large enough so that it doesn't fake out the sampling in 
	// GetSoundTime().  Basically GetSoundTime() assumes a cyclical time stamp and finds wraparound cases
	// but that means it needs to get called much more often than once per cycle.  So this number should be
	// much larger than the framerate in terms of output time
	m_clockDivider = m_deviceSampleCount / ChannelCount();

	// not really part of XAudio2, but mixer xma lacks one-time init, so doing it here
	XMAPlaybackInitialize();

	hr = m_pSourceVoice->Start( 0 );
    if ( FAILED( hr ) )
		return false;

	DevMsg( "XAudio Device Initialized:\n" );
	DevMsg( "   %s\n"
			"   %d channel(s)\n"
			"   %d bits/sample\n"
			"   %d samples/sec\n", DeviceName(), ChannelCount(), BitsPerSample(), DeviceDmaSpeed() );

	// success
	return true;
}

//-----------------------------------------------------------------------------
// Shutdown XAudio
//-----------------------------------------------------------------------------
void CAudioXAudio::Shutdown( void )
{
	if ( m_pSourceVoice )
	{
		m_pSourceVoice->Stop( 0 );
		m_pSourceVoice->DestroyVoice();
		m_pSourceVoice = NULL;
		delete[] m_pOutputBuffer;
	}

	if ( m_pMasteringVoice )
	{
		m_pMasteringVoice->DestroyVoice();
		m_pMasteringVoice = NULL;
	}

	// need to release ref to XAudio2
	m_VoiceData.VoiceShutdown();

	if ( m_pXAudio2 )
	{
		m_pXAudio2->Release();
		m_pXAudio2 = NULL;
	}

	if ( this == CAudioXAudio::m_pSingleton )
	{
		CAudioXAudio::m_pSingleton = NULL;
	}
}

//-----------------------------------------------------------------------------
// XAudio has completed a buffer. Assuming these are sequential
//-----------------------------------------------------------------------------
void CAudioXAudio::XAudio2BufferCallback( int hCompletedBuffer )
{
	// buffer completion expected to be sequential
	Assert( hCompletedBuffer == (int)( m_BufferTail % MAX_XAUDIO2_BUFFERS ) );

	m_BufferTail++;

	if ( snd_xaudio_spew_buffers.GetBool() )
	{
		if ( m_BufferTail == m_BufferHead )
		{
			Warning( "XAudio: Starved\n" );
		}
		else
		{
			Msg( "XAudio: Buffer Callback, Submit: %2d, Free: %2d\n", m_BufferHead - m_BufferTail, MAX_XAUDIO2_BUFFERS - ( m_BufferHead - m_BufferTail ) );
		}
	}

	if ( m_BufferTail == m_BufferHead )
	{
		// very bad, out of buffers, xaudio is starving
		// mix thread didn't keep up with audio clock and submit buffers
		// submit a silent buffer to keep stream playing and audio clock running
		int head = m_BufferHead++;
		XAUDIO2_BUFFER *pBuffer = &m_Buffers[head % MAX_XAUDIO2_BUFFERS];
		V_memset( (void *)pBuffer->pAudioData, 0, m_bufferSizeBytes );
		pBuffer->AudioBytes = m_bufferSizeBytes;
		m_pSourceVoice->SubmitSourceBuffer( pBuffer );
	}
}

//-----------------------------------------------------------------------------
// Return the "write" cursor.  Used to clock the audio mixing.
// The actual hw write cursor and the number of samples it fetches is unknown.
//-----------------------------------------------------------------------------
int	CAudioXAudio::GetOutputPosition( void )
{
	XAUDIO2_VOICE_STATE state;

	state.SamplesPlayed = 0;
	m_pSourceVoice->GetState( &state );

	return ( state.SamplesPlayed % m_clockDivider );
}

//-----------------------------------------------------------------------------
// Pause playback
//-----------------------------------------------------------------------------
void CAudioXAudio::Pause( void )
{
	if ( m_pSourceVoice )
	{
		m_pSourceVoice->Stop( 0 );
	}
}

//-----------------------------------------------------------------------------
// Resume playback
//-----------------------------------------------------------------------------
void CAudioXAudio::UnPause( void )
{
	if ( m_pSourceVoice )
	{
		m_pSourceVoice->Start( 0 );
	}
}

//-----------------------------------------------------------------------------
// Calc the paint position
//-----------------------------------------------------------------------------
int64 CAudioXAudio::PaintBegin( float mixAheadTime, int64 soundtime, int64 paintedtime )
{
	//  soundtime = total full samples that have been played out to hardware at dmaspeed
	//  paintedtime = total full samples that have been mixed at speed

	//  endtime = target for full samples in mixahead buffer at speed	
	int mixaheadtime = mixAheadTime * DeviceDmaSpeed();
	int64 endtime = soundtime + mixaheadtime;
	if ( endtime <= paintedtime )
	{
		return endtime;
	}

	int fullsamps = MAX_XAUDIO2_BUFFERS * (m_bufferSizeBytes /( DeviceSampleBytes() * ChannelCount() ));

	if ( ( endtime - soundtime ) > fullsamps )
	{
		endtime = soundtime + fullsamps;
	}
	if ( ( endtime - paintedtime ) & 0x03 )
	{
		// The difference between endtime and painted time should align on 
		// boundaries of 4 samples.  This is important when upsampling from 11khz -> 44khz.
		endtime -= ( endtime - paintedtime ) & 0x03;
	}

	return endtime;
}

//-----------------------------------------------------------------------------
// Fill the output buffers with silence
//-----------------------------------------------------------------------------
void CAudioXAudio::ClearBuffer( void )
{
	V_memset( m_pOutputBuffer, 0, MAX_XAUDIO2_BUFFERS * m_bufferSizeBytes );
}

//-----------------------------------------------------------------------------
// Fill the output buffer with L/R samples
//-----------------------------------------------------------------------------
int CAudioXAudio::TransferStereo( const portable_samplepair_t *pFrontBuffer, int paintedTime, int endTime, char *pOutputBuffer )
{
	int linearCount;
	int i;
	int	val;

	int volumeFactor = S_GetMasterVolume() * 256;

	int *pFront = (int *)pFrontBuffer;
	short *pOutput = (short *)pOutputBuffer;
	
	// get size of output buffer in full samples (LR pairs)
	// number of sequential sample pairs that can be wrriten
	linearCount = m_bufferSizeBytes/( DeviceSampleBytes() * ChannelCount() );		

	// clamp output count to requested number of samples
	if ( linearCount > endTime - paintedTime )
	{
		linearCount = endTime - paintedTime;
	}

	// linearCount is now number of mono 16 bit samples (L and R) to xfer.
	linearCount <<= 1;

	// transfer mono 16bit samples multiplying each sample by volume.
	for ( i=0; i<linearCount; i+=2 )
	{
		// L Channel
		val = ( pFront[i] * volumeFactor ) >> 8;
		*pOutput++ = iclip( val );

		// R Channel
		val = ( pFront[i+1] * volumeFactor ) >> 8;
		*pOutput++ = iclip( val );
	}

	return linearCount * DeviceSampleBytes();
}

//-----------------------------------------------------------------------------
// Fill the output buffer with interleaved surround samples
//-----------------------------------------------------------------------------
int CAudioXAudio::TransferSurroundInterleaved( const portable_samplepair_t *pFrontBuffer, const portable_samplepair_t *pRearBuffer, const portable_samplepair_t *pCenterBuffer, int paintedTime, int endTime, char *pOutputBuffer )
{
	int linearCount;
	int i, j;
	int	val;

	int volumeFactor = S_GetMasterVolume() * 256;

	int *pFront = (int *)pFrontBuffer;
	int *pRear = (int *)pRearBuffer;
	int *pCenter = (int *)pCenterBuffer;
	short *pOutput = (short *)pOutputBuffer;
	
	// number of mono samples per channel
	// number of sequential samples that can be wrriten
	linearCount = m_bufferSizeBytes/( DeviceSampleBytes() * ChannelCount() );		

	// clamp output count to requested number of samples
	if ( linearCount > endTime - paintedTime )	
	{	
		linearCount = endTime - paintedTime;
	}

	for ( i = 0, j = 0; i < linearCount; i++, j += 2 )
	{
		// FL
		val = ( pFront[j] * volumeFactor ) >> 8;
		*pOutput++ = iclip( val );

		// FR
		val = ( pFront[j+1] * volumeFactor ) >> 8;
		*pOutput++ = iclip( val );

		// Center
		val = ( pCenter[j] * volumeFactor) >> 8;
		*pOutput++ = iclip( val );

		// Let the hardware mix the sub from the main channels since
		// we don't have any sub-specific sounds, or direct sub-addressing
		*pOutput++ = 0;

		// RL
		val = ( pRear[j] * volumeFactor ) >> 8;
		*pOutput++ = iclip( val );

		// RR
		val = ( pRear[j+1] * volumeFactor ) >> 8;
		*pOutput++ = iclip( val );
	}

	return linearCount * DeviceSampleBytes() * ChannelCount();
}

//-----------------------------------------------------------------------------
// Transfer up to a full paintbuffer (PAINTBUFFER_SIZE) of samples out to the xaudio buffer(s).
//-----------------------------------------------------------------------------
void CAudioXAudio::TransferSamples( int64 endTime )
{
	XAUDIO2_BUFFER *pBuffer;

	if ( m_BufferHead - m_BufferTail >= MAX_XAUDIO2_BUFFERS )
	{
		DevWarning( "XAudio: No Free Buffers!\n" );
		return;
	}

	int sampleCount = endTime - g_paintedtime;
	if ( sampleCount > XAUDIO2_BUFFER_SAMPLES )
	{
		DevWarning( "XAudio: Overflowed mix buffer!\n" );
		endTime = g_paintedtime + XAUDIO2_BUFFER_SAMPLES;
	}

	unsigned int nBuffer = m_BufferHead++;
	pBuffer = &m_Buffers[nBuffer % MAX_XAUDIO2_BUFFERS];

	if ( !m_bSurround )
	{
		pBuffer->AudioBytes = TransferStereo( PAINTBUFFER, g_paintedtime, endTime, (char *)pBuffer->pAudioData );
	}
	else
	{
		pBuffer->AudioBytes = TransferSurroundInterleaved( PAINTBUFFER, REARPAINTBUFFER, CENTERPAINTBUFFER, g_paintedtime, endTime, (char *)pBuffer->pAudioData );
	}

    // submit buffer
	m_pSourceVoice->SubmitSourceBuffer( pBuffer );
}

//-----------------------------------------------------------------------------
// Get our device name
//-----------------------------------------------------------------------------
const char *CAudioXAudio::DeviceName( void )
{ 
	if ( m_bSurround )
	{
		return "XAudio: 5.1 Channel Surround";
	}

	return "XAudio: Stereo"; 
}

CXboxVoice::CXboxVoice()
{
	m_pXHVEngine = NULL;
}

//-----------------------------------------------------------------------------
// Initialize Voice
//-----------------------------------------------------------------------------
void CXboxVoice::VoiceInit( void )
{
	if ( !m_pXHVEngine )
	{
		// Set the processing modes
		XHV_PROCESSING_MODE rgMode = XHV_VOICECHAT_MODE;

		// Set up parameters for the voice chat engine
		XHV_INIT_PARAMS xhvParams = {0};
		xhvParams.dwMaxRemoteTalkers = g_pMatchFramework->GetMatchTitle()->GetTotalNumPlayersSupported();
		xhvParams.dwMaxLocalTalkers = XUSER_MAX_COUNT;
		xhvParams.localTalkerEnabledModes = &rgMode;
		xhvParams.remoteTalkerEnabledModes = &rgMode;
		xhvParams.dwNumLocalTalkerEnabledModes = 1;
		xhvParams.dwNumRemoteTalkerEnabledModes = 1;
		xhvParams.pXAudio2 = CAudioXAudio::m_pSingleton->GetXAudio2();

		// Create the engine
		HRESULT hr = XHV2CreateEngine( &xhvParams, NULL, &m_pXHVEngine );
		if ( hr != S_OK )
		{
			Warning( "Couldn't load XHV engine!\n" );
		}
	}

	memset( m_bUserRegistered, 0 ,sizeof( m_bUserRegistered ) );

	// Reset voice data for all ctrlrs
	for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
	{
		VoiceResetLocalData( k );
	}
}

void CXboxVoice::VoiceShutdown( void )
{
	if ( !m_pXHVEngine )
		return;
	
	m_pXHVEngine->Release();
	m_pXHVEngine = NULL;
}

void CXboxVoice::AddPlayerToVoiceList( XUID xPlayer, int iController, uint64 uiFlags )
{
#ifdef _X360
	XHV_PROCESSING_MODE local_proc_mode = XHV_VOICECHAT_MODE;

	if ( !xPlayer && iController >= 0 && iController < XUSER_MAX_COUNT )
	{
		// If was registered from previous time, then unregister
		if( m_bUserRegistered[ iController ] )
		{
			m_pXHVEngine->UnregisterLocalTalker( iController );
			m_bUserRegistered[ iController ] = false;
		}

		// Now register local talker
		if ( m_pXHVEngine->RegisterLocalTalker( iController ) == S_OK )
		{
			m_bUserRegistered[ iController ] = true;
			m_pXHVEngine->StartLocalProcessingModes( iController, &local_proc_mode, 1 );
		}
	}
	else if ( xPlayer )
	{
		HRESULT res = m_pXHVEngine->RegisterRemoteTalker( xPlayer, NULL, NULL, NULL );
		
		ConVarRef voice_verbose( "voice_verbose" );
		if ( voice_verbose.GetBool() )
		{
			Msg( "* CXboxVoice::AddPlayerToVoiceList: Registering %llx returned 0x%08x\n", xPlayer, res );
		}

		if ( res == S_OK )
		{
			m_pXHVEngine->StartRemoteProcessingModes( xPlayer, &local_proc_mode, 1 );
		}
	}
	else
	{
		Assert( 0 );
	}
#endif
}

void CXboxVoice::RemovePlayerFromVoiceList( XUID xPlayer, int iController )
{
	if ( !xPlayer && iController >= 0 && iController < XUSER_MAX_COUNT )
	{
		if( m_bUserRegistered[ iController ] )
		{
			m_pXHVEngine->UnregisterLocalTalker( iController );
			m_bUserRegistered[ iController ] = false;
		}
	}
	else if ( xPlayer )
	{
		m_pXHVEngine->UnregisterRemoteTalker( xPlayer );
	}
	else
	{
		Assert( 0 );
	}
}

#ifdef _X360
ConVar voice_xplay_debug( "voice_xplay_debug", "0" );
#endif

void CXboxVoice::PlayIncomingVoiceData( XUID xuid, const byte *pbData, unsigned int dwDataSize, const bool *bAudiblePlayers )
{
	ConVarRef voice_verbose( "voice_verbose" );
#ifdef _X360
	static double s_flLastCheckedTime = 0.0;
	static const double s_flCheckFreq = 0.5;

	double flTime = Plat_FloatTime();
	if ( flTime - s_flLastCheckedTime > s_flCheckFreq )
	{
		s_flLastCheckedTime = flTime;

		// Register all idle signed in players
		for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
		{
			bool bSignedIn = !( XUserGetSigninState( k ) == eXUserSigninState_NotSignedIn );
			if ( m_bUserRegistered[k] == bSignedIn )
				continue;

			XHV_PROCESSING_MODE local_proc_mode = XHV_VOICECHAT_MODE;
			if ( bSignedIn )
			{
				if ( m_pXHVEngine->RegisterLocalTalker( k ) == S_OK )
				{
					m_bUserRegistered[ k ] = true;
					m_pXHVEngine->StartLocalProcessingModes( k, &local_proc_mode, 1 );
				}
			}
			else
			{
				m_pXHVEngine->UnregisterLocalTalker( k );
				m_bUserRegistered[ k ] = false;
			}

			// Notify matchmaking that local talkers have changed
			g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnSysMuteListChanged" ) );
		}
	}
#endif

	for ( DWORD dwSlot = 0; dwSlot < XBX_GetNumGameUsers(); ++ dwSlot )
	{
		int iCtrlr = XBX_GetUserId( dwSlot );
		IPlayerLocal *pPlayer = g_pMatchFramework->GetMatchSystem()->GetPlayerManager()->GetLocalPlayer( iCtrlr );
		if ( pPlayer && pPlayer->GetXUID() == xuid )
		{
			 //Hack: Don't play stuff that comes from ourselves.
			if ( voice_verbose.GetBool() )
			{
				Msg( "* CXboxVoice::PlayIncomingVoiceData: dropping voice data from self with dwBytes %u\n", dwDataSize );
			}
			 return;
		}
	}

	if ( g_pMatchFramework->GetMatchSystem()->GetMatchVoice()->CanPlaybackTalker( xuid ) )
	{
		// Set the playback priority for talkers that we can't hear due to game rules.
		for ( DWORD dwSlot = 0; dwSlot < XBX_GetNumGameUsers(); ++dwSlot )
		{
			bool bCanHearPlayer = !bAudiblePlayers || bAudiblePlayers[dwSlot];

			// Check if the client thinks the player is audible
			if ( !bAudiblePlayers )
			{
				for ( int iClient = 0; iClient < GetBaseLocalClient().m_nMaxClients; iClient++ )
				{
					int iIndex = iClient + 1;
					player_info_t infoClient;
					if ( engineClient->GetPlayerInfo( iIndex, &infoClient ) )
					{
						if ( xuid == infoClient.xuid )
						{
							bCanHearPlayer = g_pSoundServices->GetPlayerAudible( iIndex );
							break;
						}
					}
				}
			}

			if ( voice_xplay_debug.GetBool() )
			{
				DevMsg( "XVoiceDebug: %llx -> %d = %s\n", xuid, XBX_GetUserId( dwSlot ), bCanHearPlayer ? "yes" : "no" );
			}
			m_pXHVEngine->SetPlaybackPriority( xuid, XBX_GetUserId( dwSlot ), bCanHearPlayer ? XHV_PLAYBACK_PRIORITY_MAX : XHV_PLAYBACK_PRIORITY_NEVER );
		}

		// For idle users who are simply signed in on the console, but do not participate in the game
		for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
		{
			if ( m_bUserRegistered[k] && ( XBX_GetSlotByUserId( k ) < 0 ) )
			{
				if ( voice_xplay_debug.GetBool() )
				{
					DevMsg( "XVoiceDebug: %llx -> %d = idle\n", xuid, k );
				}
				m_pXHVEngine->SetPlaybackPriority( xuid, k, XHV_PLAYBACK_PRIORITY_NEVER );
			}
		}
	}
	else
	{
		// Cannot submit voice for the player that we are not allowed to playback!
		if ( voice_xplay_debug.GetBool() )
		{
			DevMsg( "XVoiceDebug: %llx muted\n", xuid );
		}
		return;
	}

	DWORD dwApiSize = dwDataSize;
	HRESULT hrSubmit = m_pXHVEngine->SubmitIncomingChatData( xuid, pbData, &dwApiSize );
	if ( voice_verbose.GetBool() )
	{
		Msg( "* CXboxVoice::PlayIncomingVoiceData: SubmitIncomingChatData with %u bytes returned 0x%08x and copied dwBytes %u\n", dwDataSize, hrSubmit, dwApiSize );
	}
}


void CXboxVoice::UpdateHUDVoiceStatus( void )
{
	for ( int iClient = 0; iClient < GetBaseLocalClient().m_nMaxClients; iClient++ )
	{
		// Information about local client if it's a local client speaking
		bool bLocalClient = false;
		int iSsSlot = -1;
		int iCtrlr = -1;

		// Detection if it's a local client
		for ( DWORD k = 0; k < XBX_GetNumGameUsers(); ++ k )
		{
			CClientState &cs = GetLocalClient( k );
			if ( cs.m_nPlayerSlot == iClient )
			{
				bLocalClient = true;
				iSsSlot = k;
				iCtrlr = XBX_GetUserId( iSsSlot );
			}
		}

		// Convert into index and XUID
		int iIndex = iClient + 1;
		XUID xid =  NULL;
		player_info_t infoClient;
		if ( engineClient->GetPlayerInfo( iIndex, &infoClient ) )
		{
			xid = infoClient.xuid;
		}
		
		// [jason] skip any bots - we don't want to override their voice status from the chatter
		if ( infoClient.fakeplayer )
			continue;

		if ( !xid )
			// No XUID means no VOIP
		{
			g_pSoundServices->OnChangeVoiceStatus( iIndex, -1, false );
			if ( bLocalClient )
				g_pSoundServices->OnChangeVoiceStatus( iIndex, iSsSlot, false );
			continue;
		}

		// Determine talking status
		bool bTalking = false;

		if ( bLocalClient )
		{
			//Make sure the player's own "remote" label is not on.
			g_pSoundServices->OnChangeVoiceStatus( iIndex, -1, false );
			iIndex = -1; // issue notification as ent=-1
			bTalking = IsLocalPlayerTalking( iCtrlr );
		}
		else
		{
			bTalking = IsPlayerTalking( xid );
		}
	
		g_pSoundServices->OnChangeVoiceStatus( iIndex, iSsSlot, bTalking );
	}
}

bool CXboxVoice::VoiceUpdateData( int iCtrlr  )
{
	DWORD dwNumPackets = 0;
	DWORD dwBytes = 0;
	WORD wVoiceBytes = 0;
	bool bShouldSend = false;
	DWORD dwVoiceFlags = m_pXHVEngine->GetDataReadyFlags();

	//Update UI stuff.
	UpdateHUDVoiceStatus();

	while ( 1 )
	{
		int i = iCtrlr;

		if ( IsHeadsetPresent( i ) == false )
			break;

		if ( !(dwVoiceFlags & ( 1 << i )) )
			break;
  
		dwBytes = m_ChatBufferSize - m_wLocalDataSize[i];

		if( dwBytes < XHV_VOICECHAT_MODE_PACKET_SIZE )
		{
			bShouldSend = true;
		}
		else
		{
			HRESULT hr = m_pXHVEngine->GetLocalChatData( i, m_ChatBuffer[i] + m_wLocalDataSize[i], &dwBytes, &dwNumPackets );
			
			ConVarRef voice_verbose( "voice_verbose" );
			if ( voice_verbose.GetBool() )
			{
				Msg( "* CXboxVoice::VoiceUpdateData: GetLocalChatData for user %d returned 0x%08x with dwBytes %u and dwNumPackets %u\n", i, hr, dwBytes, dwNumPackets );
			}

			m_wLocalDataSize[i] += ((WORD)dwBytes) & MAXWORD;

			if( m_wLocalDataSize[i] > ( ( m_ChatBufferSize * 7 ) / 10 ) )
			{
				bShouldSend = true;
			}
		}

		wVoiceBytes += m_wLocalDataSize[i] & MAXWORD;
		break;
	}

	return  bShouldSend || 
		( wVoiceBytes && 
		( GetTickCount() - m_dwLastVoiceSend[ iCtrlr ] ) > MAX_VOICE_BUFFER_TIME );
}

void CXboxVoice::SetPlaybackPriority( XUID remoteTalker, int iController, int iAllowPlayback )
{
	XHV_PLAYBACK_PRIORITY playbackPriority = iAllowPlayback ? XHV_PLAYBACK_PRIORITY_MAX : XHV_PLAYBACK_PRIORITY_NEVER;

	// DevMsg( "[XAUDIO] SetPlaybackPriority %I64x %d %08X\n", remoteTalker, dwUserIndex, playbackPriority );
	m_pXHVEngine->SetPlaybackPriority( remoteTalker, iController, playbackPriority );

#ifdef _X360
	// When setting NEVER playback priority, make sure it is set for all controllers
	if ( playbackPriority == XHV_PLAYBACK_PRIORITY_NEVER )
	{
		for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
		{
			m_pXHVEngine->SetPlaybackPriority( remoteTalker, k, playbackPriority );
		}
	}
#endif
}

void CXboxVoice::GetRemoteTalkers( int *pNumTalkers, XUID *pRemoteTalkers )
{
	m_pXHVEngine->GetRemoteTalkers( (DWORD*)pNumTalkers, pRemoteTalkers );
}

void CXboxVoice::GetVoiceData( int iCtrlr, CCLCMsg_VoiceData_t *pMessage )
{
	IPlayerLocal *pPlayer = g_pMatchFramework->GetMatchSystem()->GetPlayerManager()->GetLocalPlayer( iCtrlr );
	pMessage->set_xuid( pPlayer ? pPlayer->GetXUID() : 0ull );
	if ( !pMessage->xuid() )
		return;

	if ( !m_wLocalDataSize[ iCtrlr ] ) 
		return;

	pMessage->set_data( m_ChatBuffer[ iCtrlr ], m_wLocalDataSize[ iCtrlr ] );
}

void CXboxVoice::GetVoiceData( int iController, const byte **ppvVoiceDataBuffer, unsigned int *pnumVoiceDataBytes )
{
	*pnumVoiceDataBytes = m_wLocalDataSize[ iController ];
	*ppvVoiceDataBuffer = m_ChatBuffer[ iController ];
}

void CXboxVoice::VoiceSendData( int iCtrlr, INetChannel *pChannel )
{
	CCLCMsg_VoiceData_t voiceMsg;
	GetVoiceData( iCtrlr, &voiceMsg );

	if ( pChannel )
	{
		pChannel->SendNetMsg( voiceMsg, false, true );
		VoiceResetLocalData( iCtrlr );
	}
}

void CXboxVoice::VoiceResetLocalData( int iCtrlr )
{
	m_dwLastVoiceSend[ iCtrlr ] = GetTickCount();
	Q_memset( m_ChatBuffer[ iCtrlr ], 0, m_ChatBufferSize );
	m_wLocalDataSize[ iCtrlr ] = 0;
}

#pragma warning(push) // warning C4800 is meaningless or worse
#pragma warning( disable: 4800 )
bool CXboxVoice::IsLocalPlayerTalking( int controllerID )
{
	return m_pXHVEngine->IsLocalTalking( controllerID ) != 0;
}

bool CXboxVoice::IsPlayerTalking( XUID uid )
{
#ifdef _X360
	if ( !g_pMatchFramework->GetMatchSystem()->GetMatchVoice()->CanPlaybackTalker( uid ) )
		return false;

	return m_pXHVEngine->IsRemoteTalking( uid ) != 0;
#else
	return false;
#endif
}

bool CXboxVoice::IsHeadsetPresent( int id )
{
	return m_pXHVEngine->IsHeadsetPresent( id ) != 0;
}
#pragma warning(pop)

void CXboxVoice::RemoveAllTalkers()
{
#ifdef _X360
	int numRemoteTalkers;
	CArrayAutoPtr< XUID > remoteTalkers( new XUID[ g_pMatchFramework->GetMatchTitle()->GetTotalNumPlayersSupported() ] );
	GetRemoteTalkers( &numRemoteTalkers, remoteTalkers.Get() );

	for ( int iRemote = 0; iRemote < numRemoteTalkers; iRemote++ )
	{
		m_pXHVEngine->UnregisterRemoteTalker( remoteTalkers[iRemote] );
	}

	for ( int i = 0; i < XUSER_MAX_COUNT; ++i )
	{
		if( !m_bUserRegistered[ i ] )
			continue;

		m_pXHVEngine->UnregisterLocalTalker( i );
		m_bUserRegistered[ i ] = false;
	}
#endif
}

EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CXboxVoice, IEngineVoice,
								  IENGINEVOICE_INTERFACE_VERSION, *Audio_GetXVoice() );