diff options
Diffstat (limited to 'engine/audio/private/snd_dev_xaudio.cpp')
| -rw-r--r-- | engine/audio/private/snd_dev_xaudio.cpp | 872 |
1 files changed, 872 insertions, 0 deletions
diff --git a/engine/audio/private/snd_dev_xaudio.cpp b/engine/audio/private/snd_dev_xaudio.cpp new file mode 100644 index 0000000..1601701 --- /dev/null +++ b/engine/audio/private/snd_dev_xaudio.cpp @@ -0,0 +1,872 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: X360 XAudio Version +// +//=====================================================================================// + + +#include "audio_pch.h" +#include "snd_dev_xaudio.h" +#include "UtlLinkedList.h" +#include "session.h" +#include "server.h" +#include "client.h" +#include "matchmaking.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 8192 +// 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_packets( "snd_xaudio_spew_packets", "0", 0, "Spew XAudio packet delivery" ); + + + +//----------------------------------------------------------------------------- +// Implementation of XAudio +//----------------------------------------------------------------------------- +class CAudioXAudio : public CAudioDeviceBase +{ +public: + ~CAudioXAudio( void ); + + bool IsActive( void ) { return true; } + bool Init( void ); + void Shutdown( void ); + + void Pause( void ); + void UnPause( void ); + int PaintBegin( float mixAheadTime, int soundtime, int paintedtime ); + int GetOutputPosition( void ); + void ClearBuffer( void ); + void TransferSamples( int end ); + + const char *DeviceName( void ); + int DeviceChannels( void ) { return m_deviceChannels; } + int DeviceSampleBits( void ) { return m_deviceSampleBits; } + int DeviceSampleBytes( void ) { return m_deviceSampleBits/8; } + int DeviceDmaSpeed( void ) { return m_deviceDmaSpeed; } + int DeviceSampleCount( void ) { return m_deviceSampleCount; } + + + + void XAudioPacketCallback( 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_deviceChannels; // channels per hardware output buffer (1 for quad/5.1, 2 for stereo) + int m_deviceSampleBits; // bits per sample (16) + int m_deviceSampleCount; // count of mono samples in output buffer + int m_deviceDmaSpeed; // samples per second per 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; + +//----------------------------------------------------------------------------- +// XAudio packet completion callback +//----------------------------------------------------------------------------- +class XAudio2VoiceCallback : public IXAudio2VoiceCallback +{ +public: + XAudio2VoiceCallback() {} + ~XAudio2VoiceCallback() {} + + void OnStreamEnd() {} + + void OnVoiceProcessingPassEnd() {} + + void OnVoiceProcessingPassStart( UINT32 SamplesRequired ) {} + + void OnBufferEnd( void *pBufferContext ) + { + CAudioXAudio::m_pSingleton->XAudioPacketCallback( (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( void ) +{ + MEM_ALLOC_CREDIT(); + + if ( !CAudioXAudio::m_pSingleton ) + { + CAudioXAudio::m_pSingleton = new CAudioXAudio; + } + + if ( !CAudioXAudio::m_pSingleton->Init() ) + { + delete CAudioXAudio::m_pSingleton; + CAudioXAudio::m_pSingleton = NULL; + } + + 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; + XAudioGetSpeakerConfig( &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_deviceChannels = 2; + break; + + default: + case SURROUND_STEREO: + m_deviceChannels = 2; + break; + + case SURROUND_DIGITAL5DOT1: + m_bSurround = true; + m_bSurroundCenter = true; + m_deviceChannels = 6; + break; + } + + m_deviceSampleBits = 16; + m_deviceDmaSpeed = 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_deviceChannels; + waveFormatEx.nSamplesPerSec = m_deviceDmaSpeed; + 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_deviceChannels, volumes ); + + m_bufferSizeBytes = XAUDIO2_BUFFER_SAMPLES * (m_deviceSampleBits/8) * m_deviceChannels; + 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 / DeviceChannels(); + + // 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(), DeviceChannels(), DeviceSampleBits(), DeviceDmaSpeed() ); + + m_VoiceData.VoiceInit(); + + // 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 packet. Assuming these are sequential +//----------------------------------------------------------------------------- +void CAudioXAudio::XAudioPacketCallback( int hCompletedBuffer ) +{ + // packet completion expected to be sequential + Assert( hCompletedBuffer == (int)( m_PacketTail % MAX_XAUDIO2_BUFFERS ) ); + + m_BufferTail++; + + if ( snd_xaudio_spew_packets.GetBool() ) + { + if ( m_BufferTail == m_BufferHead ) + { + Warning( "XAudio: Starved\n" ); + } + else + { + Msg( "XAudio: Packet 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 packets, xaudio is starving + // mix thread didn't keep up with audio clock and submit packets + // 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( 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 +//----------------------------------------------------------------------------- +int CAudioXAudio::PaintBegin( float mixAheadTime, int soundtime, int 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(); + int endtime = soundtime + mixaheadtime; + if ( endtime <= paintedtime ) + { + return endtime; + } + + int fullsamps = DeviceSampleCount() / DeviceChannels(); + + 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 = g_AudioDevice->DeviceSampleCount() >> 1; + + // 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++ = CLIP( val ); + + // R Channel + val = ( pFront[i+1] * volumeFactor ) >> 8; + *pOutput++ = CLIP( 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() * DeviceChannels() ); + + // 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++ = CLIP( val ); + + // FR + val = ( pFront[j+1] * volumeFactor ) >> 8; + *pOutput++ = CLIP( val ); + + // Center + val = ( pCenter[j] * volumeFactor) >> 8; + *pOutput++ = CLIP( 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++ = CLIP( val ); + + // RR + val = ( pRear[j+1] * volumeFactor ) >> 8; + *pOutput++ = CLIP( val ); + } + + return linearCount * DeviceSampleBytes() * DeviceChannels(); +} + +//----------------------------------------------------------------------------- +// Transfer up to a full paintbuffer (PAINTBUFFER_SIZE) of samples out to the xaudio buffer(s). +//----------------------------------------------------------------------------- +void CAudioXAudio::TransferSamples( int 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 = MAX_PLAYERS; + 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" ); + } + } + + VoiceResetLocalData( ); +} + +void CXboxVoice::VoiceShutdown( void ) +{ + if ( !m_pXHVEngine ) + return; + + m_pXHVEngine->Release(); + m_pXHVEngine = NULL; +} + +void CXboxVoice::AddPlayerToVoiceList( CClientInfo *pClient, bool bLocal ) +{ + XHV_PROCESSING_MODE local_proc_mode = XHV_VOICECHAT_MODE; + + for ( int i = 0; i < pClient->m_cPlayers; ++i ) + { + if ( pClient->m_xuids[i] == 0 ) + continue; + + if ( bLocal == true ) + { + if ( m_pXHVEngine->RegisterLocalTalker( pClient->m_iControllers[i] ) == S_OK ) + { + m_pXHVEngine->StartLocalProcessingModes( pClient->m_iControllers[i], &local_proc_mode, 1 ); + } + } + else + { + if ( m_pXHVEngine->RegisterRemoteTalker( pClient->m_xuids[i], NULL, NULL, NULL ) == S_OK ) + { + m_pXHVEngine->StartRemoteProcessingModes( pClient->m_xuids[i], &local_proc_mode, 1 ); + } + } + } +} + +void CXboxVoice::RemovePlayerFromVoiceList( CClientInfo *pClient, bool bLocal ) +{ + for ( int i = 0; i < pClient->m_cPlayers; ++i ) + { + if ( pClient->m_xuids[i] == 0 ) + continue; + + if ( bLocal == true ) + { + m_pXHVEngine->UnregisterLocalTalker( pClient->m_iControllers[i] ); + } + else + { + m_pXHVEngine->UnregisterRemoteTalker( pClient->m_xuids[i] ); + } + } +} + +void CXboxVoice::PlayIncomingVoiceData( XUID xuid, const byte *pbData, DWORD pdwSize ) +{ + XUID localXUID; + + XUserGetXUID( XBX_GetPrimaryUserId(), &localXUID ); + + //Hack: Don't play stuff that comes from ourselves. + if ( localXUID == xuid ) + return; + + m_pXHVEngine->SubmitIncomingChatData( xuid, pbData, &pdwSize ); +} + + +void CXboxVoice::UpdateHUDVoiceStatus( void ) +{ + for ( int iClient = 0; iClient < cl.m_nMaxClients; iClient++ ) + { + bool bSelf = (cl.m_nPlayerSlot == iClient); + + int iIndex = iClient + 1; + XUID id = g_pMatchmaking->PlayerIdToXuid( iIndex ); + + if ( id != 0 ) + { + bool bTalking = false; + + if ( bSelf == true ) + { + //Make sure the player's own label is not on. + g_pSoundServices->OnChangeVoiceStatus( iIndex, false ); + + iIndex = -1; + + if ( IsPlayerTalking( XBX_GetPrimaryUserId(), true ) ) + { + bTalking = true; + } + } + else + { + if ( IsPlayerTalking( id, false ) ) + { + bTalking = true; + } + } + + g_pSoundServices->OnChangeVoiceStatus( iIndex, bTalking ); + } + else + { + g_pSoundServices->OnChangeVoiceStatus( iIndex, false ); + } + } +} + +bool CXboxVoice::VoiceUpdateData( void ) +{ + DWORD dwNumPackets = 0; + DWORD dwBytes = 0; + WORD wVoiceBytes = 0; + bool bShouldSend = false; + DWORD dwVoiceFlags = m_pXHVEngine->GetDataReadyFlags(); + + //Update UI stuff. + UpdateHUDVoiceStatus(); + + for ( uint i = 0; i < XUSER_MAX_COUNT; ++i ) + { + // We currently only allow one player per console + if ( i != XBX_GetPrimaryUserId() ) + { + continue; + } + + if ( IsHeadsetPresent( i ) == false ) + continue; + + if ( !(dwVoiceFlags & ( 1 << i )) ) + continue; + + dwBytes = m_ChatBufferSize - m_wLocalDataSize; + + if( dwBytes < XHV_VOICECHAT_MODE_PACKET_SIZE ) + { + bShouldSend = true; + } + else + { + m_pXHVEngine->GetLocalChatData( i, m_ChatBuffer + m_wLocalDataSize, &dwBytes, &dwNumPackets ); + m_wLocalDataSize += ((WORD)dwBytes) & MAXWORD; + + if( m_wLocalDataSize > ( ( m_ChatBufferSize * 7 ) / 10 ) ) + { + bShouldSend = true; + } + } + + wVoiceBytes += m_wLocalDataSize & MAXWORD; + break; + } + + return bShouldSend || + ( wVoiceBytes && + ( GetTickCount() - m_dwLastVoiceSend ) > MAX_VOICE_BUFFER_TIME ); +} + +void CXboxVoice::SetPlaybackPriority( XUID remoteTalker, DWORD dwUserIndex, XHV_PLAYBACK_PRIORITY playbackPriority ) +{ + m_pXHVEngine->SetPlaybackPriority( remoteTalker, dwUserIndex, playbackPriority ); +} + +void CXboxVoice::GetRemoteTalkers( int *pNumTalkers, XUID *pRemoteTalkers ) +{ + m_pXHVEngine->GetRemoteTalkers( (DWORD*)pNumTalkers, pRemoteTalkers ); +} + +void CXboxVoice::GetVoiceData( CLC_VoiceData *pMessage ) +{ + byte *puchVoiceData = NULL; + pMessage->m_nLength = m_wLocalDataSize; + XUserGetXUID( XBX_GetPrimaryUserId(), &pMessage->m_xuid ); + + puchVoiceData = m_ChatBuffer; + + pMessage->m_DataOut.StartWriting( puchVoiceData, pMessage->m_nLength ); + pMessage->m_nLength *= 8; + pMessage->m_DataOut.SeekToBit( pMessage->m_nLength ); // set correct writing position +} + +void CXboxVoice::VoiceSendData( INetChannel *pChannel ) +{ + CLC_VoiceData voiceMsg; + GetVoiceData( &voiceMsg ); + + if ( pChannel ) + { + pChannel->SendNetMsg( voiceMsg, false, true ); + VoiceResetLocalData(); + } +} + +void CXboxVoice::VoiceResetLocalData( void ) +{ + m_wLocalDataSize = 0; + m_dwLastVoiceSend = GetTickCount(); + Q_memset( m_ChatBuffer, 0, m_ChatBufferSize ); +} + +bool CXboxVoice::IsPlayerTalking( XUID uid, bool bLocal ) +{ + if ( bLocal == true ) + { + return m_pXHVEngine->IsLocalTalking( XBX_GetPrimaryUserId() ); + } + else + { + return !g_pMatchmaking->IsPlayerMuted( XBX_GetPrimaryUserId(), uid ) && m_pXHVEngine->IsRemoteTalking( uid ); + } + + return false; +} + +bool CXboxVoice::IsHeadsetPresent( int id ) +{ + return m_pXHVEngine->IsHeadsetPresent( id ); +} + +void CXboxVoice::RemoveAllTalkers( CClientInfo *pLocal ) +{ + int numRemoteTalkers; + XUID remoteTalkers[MAX_PLAYERS]; + GetRemoteTalkers( &numRemoteTalkers, remoteTalkers ); + + for ( int iRemote = 0; iRemote < numRemoteTalkers; iRemote++ ) + { + m_pXHVEngine->UnregisterRemoteTalker( remoteTalkers[iRemote] ); + } + + if ( pLocal ) + { + for ( int i = 0; i < pLocal->m_cPlayers; ++i ) + { + if ( pLocal->m_xuids[i] == 0 ) + continue; + + m_pXHVEngine->UnregisterLocalTalker( pLocal->m_iControllers[i] ); + } + } +}
\ No newline at end of file |