csgo/cstrike15_src/engine/audio/private/snd_dev_ps3audio.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 "vjobs/sndupsampler_shared.h"

// from PS3
#include <sysutil/sysutil_sysparam.h>
#include <cell/audio.h>
#include <sys/event.h>
#include <cell/sysmodule.h> 
#include <cell/mic.h>
#include <cell/voice.h>

#include <vjobs_interface.h>
#include <vjobs/root.h>
#include <ps3/vjobutils.h>

#include <vjobs/sndupsampler_shared.h>
#include <ps3/vjobutils_shared.h>

#include "engine/IPS3FrontPanelLED.h"

#include <tier0/microprofiler.h>

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#include "sys/tty.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

#define ENABLE_SOUND_DEBUG 0
#define SOUND_PC_CELP_SUPPORTED

extern IVEngineClient *engineClient;
extern IVJobs * g_pVJobs;

ConVar snd_ps3_back_channel_multiplier( "snd_ps3_back_channel_multiplier", "0" );

//-----------------------------------------------------------------------------
// An ugly workaround: our sound mixing library outputs at 44.1khz; PS3 inputs
// at 48khz. We'll probably need to replace the mixer wholesale, but for now,
// add an upsampling stage to the pipeline.
//-----------------------------------------------------------------------------
class CAudioIckyUpsampler // a non-virtual class
{
public:
	// local constants
	enum ConstEnum_t
	{
		INPUTFREQ  = job_sndupsampler::INPUTFREQ,
		OUTPUTFREQ = job_sndupsampler::OUTPUTFREQ,
		BUFFERSIZE = job_sndupsampler::BUFFERSIZE, // < input samples, should be a power of two
	};
	
	CThreadMutex m_mutex;

	CAudioIckyUpsampler();
	~CAudioIckyUpsampler(); // NON-VIRTUAL .. mark virtual if you inherit from here

	// initialize to stereo or surround. Can be called again to reinitialize.
	void Init( bool surround );
		
	// take in some number of input samples. Returns the number actually consumed (the buffer might be full)
	int IngestStereo( portable_samplepair_t *pInputSamples, int numSamples ) RESTRICT;
	int IngestSurround( portable_samplepair_t *pInputStereo, portable_samplepair_t *pInputSurround, portable_samplepair_t *pInputCenter, int numSamples ) RESTRICT;

	// upsample and emit the left and right channels into an interleaved float stream.
	// scalar gets multiplied onto each sample as it's written (ie to rescale -32767..32767 -> -1..1
	// returns number of samples actually emitted.
	// assumes PS3 interleaving (
	/*
	// you specify a pointer to the left channel, an offset (in words) between the left and right 
	// channel, and the stride between successive samples. Returns the number of samples actually
	// emitted.
	// scalar gets multiplied onto each sample as it's written (ie to rescale -32767..32767 -> -1..1
	int Excrete( uint nSamplesRequested, float *pOutSamples, int nLeftToRightOffset, int nstride, float scalar );
	*/
	// We output stereo in a surround channel.
	int ExcreteStereo( uint nSamplesRequested, libaudio_sample_surround_t *pOutSamples, float scalar ) RESTRICT;
	int ExcreteSurround(  uint nSamplesRequested, libaudio_sample_surround_t *pOutSamples, float scalar  ) RESTRICT;

	/// dump all data
	void Flush();

	// the number of INPUT samples already in the buffer
	inline int Count();
	inline int SpaceRemaining() { return BUFFERSIZE - Count(); }
	int OutputSamplesAvailable(); 	
	inline bool IsSurround() { return m_bSurround; }
public:
	/// ring buffers: one interleaved pair for stereo, or five channels for surround.
	/// I compress them back to signed shorts to conserve memory bandwidth.
	typedef job_sndupsampler::stereosample_t stereosample_t;
	typedef job_sndupsampler::surroundsample_t surroundsample_t;

	union // the pointer to the input buffer of samples at 44k
	{
		stereosample_t *m_p44kStereoIn;
		surroundsample_t *m_p44kSurroundIn;
		uintp m_ea44kSamplesIn;
	};

	// size in bytes of an input sample for the current channel mode 
	inline int InputSampleSizeof( ) { return m_bSurround ? sizeof(surroundsample_t) : sizeof(stereosample_t); }

	CInterlockedInt m_ringHead; ///< "head" of the buffer, the first sample Excrete() will look at
	CInterlockedInt m_ringCount; ///< number of samples in the buffer
	float m_fractionalSamples; ///< we will have some fractional number of samples still waiting to be sent. ie 0.2f means we still have temporally 80% of the HEAD sample to emit.
	bool m_bSurround; // set to surround sound mode
};

CAudioIckyUpsampler::CAudioIckyUpsampler()
	: m_ringHead( 0 )
	, m_ringCount( 0 )
	, m_fractionalSamples( 0 )
	, m_p44kStereoIn( NULL )
	, m_bSurround( false )
{
}


CAudioIckyUpsampler::~CAudioIckyUpsampler()
{
	if ( IsSurround() ) 
		MemAlloc_FreeAligned( m_p44kSurroundIn );
	else
		MemAlloc_FreeAligned( m_p44kStereoIn );
	m_p44kStereoIn = NULL;
}

void CAudioIckyUpsampler::Init( bool surround )
{
	// there's a buffer already, toss it. (in certain cases could just recycle it, but it's unlikely that this is ever actually called twice)
	if ( m_p44kStereoIn != NULL ) 
	{
		MemAlloc_FreeAligned( m_p44kStereoIn );
		m_p44kStereoIn = NULL;
	}
	
	// Note : we need to allocate aligned memory so that when DMA'ing ring buffer that wraps around,
	//        there's no hole at the wrap point (so the end and start of the buffer must be aligned

	if ( m_bSurround = surround ) 
	{	// we are in surround mode
		m_p44kSurroundIn = ( surroundsample_t* ) MemAlloc_AllocAligned( sizeof( surroundsample_t ) * BUFFERSIZE, 16 );
		memset( m_p44kSurroundIn, 0, sizeof(surroundsample_t)*BUFFERSIZE );
	}
	else
	{	// stereo mode
		m_p44kStereoIn = ( stereosample_t* )MemAlloc_AllocAligned( sizeof( stereosample_t ) * BUFFERSIZE, 16 );
		memset( m_p44kStereoIn, 0, sizeof(stereosample_t)*BUFFERSIZE );
	}
}

void CAudioIckyUpsampler::Flush()
{
	AUTO_LOCK( m_mutex ); // TODO: get rid of this lock, use head-tail counters instead of head+count
	m_fractionalSamples = 0;
	m_ringHead = m_ringCount = 0;
}

inline int CAudioIckyUpsampler::Count()
{
	return m_ringCount;
}

int CAudioIckyUpsampler::IngestStereo( portable_samplepair_t * RESTRICT pInputSamples, int numSamples ) RESTRICT 
{
	if ( IsSurround() )
	{
		Error( "Audio: Tried to ingest stereo data into a surround upsampler!\n" );
	}

	const int nSamplesToConsume = MIN( numSamples, SpaceRemaining() ); 
	int i,o;
	for ( i = 0, o = (m_ringHead + m_ringCount)%BUFFERSIZE  ; 
		  i < nSamplesToConsume								; 
		  ++i, o = (o + 1)%BUFFERSIZE						) // power-of-two mods become ands 
	{
		m_p44kStereoIn[ o ].left = pInputSamples[i].left;
		m_p44kStereoIn[ o ].right = pInputSamples[i].right;
	}

	m_ringCount += nSamplesToConsume;
	return nSamplesToConsume;	
	

	// ------------------------------------------
	// PURELY FOR EXAMPLE: a basic sine wave test
	if ( false ) {
		int q = 0 ;
		while ( q++ < numSamples && m_ringCount < BUFFERSIZE )
		{
			int i = (m_ringHead + m_ringCount)%BUFFERSIZE;
		
			float f = sin( ( i & 0x100 ? (2.0/256.0) : (2.0/128.0)) * M_PI * i ) * 20000;
			m_p44kStereoIn[i].left = f;
			m_p44kStereoIn[i].right = f;
			
			++m_ringCount;
		}
		return numSamples; 
	}
}

int CAudioIckyUpsampler::IngestSurround( portable_samplepair_t * RESTRICT pInputStereo, portable_samplepair_t * RESTRICT pInputSurround, portable_samplepair_t * RESTRICT pInputCenterAsPairs, int numSamples ) RESTRICT 
{
	if ( !IsSurround() )
	{
		Error( "Audio: Tried to ingest stereo data into a surround upsampler!\n" );
	}

	const int nSamplesToConsume = MIN( numSamples, SpaceRemaining() ); 
	int i,o;
	for ( i = 0, o = (m_ringHead + m_ringCount)%BUFFERSIZE  ; 
		i < nSamplesToConsume								; 
		++i, o = (o + 1)%BUFFERSIZE						) // power-of-two mods become ands 
	{
		// hopefully the compiler knows how to pipeline these intelligently ( should be >1 IPC )
		m_p44kSurroundIn[ o ].left = pInputStereo[i].left;
		m_p44kSurroundIn[ o ].right = pInputStereo[i].right;
		m_p44kSurroundIn[ o ].center = pInputCenterAsPairs[i].left;		// Center is stored as left / right, but only left contains the necessary information
		m_p44kSurroundIn[ o ].surleft = pInputSurround[i].left;
		m_p44kSurroundIn[ o ].surright = pInputSurround[i].right;
	}

	m_ringCount += nSamplesToConsume;
	return nSamplesToConsume;	
}

#pragma message("TODO: obvious optimization opportunities")
// TODO: move to SPU  -- many obvious optimization opportunities
float g_flSumStereo;
int CAudioIckyUpsampler::ExcreteStereo( uint nSamplesRequested, libaudio_sample_surround_t * RESTRICT pOutSamples, float scalar ) RESTRICT 
{
	Assert( !IsSurround() );
	// do a braindead linear interpolation
	float t = m_fractionalSamples;
	float tstep = ((float)INPUTFREQ)/((float) OUTPUTFREQ);
	const int nSamplesToEmit = MIN( OutputSamplesAvailable(), nSamplesRequested );

	int curSamp = m_ringHead;
	int nextSamp = (curSamp + 1) & (BUFFERSIZE - 1);
	int n44kSamplesConsumed = 0;
	//  iterator
	for ( int iRemain = nSamplesToEmit ; 
		  iRemain > 0				   ; 
		  t += tstep, --iRemain )
	{
		// if we've passed a sample boundary, go onto the next sample
		if ( t >= 1.0f ) // ugh, fcmp, it's just a hacky prototype
		{
			t -= 1.0f;
			curSamp = nextSamp;
			nextSamp = (curSamp + 1) & (BUFFERSIZE - 1);
			++n44kSamplesConsumed;
		}

		pOutSamples->left  = Lerp( t, m_p44kStereoIn[curSamp].left,  m_p44kStereoIn[nextSamp].left )  * scalar; // left 
		pOutSamples->right = Lerp( t, m_p44kStereoIn[curSamp].right, m_p44kStereoIn[nextSamp].right ) * scalar; // right
		// Fill the remaining with blank
		pOutSamples->center  = 0;
		pOutSamples->subwoofer = 0;
		pOutSamples->leftsurround  = 0;
		pOutSamples->rightsurround = 0;
		pOutSamples->leftextend = 0;
		pOutSamples->rightextend = 0;

		g_flSumStereo += pOutSamples->left * pOutSamples->left + pOutSamples->right * pOutSamples->right;
		pOutSamples++;
	}

	// Make sure to update correctly the variables after the last sample (after all, we did t += tstep).
	if ( t >= 1.0f )
	{
		t -= 1.0f;
		curSamp = nextSamp;
		++n44kSamplesConsumed;
	}
	m_fractionalSamples = t;
	
	m_ringHead = curSamp;
	m_ringCount -= n44kSamplesConsumed;
	return nSamplesToEmit;
}


int  CAudioIckyUpsampler::ExcreteSurround(  uint nSamplesRequested, libaudio_sample_surround_t *pOutSamples, float scalar  ) RESTRICT
{
	Assert( IsSurround() );

	// do a braindead linear interpolation
	float t = m_fractionalSamples;
	float tstep = ((float)INPUTFREQ)/((float) OUTPUTFREQ);
	const int nSamplesToEmit = MIN( OutputSamplesAvailable(), nSamplesRequested );

	int curSamp = m_ringHead;
	int nextSamp = (curSamp + 1) & (BUFFERSIZE - 1);
	int n44kSamplesConsumed = 0;
	const float flBackChannelMultipler = snd_ps3_back_channel_multiplier.GetFloat();
	//  iterator
	for ( int iRemain = nSamplesToEmit ; 
		iRemain > 0				   ; 
		t += tstep, --iRemain )
	{
		// if we've passed a sample boundary, go onto the next sample
		if ( t >= 1.0f ) // ugh, fcmp, it's just a hacky prototype
		{
			t -= 1.0f;
			curSamp = nextSamp;
			nextSamp = (curSamp + 1) & (BUFFERSIZE - 1);
			++n44kSamplesConsumed;
		}

		pOutSamples->left  = Lerp( t, m_p44kSurroundIn[curSamp].left,  m_p44kSurroundIn[nextSamp].left )  * scalar; // left 
		pOutSamples->right = Lerp( t, m_p44kSurroundIn[curSamp].right, m_p44kSurroundIn[nextSamp].right ) * scalar; // right
		pOutSamples->center  = Lerp( t, m_p44kSurroundIn[curSamp].center,  m_p44kSurroundIn[nextSamp].center )  * scalar; // left 
		pOutSamples->subwoofer = 0;		// As on X360, let the HW mix the sub from the main channel since we don't have any sub-specific sounds, or direct sub-addressing
		float fLeftSurround = Lerp( t, m_p44kSurroundIn[curSamp].surleft,  m_p44kSurroundIn[nextSamp].surleft )  * scalar; // left 
		float fRightSurround = Lerp( t, m_p44kSurroundIn[curSamp].surright, m_p44kSurroundIn[nextSamp].surright ) * scalar; // right
		pOutSamples->leftsurround  = fLeftSurround;
		pOutSamples->rightsurround = fRightSurround;
		pOutSamples->leftextend = fLeftSurround * flBackChannelMultipler;
		pOutSamples->rightextend = fRightSurround * flBackChannelMultipler;
		pOutSamples++;
	}

	// Make sure to update correctly the variables after the last sample (after all, we did t += tstep).
	if ( t >= 1.0f )
	{
		t -= 1.0f;
		curSamp = nextSamp;
		++n44kSamplesConsumed;
	}
	m_fractionalSamples = t;
	
	m_ringHead = curSamp;
	m_ringCount -= n44kSamplesConsumed;
	return nSamplesToEmit;
}

int CAudioIckyUpsampler::OutputSamplesAvailable()
{
	// returns the number of output samples we can generate (notice this rounds down, ie we may leave some fractional samples for next time)
	return ( ( m_ringCount - 1 ) * OUTPUTFREQ) / INPUTFREQ;
}

//-----------------------------------------------------------------------------
// Implementation of an audio device on top of PS3's libaudio
//-----------------------------------------------------------------------------
class CAudioPS3LibAudio: public CAudioDeviceBase, public VJobInstance
{
public:
	~CAudioPS3LibAudio( void );
	CAudioPS3LibAudio( 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 );
	void		PaintEnd( void );
	int			GetOutputPosition( void );
	void		ClearBuffer( void );
	void		TransferSamples( int64 end ) ;

	virtual const char *DeviceName( void );
	virtual int			DeviceChannels( void );
	virtual int			DeviceSampleBits( void );
	virtual int			DeviceSampleBytes( void );
	virtual int			DeviceDmaSpeed( void );
	virtual int			DeviceSampleCount( void );

	CEngineVoicePs3	*GetVoiceData( void ) { return &m_VoiceData; }
	static		CAudioPS3LibAudio *m_pSingleton;

	static void	QuerySystemAudioConfiguration( bool bForceRefreshCache = false ); // retrieves information from the OS about what output devices are connected. Caches result.


	virtual void OnVjobsInit(){ s_LibAudioThread.OnVjobsInit( m_pRoot ); }
	virtual void OnVjobsShutdown() { s_LibAudioThread.OnVjobsShutdown(); }

protected:

	inline float *GetAddressForBlockIdx( unsigned nBlock );
	inline uint GetPortBufferSize()const;
	inline float *GetNextReadBlockAddress();
	int UpdateBufferCount( void );  // update the count of how many filled buffers remain to be read. return m_nFilledBuffers to avoid a LHS

#if 0 // These functions were deprecated by the move to a DMA thread:
	// blit the audio data to the hardware. returns the number of samples written.
	int TransferStereo( const portable_samplepair_t *pFrontBuffer, int nSamplesToWrite, int nStartBlock );
	int TransferSurroundInterleaved( const portable_samplepair_t *pFrontBuffer, const portable_samplepair_t *pRearBuffer, const int *pCenterBuffer, 
		int nSamplesToWrite, int nStartBlock );
#endif


	int			m_deviceChannels;					// channels per ring port ( either 2 for stereo or 8 for surround -- PS3's libaudio has no concept of 5.1 ) 

	// information from the OS.
	// right now this is all a little redundant because we are only using the "primary" sound device,
	// which always has exactly one logical device even if there are multiple things attached. But it
	// will be significant if we eventually create another class to handle "secondary" outputs, in which
	// case the members below should not be static, and QuerySystemAudioConfiguration() will need to take
	// a flag specifying CELL_AUDIO_OUT_PRIMARY or CELL_AUDIO_OUT_SECONDARY. You'll also need to 
	// touch the init/shutdown functions so that you only intialize the OS's audio lib once.
	static bool	s_bCellAudioStateInitialized;
	static CUtlVectorConservative<CellAudioOutState> s_vCellAudioOutputDeviceStates;
	uint32_t m_nPortNum; // the "port number" given us by Cell
	sys_addr_t m_pPortBufferAddr; // base address of the audio port's ring buffer
	float * m_pDebugBuffer;
	volatile uint64_t* m_pReadIndexAddr; // pointer to an int containing the index of next block in the buffer that the hardware will read
	
	char m_nPhysicalOutChannels;
	CInterlockedInt m_nTotalBlocksPlayed;

	/// ----- THE FOLLOWING ARE CONTROLLED BY ONE MUTEX ----------
	CAudioIckyUpsampler m_upsampler;
	/// ----------------------------------------------------------


	class CAudioPS3DMAThread : public CThread
	{
	public:
		CAudioPS3DMAThread( );
		bool Setup( CAudioPS3LibAudio *pOwner );

		CInterlockedInt m_eHalt; // owner can signal halt with this by setting it to TRUE
		
		job_sndupsampler::JobDescriptor_t * m_pSndUpsamplerJobDescriptor;		
		job_sndupsampler::JobOutput_t * GetSndUpsamplerJobOutput() { return ( job_sndupsampler::JobOutput_t * )( m_pSndUpsamplerJobDescriptor + 1 ); }
		job_sndupsampler::JobParams_t * GetSndUpsamplerJobParams() { return job_sndupsampler::GetJobParams( m_pSndUpsamplerJobDescriptor ); }
		
		void OnVjobsInit( VJobsRoot* pRoot );
		void OnVjobsShutdown();
	protected:
		virtual int Run();
		virtual void OnExit(); // clean up
		int OutputData( int nCurrentAudioBlockReadIndex ) RESTRICT; // dump sounds from the upsampler into the DAC. return number of blocks written.
		
		int m_nFilledBuffers; // the number of block that are full of data but haven't been played yet.
		int m_nPreviouslySeenNextToUpdateBufferIndex;
		
		// the event queue (for counting how many blocks get played -- we could also use this for async sound writing) 
		sys_event_queue_t m_AudioEventQueue;
		sys_ipc_key_t m_AudioIPCKey;
		CAudioPS3LibAudio *m_pOwner;

		enum { STACKSIZE=4095 };
	};

	// a tiny thread whose only job in existence is to feed libaudio from our upsampling buffer.
	// it has to be this way because the system only caches two events from libaudio, and so
	// we can't know how many blocks have been played if we happen to be polled less than once
	// every ten milliseconds. 
	static CAudioPS3DMAThread s_LibAudioThread;
	friend class CAudioPS3DMAThread;

	CEngineVoicePs3 m_VoiceData;
};

CAudioPS3LibAudio *CAudioPS3LibAudio::m_pSingleton = NULL;


CAudioPS3LibAudio::CAudioPS3DMAThread::CAudioPS3DMAThread() 
	: m_nFilledBuffers(0)
	, m_eHalt(false)
	, m_pSndUpsamplerJobDescriptor( NULL )
{
}


// [Main] called from the context of main thread
//
void CAudioPS3LibAudio::CAudioPS3DMAThread::OnVjobsInit( VJobsRoot* pRoot )
{
	Assert( !m_pSndUpsamplerJobDescriptor );
	m_pSndUpsamplerJobDescriptor = ( job_sndupsampler::JobDescriptor_t * )MemAlloc_AllocAligned( sizeof( job_sndupsampler::JobDescriptor_t ) + sizeof( job_sndupsampler::JobOutput_t ), 128 );
	m_pSndUpsamplerJobDescriptor->header = *pRoot->m_pJobSndUpsampler;
	m_pSndUpsamplerJobDescriptor->header.useInOutBuffer = 0;
	job_sndupsampler::JobParams_t * pJobParams = job_sndupsampler::GetJobParams( m_pSndUpsamplerJobDescriptor );
	pJobParams->m_flMaxSumStereo = 500;
	pJobParams->m_nDebuggerBreak = 0;
	pJobParams->m_deviceChannels = m_pOwner->m_deviceChannels;
	Assert( pJobParams->m_deviceChannels == m_pOwner->m_deviceChannels );
	pJobParams->m_bIsSurround = m_pOwner->IsSurround();
	pJobParams->m_nCellAudioBlockSamplesLog2 = COMPILE_TIME_LOG2( CELL_AUDIO_BLOCK_SAMPLES );

	cellAudioCreateNotifyEventQueue( &m_AudioEventQueue, &m_AudioIPCKey );
	cellAudioSetNotifyEventQueue( m_AudioIPCKey );

	Start(STACKSIZE);
}


// [Main] called from the context of main thread
//
void CAudioPS3LibAudio::CAudioPS3DMAThread::OnVjobsShutdown()
{
	m_eHalt = true ;
	Join();

	cellAudioRemoveNotifyEventQueue( m_AudioIPCKey );
	sys_event_queue_destroy( m_AudioEventQueue, SYS_EVENT_QUEUE_DESTROY_FORCE  );

	Assert( m_pSndUpsamplerJobDescriptor );
	if( m_pSndUpsamplerJobDescriptor )
	{
		m_pSndUpsamplerJobDescriptor = NULL;

		job_sndupsampler::JobOutput_t * pJobOutput = GetSndUpsamplerJobOutput();	
		MemAlloc_FreeAligned( m_pSndUpsamplerJobDescriptor );
		m_pSndUpsamplerJobDescriptor = NULL;
	}
}



bool CAudioPS3LibAudio::CAudioPS3DMAThread::Setup( CAudioPS3LibAudio *pOwner )
{
	if ( m_pOwner )
	{
		AssertMsg( false, "Tried to make two CAudioPS3LibAudio s\n");
		return false;
	}
	SetName("CAudioPS3DMAThread");
	
	m_pOwner = pOwner;

	return true;
}

void CAudioPS3LibAudio::CAudioPS3DMAThread::OnExit()
{
	// NOTE: please don't destruct resources created in the context of main thread here; Setup() is called in main thread; OnExit is called from the audio thread.
	//       destroy those resources where you join the thread , the same way they are created before the thread Start() is called
	// NOTE: we need to shutdown AFTER exiting the thread, to avoid accessing thread structure during/after shutdown
	Assert( m_pSndUpsamplerJobDescriptor );
}



int CAudioPS3LibAudio::CAudioPS3DMAThread::Run() 
{
	// this needs to be a high priority thread since it is realtime
	SetPriority( 5 );
	m_nPreviouslySeenNextToUpdateBufferIndex = *(m_pOwner->m_pReadIndexAddr);
	while ( !m_eHalt )
	{
		// wait for the audio engine to signal that it's mixed out a buffer
		// and is ready for another
		sys_event_t audioevent;
		int waitresult = sys_event_queue_receive( m_AudioEventQueue, &audioevent, 5000000 );
		if ( waitresult == ETIMEDOUT )
		{
			// warnings are commented out here because CUtlString::Format() allocates a 4096byte buffer and thereby blows
			// the thread stack!
			// Warning("Went five seconds without a libaudio event, wtf?\n");
			continue;
		}
		else if ( waitresult != CELL_OK )
		{
			Error("Failed to wait on libaudio buffer, error %x\n", waitresult );
			return -1;
		}

		// down here, we successfully received an event
		// make sure we still haven't been halted
		if ( m_eHalt )
			break;

		int nextBufferToBeRead = *(m_pOwner->m_pReadIndexAddr);
		if ( nextBufferToBeRead != (m_nPreviouslySeenNextToUpdateBufferIndex + 1) % CELLAUDIO_PORT_BUFFER_BLOCKS )
		{
			// warnings are commented out here because CUtlString::Format() allocates a 4096byte buffer and thereby blows
			// the thread stack!
			// Warning( "Missed an audio buffer being sent through! previously seen was %d now is %d\n",
			//	m_nPreviouslySeenNextToUpdateBufferIndex, nextBufferToBeRead );
			// flush everything and start over
			m_nFilledBuffers = 0;
		}
		else
		{
			// one more buffer has been eaten
			m_nFilledBuffers = m_nFilledBuffers <= 0 ? 0 : m_nFilledBuffers - 1;
		}

		// let's avoid a sys call in non-debug configurations
		if ( !ENABLE_SOUND_DEBUG || ( CPS3FrontPanelLED::GetSwitches() & CPS3FrontPanelLED::kPS3SWITCH2 ) == 0 )
		{
			int bufsRead = OutputData( nextBufferToBeRead );
			// Msg("Emited %d bufs\n", bufsRead);
			m_nFilledBuffers += bufsRead;
		}
		else
		{
			// An example of a dead simple sine wave test:
			m_pOwner->m_upsampler.Flush();
			float * pOut = m_pOwner->GetAddressForBlockIdx( nextBufferToBeRead );
			// brain-dead test, just a low note
			for ( int n = 0 ; n <  CELL_AUDIO_BLOCK_SAMPLES ; ++n )
			{
				float f = 0.4f * sin( (4.0 / (double)CELL_AUDIO_BLOCK_SAMPLES) * M_PI * n );
				pOut[n*2 + 0] = f;
				pOut[n*2 + 1] = f;
				m_nFilledBuffers = 1;
			}
/*
			char buffer[200];
			int len = V_snprintf( buffer, sizeof( buffer) , "Snd %x, @%p\n", CELL_AUDIO_BLOCK_SAMPLES * 2 * sizeof( float ), pOut );
			uint wrote;
			sys_tty_write( SYS_TTYP3, buffer, len, &wrote );
*/
		}
		m_nPreviouslySeenNextToUpdateBufferIndex = nextBufferToBeRead; // *(m_pOwner->m_pReadIndexAddr); // reread the volatile

		// Update the voice buffer here too
		Audio_GetXVoice()->PlayPortInterruptHandler();
	}
	return 0;
}


ConVar sound_on_spu( "sound_on_spu", "1" );
#define AssertRt(X) //while(!(X)){DebuggerBreak();break;}


uint g_nOutputDataBlocksWritten = 0;

ConVar sound_sleep_rt_thread( "sound_sleep_rt_thread", "30" );

int CAudioPS3LibAudio::CAudioPS3DMAThread::OutputData( int nCurrentAudioBlockReadIndex ) RESTRICT 
{
	Assert( m_pSndUpsamplerJobDescriptor ); // the SPU job code must be loaded/streamed in already
	// grab the upsampler mutex
	int availableInputSamples = m_pOwner->m_upsampler.OutputSamplesAvailable(); // at the 48khz rate
	if( availableInputSamples <= 0 )
	{
		return 0;
	}

	int nextBlockIdxToWrite = ( nCurrentAudioBlockReadIndex + m_nFilledBuffers ) % CELLAUDIO_PORT_BUFFER_BLOCKS;
	float volumeFactor = S_GetMasterVolume() / 32767.0f;

	// flush as many samples out to the device as possible
	// now output as many full audio blocks @48khz as we can

	int emptyblocks = CELLAUDIO_PORT_BUFFER_BLOCKS - m_nFilledBuffers;

	int availableInputBlocks = availableInputSamples / CELL_AUDIO_BLOCK_SAMPLES; // rounds down 

	// don't emit more blocks than the DAC has room for
	availableInputBlocks = MIN( availableInputBlocks, emptyblocks );
	
	if( availableInputBlocks <= 0 )
	{
		return 0;
	}
	
	uint blocksWrit = 0;
	if( int nSoundOnSpu = sound_on_spu.GetInt() )
	{
		job_sndupsampler::JobOutput_t * pJobOutput = GetSndUpsamplerJobOutput();
		job_sndupsampler::JobParams_t * pJobParams = job_sndupsampler::GetJobParams( m_pSndUpsamplerJobDescriptor );
		float * pSpuResult = ENABLE_SOUND_DEBUG && nSoundOnSpu > 1 ? m_pOwner->m_pDebugBuffer : NULL;
		uint n44kSamplesAvailable = m_pOwner->m_upsampler.m_ringCount;
		{
			MICRO_PROFILE( g_mpOutputData );
			AssertRt( pJobParams->m_deviceChannels == m_pOwner->m_deviceChannels );
			
			pJobParams->m_eaPortBufferAddr     = ( pSpuResult ? (sys_addr_t)pSpuResult : m_pOwner->m_pPortBufferAddr ); // may change when user switches surround <-> stereo
			
			pJobParams->m_availableInputBlocks = availableInputBlocks;
			pJobParams->m_volumeFactor         = volumeFactor;
			pJobParams->m_nextBlockIdxToWrite  = nextBlockIdxToWrite;
			pJobParams->m_fractionalSamples    = m_pOwner->m_upsampler.m_fractionalSamples;
			pJobParams->m_flBackChannelMultipler = snd_ps3_back_channel_multiplier.GetFloat();
			
			if( ENABLE_SOUND_DEBUG  )
			{
				// let's avoid a sys call (sys_gpio_get) in non-debug configurations
				if( ( CPS3FrontPanelLED::GetSwitches() & CPS3FrontPanelLED::kPS3SWITCH3 ) == 0 )
				{
					pJobParams->m_nDebuggerBreak &= 0x7F;
				}
				else
				{
					pJobParams->m_nDebuggerBreak |= 0x80;
				}
			}
			
			uint nSampleSizeIn, nSampleSizeOutLog2;
			// align the number of samples so that we don't have to deal with unaligned blocks

			if( m_pOwner->m_upsampler.IsSurround() )
			{
				nSampleSizeOutLog2 = COMPILE_TIME_LOG2( sizeof( libaudio_sample_surround_t ) );
				nSampleSizeIn = sizeof( job_sndupsampler::surroundsample_t );
			}
			else
			{
				nSampleSizeOutLog2 = COMPILE_TIME_LOG2( sizeof( libaudio_sample_surround_t ) );
				nSampleSizeIn = sizeof( job_sndupsampler::stereosample_t );
			}
			
			CDmaListConstructor dmaConstructor( m_pSndUpsamplerJobDescriptor->workArea.dmaList );
			int nRingHead = m_pOwner->m_upsampler.m_ringHead;
			uintp ea44kSamplesIn = m_pOwner->m_upsampler.m_ea44kSamplesIn;
			uint eaInputSamplesBegin = ea44kSamplesIn + ( nRingHead * nSampleSizeIn );
			pJobParams->m_eaInputSamplesBegin0xF = uint8( eaInputSamplesBegin & 0xF );

			pJobParams->m_ringHead             = nRingHead;
			pJobParams->m_ringCount            = n44kSamplesAvailable;

			if( nRingHead + n44kSamplesAvailable > CAudioIckyUpsampler::BUFFERSIZE )
			{
				// split into 2 transactions
				dmaConstructor.AddInputDmaLargeRegion( (void*)( eaInputSamplesBegin & -16 ), (void*)( ea44kSamplesIn + ( CAudioIckyUpsampler::BUFFERSIZE * nSampleSizeIn ) ) );
				// this is always aligned
				dmaConstructor.AddInputDmaLarge( AlignValue( ( nRingHead + n44kSamplesAvailable - CAudioIckyUpsampler::BUFFERSIZE ) * nSampleSizeIn, 16 ), ( void * )ea44kSamplesIn );
			}
			else
			{
				dmaConstructor.AddInputDmaLargeUnalignedRegion( (void*)eaInputSamplesBegin, (void*)( eaInputSamplesBegin + ( n44kSamplesAvailable * nSampleSizeIn ) ) );
			}
			
			m_pSndUpsamplerJobDescriptor->header.sizeOut = 
					sizeof( job_sndupsampler::JobOutput_t ) // job output structure
				+ ( ( 2 * CELL_AUDIO_BLOCK_SAMPLES ) << nSampleSizeOutLog2 ) // output samples
				+   16									   // potential misalignment of output samples ( stereo samples are 8 bytes each )
				;
			dmaConstructor.FinishInBuffer( &m_pSndUpsamplerJobDescriptor->header, pJobParams );
								    
			pJobOutput->m_nBlockWritten = 0xFFFFFFFF; // invalid value
			
			// NOTE: if we need to wait for the job, we need to push it with CELL_SPURS_JOBQUEUE_FLAG_SYNC_JOB flag!
			if( int nError = m_pOwner->m_pRoot->m_queuePortSound.pushJob( &m_pSndUpsamplerJobDescriptor->header, sizeof( job_sndupsampler::JobDescriptor_t ), 0, 0 ) )
			{
				Warning( "Cannot start Sound job, error 0x%X\n", nError );
			}
		}
		//m_pOwner->m_pRoot->m_queuePortSound.sync( 0 );	// NOTE! if we use sync() here, we need to push job with CELL_SPURS_JOBQUEUE_FLAG_SYNC_JOB flag!
		sys_timer_usleep( sound_sleep_rt_thread.GetInt() );
		while( *(volatile uint32*)( &pJobOutput->m_nBlockWritten ) == 0xFFFFFFFF ); // must be synchronized by now
		{
			sys_timer_usleep( 100 ); // wait for the job to complete; we aren't in a hurry
		}

		AssertRt( n44kSamplesAvailable > pJobOutput->m_n44kSamplesConsumed ); // we must never consume the last sample, because we won't be able to extrapolate the value
		AssertRt( m_pOwner->m_upsampler.m_ringCount >= n44kSamplesAvailable );
		AUTO_LOCK( m_pOwner->m_upsampler.m_mutex ); // TODO: get rid of this lock, use head-tail counters instead of head+count
		if( !m_pOwner->m_upsampler.m_ringCount )
		{
			// if the ring count was flushed, don't do any checks - it's useless
			blocksWrit = pJobOutput->m_nBlockWritten;
		}
		else if( ENABLE_SOUND_DEBUG && pSpuResult ) 
		{
			int nRingCountBegin = m_pOwner->m_upsampler.m_ringCount, nRingHeadBegin = m_pOwner->m_upsampler.m_ringHead;
			// STEREO!
			while ( availableInputBlocks>0 )
			{
				// all sorts of obvious ways to optimize this (explicit iterators, VMX, SPU, etc)
				float * RESTRICT pWriteDest = (m_pOwner->GetAddressForBlockIdx( nextBlockIdxToWrite ));
				float *buffer = new float[CELL_AUDIO_BLOCK_SAMPLES * sizeof( libaudio_sample_surround_t ) / sizeof( float )];

				AssertRt( fabsf( m_pOwner->m_upsampler.m_fractionalSamples - pJobOutput->m_trace[blocksWrit].m_fractionalSamplesBefore ) < 1e-2f );
				int nRingHeadBefore = m_pOwner->m_upsampler.m_ringHead, nRingCountBefore = m_pOwner->m_upsampler.m_ringCount;
				float fractionalSamplesBefore = m_pOwner->m_upsampler.m_fractionalSamples;
				
				if( ENABLE_SOUND_DEBUG )
				{
					m_pOwner->m_upsampler.m_ringHead = nRingHeadBefore;
					m_pOwner->m_upsampler.m_ringCount = nRingCountBefore;
					m_pOwner->m_upsampler.m_fractionalSamples = fractionalSamplesBefore;
				}
				
				int samplesWritten = m_pOwner->IsSurround() ? 
					m_pOwner->m_upsampler.ExcreteSurround( CELL_AUDIO_BLOCK_SAMPLES, reinterpret_cast<libaudio_sample_surround_t *>(buffer), volumeFactor ) :
					m_pOwner->m_upsampler.ExcreteStereo( CELL_AUDIO_BLOCK_SAMPLES, reinterpret_cast<libaudio_sample_surround_t *>(buffer), volumeFactor ) ;
				AssertRt( samplesWritten == CELL_AUDIO_BLOCK_SAMPLES );
				int nSamplesConsumedSoFar = nRingCountBegin - m_pOwner->m_upsampler.m_ringCount;
				AssertRt( nSamplesConsumedSoFar == pJobOutput->m_trace[blocksWrit].m_n44kSamplesConsumed );
				
				float * pSpuResultBlock = pSpuResult + ( pWriteDest - ( float * )m_pOwner->m_pPortBufferAddr );
				for( uint i = 0; i < CELL_AUDIO_BLOCK_SAMPLES * m_pOwner->m_deviceChannels;  )
				{
					if( fabsf( buffer[i] - pSpuResultBlock[i] ) > 1e-6f )
					{
						DebuggerBreakIfDebugging();
						pJobOutput->m_nBlockWritten = 0xFFFFFFFF; // invalid value
						int nError = m_pOwner->m_pRoot->m_queuePortSound.pushJob( &m_pSndUpsamplerJobDescriptor->header, sizeof( job_sndupsampler::JobDescriptor_t ), 0, 0 );
						while( pJobOutput->m_nBlockWritten == 0xFFFFFFFF )
							continue;
						continue;
					}
					++i;
				}

				--availableInputBlocks;
				nextBlockIdxToWrite = (nextBlockIdxToWrite + 1)%CELLAUDIO_PORT_BUFFER_BLOCKS;
				++blocksWrit;
				delete []buffer;
			}
			
			AssertRt( blocksWrit == pJobOutput->m_nBlockWritten );
			AssertRt( m_pOwner->m_upsampler.m_ringHead == pJobOutput->m_ringHead );
			AssertRt( fabsf( m_pOwner->m_upsampler.m_fractionalSamples - pJobOutput->m_fractionalSamples ) < 1e-6f );
		}
		else
		{
			blocksWrit = pJobOutput->m_nBlockWritten;
			m_pOwner->m_upsampler.m_ringCount -= pJobOutput->m_n44kSamplesConsumed;
			m_pOwner->m_upsampler.m_ringHead = pJobOutput->m_ringHead;
			m_pOwner->m_upsampler.m_fractionalSamples = pJobOutput->m_fractionalSamples;
		}		
	}
	else
	{
		// STEREO!
		AUTO_LOCK( m_pOwner->m_upsampler.m_mutex ); // TODO: get rid of this lock, use head-tail counters instead of head+count
		MICRO_PROFILE( g_mpOutputData );
		g_flSumStereo = 0;
		while ( availableInputBlocks>0 )
		{
			// all sorts of obvious ways to optimize this (explicit iterators, VMX, SPU, etc)
			float * RESTRICT pWriteDest = (m_pOwner->GetAddressForBlockIdx( nextBlockIdxToWrite ));

			int samplesWritten = m_pOwner->IsSurround() ? 
				m_pOwner->m_upsampler.ExcreteSurround( CELL_AUDIO_BLOCK_SAMPLES, reinterpret_cast<libaudio_sample_surround_t *>(pWriteDest), volumeFactor ) :
				m_pOwner->m_upsampler.ExcreteStereo( CELL_AUDIO_BLOCK_SAMPLES, reinterpret_cast<libaudio_sample_surround_t *>(pWriteDest), volumeFactor ) ;
			AssertRt( samplesWritten == CELL_AUDIO_BLOCK_SAMPLES );

			--availableInputBlocks;
			nextBlockIdxToWrite = (nextBlockIdxToWrite + 1)%CELLAUDIO_PORT_BUFFER_BLOCKS;
			++blocksWrit;
		}
		
		if( ENABLE_SOUND_DEBUG && g_flSumStereo > GetSndUpsamplerJobParams()->m_flMaxSumStereo )
		{
			char buffer[200];
			int len = V_snprintf( buffer, sizeof( buffer) , "PPU Stereo %g\n", g_flSumStereo );
			uint wrote;
			sys_tty_write( SYS_TTYP3, buffer, len, &wrote );
		}
	}
	m_pOwner->m_nTotalBlocksPlayed += blocksWrit;

	g_nOutputDataBlocksWritten += blocksWrit;		

	return blocksWrit;
}

CAudioPS3LibAudio::CAudioPS3DMAThread CAudioPS3LibAudio::s_LibAudioThread;

bool CAudioPS3LibAudio::s_bCellAudioStateInitialized = false;
CUtlVectorConservative<CellAudioOutState> CAudioPS3LibAudio::s_vCellAudioOutputDeviceStates(0,1);

// NULL out the pointers so that failures are more immediate, evident
CAudioPS3LibAudio::CAudioPS3LibAudio( void ) : m_deviceChannels( 0 )
	, m_nPortNum( -1 )
	, m_nPhysicalOutChannels( 0 )
	, m_pPortBufferAddr( NULL )
	, m_pReadIndexAddr( NULL )
	, m_nTotalBlocksPlayed( 0 )
{
//	AssertMsg( false, "Please implement CAudioPS3LibAudio\n" ); 
}



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

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

	if ( !CAudioPS3LibAudio::m_pSingleton )
	{
		CAudioPS3LibAudio::m_pSingleton = new CAudioPS3LibAudio;
		if ( !CAudioPS3LibAudio::m_pSingleton->Init() )
		{
			AssertMsg( false, "Failed to init CAudioPS3LibAudio\n" );
			delete CAudioPS3LibAudio::m_pSingleton;
			CAudioPS3LibAudio::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 && CAudioPS3LibAudio::m_pSingleton )
	{
		CAudioPS3LibAudio::m_pSingleton->GetVoiceData()->VoiceInit();
	}

	return CAudioPS3LibAudio::m_pSingleton;
}

//-----------------------------------------------------------------------------
// Destructor
//-----------------------------------------------------------------------------
CAudioPS3LibAudio::~CAudioPS3LibAudio( void )
{
	if ( m_deviceChannels >  0 )
	{
		AssertMsg( false, "CAudioPS3LibAudio() called without being Shutdown() first! Initiating emergency purge.\n" );
		Shutdown();
	}

	g_pVJobs->Unregister( this );
	m_pSingleton = NULL;
}

void CAudioPS3LibAudio::QuerySystemAudioConfiguration( bool bForceRefreshCache )
{
	if ( !s_bCellAudioStateInitialized || bForceRefreshCache )
	{
		// flush the data we've got if necessary
		s_vCellAudioOutputDeviceStates.RemoveAll();

		const int numDevices = cellAudioOutGetNumberOfDevice( CELL_AUDIO_OUT_PRIMARY );
		if ( numDevices < 0 )
		{
			// error!
			s_vCellAudioOutputDeviceStates.RemoveAll();
			AssertMsg1( false, "cellAudioOutGetNumberOfDevice failed: %x\n", numDevices );
			return;
		}

		s_vCellAudioOutputDeviceStates.EnsureCount(numDevices); // set the count of output devices
		for ( int d = 0 ; d < s_vCellAudioOutputDeviceStates.Count() ; ++d )
		{
			int suc = cellAudioOutGetState( CELL_AUDIO_OUT_PRIMARY, d, &s_vCellAudioOutputDeviceStates[d] );
			AssertMsg2( suc == CELL_OK, "cellAudioOutGetState(%d) failed: %x\n", d, suc );
		}

		s_bCellAudioStateInitialized = true;
	}
}

// This code is from Bink's examples - they are configuring the HW mixer
// This may resolve the issue with center being lost when we are in stereo.
// Note that we do not detect DTS. Maybe we should?
static int init_audio_hardware( int minimum_chans, int &nPhysicalChannels )
{
  int ret;
  int ch_pcm;
  int ch_bit;
  CellAudioOutConfiguration a_config;

  memset( &a_config, 0, sizeof( CellAudioOutConfiguration ) );

  // Note that we would probably need to do something smarter than what this function is doing.
  // It seems we should test these cases in this order (highest to lowest quality):
  // Do we have enough channels for:
  //   - LPCM
  //   - DTS
  //   - AC3
  // If not, then we have to downmix:
  //   - If from 8 to 6 (type B downmixer)
  //       - Try LPCM encoder
  //       - Otherwise try DTS encoder	- Is this necessary?
  //       - Then the AC3 encoder		- Is this necessary?
  //   - If it does not work (or from 8 to 2, 6 to 2) - use Type A downmixer:
  //	   - Try PCM encoder

  // Current code is doing:
  //   - Do we have enough channels for LPCM
  //	   If yes, set it, done.
  //       If not
  //           Do we have support for 6 channels?
  //		     If yes, then set downmixer from 8 to 6 in LPCM mode.
  //             If not then we support only 2 channels.
  //             Do we have support for Dolby (any number of channels)?
  //				If yes, do we have enough support for requested channels?
  //					If yes, set it, done.
  //					If not, set the downmixer to 5.1, if successful, done.
  //				If not (or Dolby downmixer to 5.1 failed), downmix to 2 with LPCM.

  // first lets see how many pcm output channels we have
  ch_pcm = cellAudioOutGetSoundAvailability( CELL_AUDIO_OUT_PRIMARY,
                                             CELL_AUDIO_OUT_CODING_TYPE_LPCM,
                                             CELL_AUDIO_OUT_FS_48KHZ, 0 );
  nPhysicalChannels = ch_pcm;

  if ( ch_pcm >= minimum_chans )
  {
    a_config.channel = ch_pcm;
    a_config.encoder = CELL_AUDIO_OUT_CODING_TYPE_LPCM;
    a_config.downMixer = CELL_AUDIO_OUT_DOWNMIXER_NONE; /* No downmixer is used */
    cellAudioOutConfigure( CELL_AUDIO_OUT_PRIMARY, &a_config, NULL, 0 );
    ret = ch_pcm;
  }
  else
  {
    switch ( ch_pcm )
    {
      case 6:
        // this means we asked for 8 channels, but only 6 are available
        //   so, we'll turn on the 7.1 to 5.1 downmixer.
        a_config.channel = 6; 
        a_config.encoder = CELL_AUDIO_OUT_CODING_TYPE_LPCM;
        a_config.downMixer = CELL_AUDIO_OUT_DOWNMIXER_TYPE_B; 
        if ( cellAudioOutConfigure( CELL_AUDIO_OUT_PRIMARY, &a_config, NULL, 0 ) != CELL_OK )
        {
          return 0; // error - the downmixer didn't init
        }
        ret = 8;
        break;

    case 2:
      // ok, this means they asked for multi-channel out, but only stereo
      //   is supported.  we'll try Dolby digital first and then the downmixer
            
	  // Support for DTS - disabled as we can't test it right now
#if 0
		ch_bit = cellAudioOutGetSoundAvailability( CELL_AUDIO_OUT_PRIMARY,
			CELL_AUDIO_OUT_CODING_TYPE_DTS,
			CELL_AUDIO_OUT_FS_48KHZ, 0 );
		if ( ch_bit > 0 ) 
		{
			a_config.channel = ch_bit;
			a_config.encoder = CELL_AUDIO_OUT_CODING_TYPE_DTS;
			if ( ch_bit >= minimum_chans )
			{
				// we have enough channels to support their minimum
				a_config.downMixer = CELL_AUDIO_OUT_DOWNMIXER_NONE;
				ret = ch_bit;
			} 
			else 
			{
				// we don't have enough channels to support their minimum, so use the downmixer
				a_config.downMixer = CELL_AUDIO_OUT_DOWNMIXER_TYPE_B;			// Downmix to 5.1 channels
				ret = 8;
			}

			if ( cellAudioOutConfigure( CELL_AUDIO_OUT_PRIMARY, &a_config, NULL, 0 ) == CELL_OK )
			{
				nPhysicalChannels = ch_bit;
				break;
			}

			// if we got here the DTS encoder didn't init, so fall through to Dolby encoder
		}
#endif

      ch_bit = cellAudioOutGetSoundAvailability( CELL_AUDIO_OUT_PRIMARY,
                                                 CELL_AUDIO_OUT_CODING_TYPE_AC3,
                                                 CELL_AUDIO_OUT_FS_48KHZ, 0 );
      if ( ch_bit > 0 ) 
      {
        a_config.channel = ch_bit;
        a_config.encoder = CELL_AUDIO_OUT_CODING_TYPE_AC3;
        if ( ch_bit >= minimum_chans )
        {
          // we have enough channels to support their minimum
          a_config.downMixer = CELL_AUDIO_OUT_DOWNMIXER_NONE;
          ret = ch_bit;
        } 
        else 
        {
          // we don't have enough channels to support their minimum, so use the downmixer
          a_config.downMixer = CELL_AUDIO_OUT_DOWNMIXER_TYPE_B;			// Downmix to 5.1 channels
          ret = 8;
        }

        if ( cellAudioOutConfigure( CELL_AUDIO_OUT_PRIMARY, &a_config, NULL, 0 ) == CELL_OK )
        {
		  nPhysicalChannels = ch_bit;
		  break;
        }

        // if we got here the Dolby encoder didn't init, so fall through to downmixing to stereo
      }

      a_config.channel = 2; 
      a_config.encoder   = CELL_AUDIO_OUT_CODING_TYPE_LPCM;
      a_config.downMixer = CELL_AUDIO_OUT_DOWNMIXER_TYPE_A;				// Downmix to 2 channels
      if ( cellAudioOutConfigure( CELL_AUDIO_OUT_PRIMARY, &a_config, NULL, 0 ) != CELL_OK )
      {
        return 0; // error - downmixer didn't work
      }

      ret = 7; // downmixer does 7.0 to 2.0 downmixing...
      break;

    default:
      // some other weird case that we don't understand
      return 0;
    }
  }

/*
  // wait for the device to enable (not necessary anymore?)
  {
    CellAudioOutState a_state;

    do
    {
      if ( cellAudioOutGetState( CELL_AUDIO_OUT_PRIMARY, 0, &a_state ) != CELL_OK )
      {
        return( ret );	// If that failed, we are still returning the expected value. This call is not critical. 
      }
      sys_timer_usleep( 5000 );
    }
    while ( a_state.state != CELL_AUDIO_OUT_OUTPUT_STATE_ENABLED );
  }
*/

  // turn off copy protection stupidness
  cellAudioOutSetCopyControl( CELL_AUDIO_OUT_PRIMARY,
                              CELL_AUDIO_OUT_COPY_CONTROL_COPY_FREE );


  return( ret );
}

bool CAudioPS3LibAudio::Init( void ) 
{
	if ( this == CAudioPS3LibAudio::m_pSingleton ) // guard against possible multiples of this thing
	{
		int success = cellAudioInit();
		if ( success != CELL_OK )
		{
			Warning( "Could not initalize PS3 audio, error code: %x\n", success );
			return false;
		}
	}

	// get relevant info from the OS
	QuerySystemAudioConfiguration( false );

	// work out our surround sound mode
	// assumption: we're only looking at CELL_AUDIO_OUT_PRIMARY
	// also: we could query headphones properly from some kind of UI setting
	m_bHeadphone = snd_surround.GetInt() == SURROUND_HEADPHONES; // in case we set this from the UI

	// number of physical out channels connected
	// (remember libaudio only logically supports 2 or 8 in the ring buffer)
	// also this is an enum rather than a direct count
	const int eOutputChannels = s_vCellAudioOutputDeviceStates[0].soundMode.channel;
	switch ( eOutputChannels ) 
	{
	case CELL_AUDIO_OUT_CHNUM_2:
	default:
		m_nPhysicalOutChannels = 2;
		break;
	case CELL_AUDIO_OUT_CHNUM_4:
		m_nPhysicalOutChannels = 4;  // quad
		break;
	case CELL_AUDIO_OUT_CHNUM_6:
		m_nPhysicalOutChannels = 6; // 5.1
		break;
	case CELL_AUDIO_OUT_CHNUM_8:
		m_nPhysicalOutChannels = 8; // 7.1
		break;
	}

	int nPhysicalChannels = m_nPhysicalOutChannels;
	int nResult = init_audio_hardware( 6, nPhysicalChannels );		// Ask for 5.1, so it can down mix to stereo if necessary
																	// Then engine will support the right format regardless of what the down mixer can support
	if ( nResult != 0 )
	{
		m_nPhysicalOutChannels = nPhysicalChannels;					// We could initialize the down mixer, lets use the physical out channels.
	}

	CellAudioPortParam aparam;
	float flBackChannelMultipler = 0.0f;
	if ( m_nPhysicalOutChannels > 2 )
	{
		snd_surround.SetValue( SURROUND_DIGITAL7DOT1 ); // all internal mixing is 8 channels; downsampling occurs in hardware

		m_bSurround = m_bSurroundCenter = true;
		m_deviceChannels = 8; // you can only have stereo or 7.1
		aparam.nChannel = CELL_AUDIO_PORT_8CH;

		// If we are in 7.1, we want to fill the back channel with the same value as the side channels
		// However, if we are in 5.1, we don't want to fill it in case the downmixer uses it and creates unwanted side-effects.
		if ( m_nPhysicalOutChannels > 6 )
		{
			flBackChannelMultipler = 1.0f;
		}
	}
	else
	{
		// Because we have the down mixer for Bink, we are going to output 7.1 even for stereo only
		// That way Bink can output 5.1 normally, and the down mixer will change it to stereo.
		// Same for the engine, however the engine is going to only output stereo values.

		snd_surround.SetValue( m_bHeadphone ? SURROUND_HEADPHONES : SURROUND_STEREO );

		m_bSurround = m_bSurroundCenter = false;
		m_deviceChannels = 8;
		aparam.nChannel = CELL_AUDIO_PORT_8CH;
	}
	snd_ps3_back_channel_multiplier.SetValue( flBackChannelMultipler );

	// open the audio port
	COMPILE_TIME_ASSERT( CELLAUDIO_PORT_BUFFER_BLOCKS == 8 || CELLAUDIO_PORT_BUFFER_BLOCKS == 16 ); // You're only allowed to have either 8 or 16 blocks in the ring buffer!

	aparam.nBlock = CELLAUDIO_PORT_BUFFER_BLOCKS == 16 ? CELL_AUDIO_BLOCK_16 : CELL_AUDIO_BLOCK_8; // you can have 8 or 16 blocks in the ring buffer. 16 gives us about 80ms of buffer.
	aparam.attr = 0; // no special attributes
	aparam.level = 1; // this is actually ignored without setting  CELL_AUDIO_PORTATTR_INITLEVEL to the attributes above.
	
	int success = cellAudioPortOpen( &aparam, &m_nPortNum );
	if ( success != CELL_OK )
	{
		Warning("Could not initialize libaudio, error code %x\n", success );
	}
	else
	{
		DevMsg( "PS3 libaudio device initialized:\n" );
		DevMsg( "   %d channel(s)\n"
			"   %d bits/sample\n"
			"   %d samples/sec\n", DeviceChannels(), DeviceSampleBits(), DeviceDmaSpeed() );
	}

	// get the pointers to the start and next-block-indicator of the ring buffer
	CellAudioPortConfig configinfo;
	cellAudioGetPortConfig( m_nPortNum,	&configinfo	);

	m_pPortBufferAddr = configinfo.portAddr;
	uint nPortBufferSize = GetPortBufferSize();
	m_pDebugBuffer = ENABLE_SOUND_DEBUG ? (float*)MemAlloc_AllocAligned( nPortBufferSize, 16 ) : NULL ;
	m_pReadIndexAddr = (uint64_t*)configinfo.readIndexAddr;

	m_upsampler.Init( m_bSurround );
	s_LibAudioThread.Setup( this );
	g_pVJobs->Register( this );

	cellAudioPortStart( m_nPortNum );
	return success == CELL_OK;
}

int	CAudioPS3LibAudio::DeviceChannels( void )		
{ 
	return m_deviceChannels;
}

int	CAudioPS3LibAudio::DeviceSampleBits( void )	
{ 
	return sizeof(float)*8; // the only sound format is single precision floats. PERIOD.
}

int	CAudioPS3LibAudio::DeviceSampleBytes( void )	
{
	return sizeof(float); 
}

int	CAudioPS3LibAudio::DeviceDmaSpeed( void )		
{ 
	return SOUND_DMA_SPEED; // the upsampler fakes 44.1
}

int	CAudioPS3LibAudio::DeviceSampleCount( void )	
{ 
	return CELL_AUDIO_BLOCK_SAMPLES * CELLAUDIO_PORT_BUFFER_BLOCKS; // each block is 256 samples long. OR ELSE.
}


inline float *CAudioPS3LibAudio::GetAddressForBlockIdx( unsigned nBlock )
{ 
	nBlock %= CELLAUDIO_PORT_BUFFER_BLOCKS;
	return reinterpret_cast<float *>( m_pPortBufferAddr + ( nBlock * sizeof(float) * CELL_AUDIO_BLOCK_SAMPLES * m_deviceChannels ) );
}

uint CAudioPS3LibAudio::GetPortBufferSize()const
{
	Assert( m_deviceChannels == 2 || m_deviceChannels == 8 );
	return CELLAUDIO_PORT_BUFFER_BLOCKS * CELL_AUDIO_BLOCK_SAMPLES * sizeof( float ) * m_deviceChannels;
}

inline float *CAudioPS3LibAudio::GetNextReadBlockAddress()
{ 
	return GetAddressForBlockIdx((uint)(*m_pReadIndexAddr));
}

void CAudioPS3LibAudio::Shutdown( void )
{
	// need to release ref to voice library
	m_VoiceData.VoiceShutdown();

	Assert( s_LibAudioThread.m_pSndUpsamplerJobDescriptor );
	// unregistering with Vjobs will cascade shutdown of all SPU-related and SPU-using resources (like the audio thread - it's using SPU resources)
	// this'll happen synchronously
	g_pVJobs->Unregister( this ); 
	Assert( !s_LibAudioThread.m_pSndUpsamplerJobDescriptor ); // must be shut down already

	int suc = cellAudioPortClose(m_nPortNum);
	AssertMsg2( suc == CELL_OK, "Couldn't close libaudio port(%d): %x\n", m_nPortNum, suc );
	m_nPortNum = -1;
	m_deviceChannels = 0;
	
	m_nPhysicalOutChannels = 0;
	m_pPortBufferAddr      = NULL;
	m_pReadIndexAddr       = NULL;
	m_nTotalBlocksPlayed   = 0;

	if ( this == CAudioPS3LibAudio::m_pSingleton )
	{
		CAudioPS3LibAudio::m_pSingleton = NULL;
		cellAudioQuit();
		s_bCellAudioStateInitialized = false;
	}
}

void CAudioPS3LibAudio::Pause( void )
{
	cellAudioPortStop( m_nPortNum );
}

void CAudioPS3LibAudio::UnPause( void )
{
	cellAudioPortStart( m_nPortNum );
}

//-----------------------------------------------------------------------------
// Fill the output buffers with silence
//-----------------------------------------------------------------------------
void CAudioPS3LibAudio::ClearBuffer( void )
{
	memset( reinterpret_cast<void *>(m_pPortBufferAddr), 0, CELLAUDIO_PORT_BUFFER_BLOCKS * CELL_AUDIO_BLOCK_SAMPLES * m_deviceChannels * sizeof(float) );
	m_upsampler.Flush();
}


//-----------------------------------------------------------------------------
// Calc the paint position
//-----------------------------------------------------------------------------
int64 CAudioPS3LibAudio::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 mixaheadsamples = mixAheadTime * DeviceDmaSpeed();

	// the upsampler will consume as much as it can 			
	int64 endtime = paintedtime + MIN(mixaheadsamples, m_upsampler.SpaceRemaining());
	// only get samples in numbers divisible by four
	endtime = endtime & ~0x3;

	return endtime;
}


void CAudioPS3LibAudio::TransferSamples( int64 endTime ) 
{
	AUTO_LOCK( m_upsampler.m_mutex );
	// first, pull as many samples into the upsampler as we can
	int sampleCountToWrite = endTime - g_paintedtime;  // copied from xaudio version. a global? wtf?
	Assert( sampleCountToWrite <= m_upsampler.SpaceRemaining() );

	if ( IsSurround() != m_upsampler.IsSurround() )
	{
		AssertMsg2( false, "Tried to write %d channels onto a %d-channel audio port!\n", m_deviceChannels, m_upsampler.IsSurround() ? 8 : 2 );
		// abort! abort!
		m_upsampler.Flush();
		return;
	}

	if ( IsSurround() )
		m_upsampler.IngestSurround( PAINTBUFFER, REARPAINTBUFFER, CENTERPAINTBUFFER, sampleCountToWrite );
	else
		m_upsampler.IngestStereo( PAINTBUFFER, sampleCountToWrite );
}

void	 CAudioPS3LibAudio::PaintEnd( void )
{}

#if 0
#pragma message("TODO: obvious optimization opportunities")
// TODO: move to SPU  -- many obvious optimization opportunities
int CAudioPS3LibAudio::TransferStereo( const portable_samplepair_t * RESTRICT pFrontBuffer, int nSamplesToWrite, int nStartBlock )
{
	// Assert that the compiler hasn't failed to pack the structs properly
	COMPILE_TIME_ASSERT( sizeof(libaudio_sample_stereo_t) == 8 );
	COMPILE_TIME_ASSERT( sizeof(libaudio_sample_surround_t) == 32 );

	AssertMsg1( m_deviceChannels == 2, "Transferred stereo onto a %d-channel audio port\n", m_deviceChannels );
	float volumeFactor = S_GetMasterVolume() / 32767.0f;
	uint blocksWrit = 0;
	while ( nSamplesToWrite>0 )
	{
		// all sorts of obvious ways to optimize this (explicit iterators, VMX, SPU, etc)
		libaudio_sample_stereo_t * RESTRICT pWriteDest = reinterpret_cast<libaudio_sample_stereo_t *>(GetAddressForBlockIdx( nStartBlock ));
		const uint batchsize = MIN( nSamplesToWrite, CELL_AUDIO_BLOCK_SAMPLES );
		for ( uint s = 0 ; s < batchsize ; ++s )
		{
			pWriteDest[s].left = pFrontBuffer[s].left * volumeFactor;
			pWriteDest[s].right = pFrontBuffer[s].right * volumeFactor;
		}
		pFrontBuffer += batchsize;

		nSamplesToWrite -= batchsize; 
		nStartBlock = (nStartBlock + 1)%CELLAUDIO_PORT_BUFFER_BLOCKS;
		++blocksWrit;
	}
	return blocksWrit;
}

// TODO: move to SPU  -- many obvious optimization opportunities
// TODO: make a LFE channel
int CAudioPS3LibAudio::TransferSurroundInterleaved( const portable_samplepair_t * RESTRICT pFrontBuffer, 
												   const portable_samplepair_t *  RESTRICT pRearBuffer, 
												   const int *  RESTRICT pCenterBuffer, 
								int nSamplesToWrite, int nStartBlock )
{
	if ( m_deviceChannels != 8 )  //!!EMERGENCY! EMERGENCY! WILL CAUSE CRASH! 
	{
		AssertMsg1( false, "Tried to write 7.1 surround onto a %d-channel audio port!\n", m_deviceChannels );
		return TransferStereo( pFrontBuffer, nSamplesToWrite, nStartBlock );	// CRASH AVERTED!
	}

	int volumeFactor = S_GetMasterVolume() * 256; // a legacy WTF
	uint blocksWrit = 0;

	while ( nSamplesToWrite>0 )
	{
		// all sorts of obvious ways to optimize this (explicit iterators, VMX, SPU, etc)
		libaudio_sample_surround_t * RESTRICT pWriteDest = reinterpret_cast<libaudio_sample_surround_t*>(GetAddressForBlockIdx( nStartBlock ));
		const uint batchsize = MIN( nSamplesToWrite, CELL_AUDIO_BLOCK_SAMPLES );
		for ( uint s = 0 ; s < batchsize ; ++s )
		{
			// perform the writes in order to be gentle on the write aggregator
			// (really I should go back and use dcbz+vmx here)
			pWriteDest[s].left = pFrontBuffer[s].left * volumeFactor;
			pWriteDest[s].right = pFrontBuffer[s].right * volumeFactor;
			pWriteDest[s].center = pCenterBuffer[s] * volumeFactor;
			pWriteDest[s].subwoofer = 0;
			pWriteDest[s].leftsurround = pRearBuffer[s].left * volumeFactor;
			pWriteDest[s].rightsurround = pRearBuffer[s].right * volumeFactor;
			pWriteDest[s].leftextend = 0;
			pWriteDest[s].rightextend = 0;
		}
		pFrontBuffer += batchsize;
		pRearBuffer += batchsize;
		pCenterBuffer += batchsize;

		nSamplesToWrite -= batchsize; 
		nStartBlock = (nStartBlock + 1)%CELLAUDIO_PORT_BUFFER_BLOCKS;
		++blocksWrit;
	}
	return blocksWrit;
}
#endif

//-----------------------------------------------------------------------------
// Get our device name
//-----------------------------------------------------------------------------
const char *CAudioPS3LibAudio::DeviceName( void )
{ 
	if ( m_bSurround )
		return "PS3 libaudio: 7.1 Channel Surround";
	else
		return "PS3 libaudio: Stereo"; 
}

int CAudioPS3LibAudio::GetOutputPosition( void )
{
	return m_nTotalBlocksPlayed * CELL_AUDIO_BLOCK_SAMPLES; // makes this effectively a 24-bit number, but the higher level code expects a count of samples, not sample blocks. 
}

#ifdef PS3_SUPPORT_XVOICE

ConVar voice_xplay_enable( "voice_xplay_enable", "1" );
ConVar voice_xplay_debug( "voice_xplay_debug", "0" );
ConVar voice_xplay_bandwidth_debug( "voice_xplay_bandwidth_debug", "0" );
ConVar voice_xplay_echo( "voice_xplay_echo", "0" );


CEngineVoicePs3::CEngineVoicePs3() :
	m_memContainer( SYS_MEMORY_CONTAINER_ID_INVALID )
{
}

//-----------------------------------------------------------------------------
// Initialize Voice
//-----------------------------------------------------------------------------
void CEngineVoicePs3::VoiceInit( void )
{
	memset( m_bUserRegistered, kVoiceNotInitialized, sizeof( m_bUserRegistered ) );

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

void CEngineVoicePs3::VoiceShutdown( void )
{
	RemoveAllTalkers(); // this should shutdown the voice engine on PS3
}

void CEngineVoicePs3::AddPlayerToVoiceList( XUID xPlayer, int iController, uint64 uiFlags )
{
	if ( !voice_xplay_enable.GetBool() )
		return;
	// This should only happen if we are not initialized and matchmaking
	// is in an online session
	if ( XBX_GetNumGameUsers() != 1 )
		return;
	if ( !g_pMatchFramework )
		return;
	if ( !g_pMatchFramework->GetMatchSession() )
		return;
	if ( Q_stricmp( g_pMatchFramework->GetMatchSession()->GetSessionSettings()->GetString( "system/network" ), "LIVE" ) )
		return;

	// Any connecting player initializes the voice system
	if ( m_bUserRegistered[ GetVoiceUserIndex( iController ) ] == kVoiceNotInitialized )
	{
		//
		// Initialize syslib
		//
		int res = cellSysmoduleLoadModule( CELL_SYSMODULE_VOICE );
		if ( res != CELL_OK )
		{
			Warning( "VOICE PS3: Failed to load libvoice! Error code %d\n", res );
			return;
		}
		CellVoiceInitParam cvip;
		Q_memset( &cvip, 0, sizeof( cvip ) );
		cvip.appType = CELLVOICE_APPTYPE_GAME_1MB;
		cvip.version = CELLVOICE_VERSION_100;
		res = cellVoiceInitEx( &cvip );
		if ( res != CELL_OK )
		{
			Warning( "VOICE PS3: Failed to cellVoiceInit! Error code %d\n", res );
			cellSysmoduleUnloadModule( CELL_SYSMODULE_VOICE );
			return;
		}

		// Otherwise we have successfully initialized syslib
		m_bUserRegistered[ GetVoiceUserIndex( iController ) ] = kVoiceInit;
		DevMsg( "PS3 Voice: microphone library loaded and started\n" );

		// Create ports
		res = CreateVoicePortsLocal( uiFlags );
		if ( res < 0 )
		{
			Warning( "VOICE PS3: Failed to create voice ports! Error code %d\n", res );
			cellVoiceEnd();
			cellSysmoduleUnloadModule( CELL_SYSMODULE_VOICE );
			m_bUserRegistered[ GetVoiceUserIndex( iController ) ] = kVoiceNotInitialized;
		}
	}
	
	if ( xPlayer )
	{
		if ( m_bUserRegistered[ GetVoiceUserIndex( iController ) ] < kVoiceOpen )
		{
			DevWarning( "VOICE PS3: Cannot add remote talkers since voice system is not initialized (state %d)\n", m_bUserRegistered[ GetVoiceUserIndex( iController ) ] );
			Assert( 0 );
			return;
		}
		for ( int k = 0; k < m_arrRemoteTalkers.Count(); ++ k )
		{
			if ( m_arrRemoteTalkers[k].m_xuid == xPlayer )
				return;
		}

		RemoteTalker_t rt = { xPlayer, 0, uiFlags, 0 };
		int res = CreateVoicePortsRemote( rt );
		if ( res < 0 )
		{
			DevWarning( "VOICE PS3: Cannot add remote talker %llx! Failed to create ports, error %d\n", xPlayer, res );
			return;
		}

		m_arrRemoteTalkers.AddToTail( rt );
		DevMsg( "VOICE PS3: added remote talker %llx\n", xPlayer );
	}
}

int CEngineVoicePs3::CreateVoicePortsLocal( uint64 uiFlags )
{
	int res = CELL_OK;

	CellVoicePortParam pp;
	Q_memset( &pp, 0, sizeof( pp ) );
	pp.threshold = 100;
	pp.volume = 1.0f;

	// MIC > [IMic]
	pp.portType = CELLVOICE_PORTTYPE_IN_MIC;
	pp.device.playerId = 0;
	res = cellVoiceCreatePort( &m_portIMic, &pp );
	if ( res < 0 ) return res;
	// MIC > [IMic] > [OVoice]
	pp.portType = CELLVOICE_PORTTYPE_OUT_VOICE;
	pp.voice.bitrate = CELLVOICE_BITRATE_7300;
	res = cellVoiceCreatePort( &m_portOVoice, &pp );
	if ( res < 0 ) return res;
	res = cellVoiceConnectIPortToOPort( m_portIMic, m_portOVoice );
	if ( res < 0 ) return res;

#ifndef SOUND_PC_CELP_SUPPORTED
	// PCM output
	pp.portType = CELLVOICE_PORTTYPE_OUT_PCMAUDIO;
	pp.pcmaudio.bufSize = 8*1024;
	pp.pcmaudio.format.numChannels = 1;
	pp.pcmaudio.format.sampleAlignment = 1;
	pp.pcmaudio.format.dataType = CELLVOICE_PCM_SHORT_LITTLE_ENDIAN;
	pp.pcmaudio.format.sampleRate = CELLVOICE_SAMPLINGRATE_16000;
	res = cellVoiceCreatePort( &m_portOPcm, &pp );
	if ( res < 0 ) return res;
	res = cellVoiceConnectIPortToOPort( m_portIMic, m_portOPcm );
	if ( res < 0 ) return res;
#endif

	// Remote > [OEarphone]
	pp.portType = CELLVOICE_PORTTYPE_OUT_SECONDARY;
	pp.device.playerId = 0;
	res = cellVoiceCreatePort( &m_portOEarphone, &pp );
	if ( res < 0 ) return res;
	// IVoiceEcho
	pp.portType = CELLVOICE_PORTTYPE_IN_VOICE;
	pp.voice.bitrate = CELLVOICE_BITRATE_7300;
	res = cellVoiceCreatePort( &m_portIVoiceEcho, &pp );
	if ( res < 0 ) return res;
	res = cellVoiceConnectIPortToOPort( m_portIVoiceEcho, m_portOEarphone );
	if ( res < 0 ) return res;

	// Start
	res = sys_memory_container_create( &m_memContainer, 1024*1024 );
	if ( res < 0 ) return res;
	CellVoiceStartParam cvsp;
	Q_memset( &cvsp, 0, sizeof( cvsp ) );
	cvsp.container = m_memContainer;
	res = cellVoiceStartEx( &cvsp );
	if ( ( res < 0 ) && ( m_memContainer != SYS_MEMORY_CONTAINER_ID_INVALID ) )
	{
		sys_memory_container_destroy( m_memContainer );
		m_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID;
	}
	if ( res < 0 ) return res;

	m_portOSendForRemote = m_portOVoice;
	m_bUserRegistered[ GetVoiceUserIndex( XBX_GetPrimaryUserId() ) ] = kVoiceOpen;
	return res;
}

int CEngineVoicePs3::CreateVoicePortsRemote( RemoteTalker_t &rt )
{
	VoiceResetLocalData( XBX_GetPrimaryUserId() );

	CellVoicePortParam pp;
	Q_memset( &pp, 0, sizeof( pp ) );
	pp.threshold = 100;
	pp.volume = 1.0f;
#ifndef SOUND_PC_CELP_SUPPORTED
	if ( !( rt.m_uiFlags & ENGINE_VOICE_FLAG_PS3 ) )
	{
		pp.portType = CELLVOICE_PORTTYPE_IN_PCMAUDIO;
		pp.threshold = 0; // can't have PCM threshold (needs huge buffer)
		pp.pcmaudio.bufSize = 8 * 1024;
		pp.pcmaudio.format.numChannels = 1;
		pp.pcmaudio.format.sampleAlignment = 1;
		pp.pcmaudio.format.dataType = CELLVOICE_PCM_SHORT_LITTLE_ENDIAN;
		pp.pcmaudio.format.sampleRate = CELLVOICE_SAMPLINGRATE_16000;
		m_portOSendForRemote = m_portOPcm;
	}
	else
#endif
	{
		pp.portType = CELLVOICE_PORTTYPE_IN_VOICE;
		pp.voice.bitrate = CELLVOICE_BITRATE_7300;
		m_portOSendForRemote = m_portOVoice;
	}

	int res = cellVoiceCreatePort( &rt.m_portIRemoteVoice, &pp );
	if ( res < 0 ) return res;

	res = cellVoiceConnectIPortToOPort( rt.m_portIRemoteVoice, m_portOEarphone );
	if ( res < 0 )
	{
		cellVoiceDeletePort( rt.m_portIRemoteVoice );
	}

	return res;
}

void CEngineVoicePs3::RemovePlayerFromVoiceList( XUID xPlayer, int iController )
{
	if ( !m_bUserRegistered[ GetVoiceUserIndex( iController ) ] )
		return;

	if ( xPlayer )
	{
		// Find the remote player in our list
		for ( int k = 0; k < m_arrRemoteTalkers.Count(); ++ k )
		{
			if ( m_arrRemoteTalkers[k].m_xuid == xPlayer )
			{
				cellVoiceDisconnectIPortFromOPort( m_arrRemoteTalkers[k].m_portIRemoteVoice, m_portOEarphone );
				cellVoiceDeletePort( m_arrRemoteTalkers[k].m_portIRemoteVoice );
				m_arrRemoteTalkers.Remove( k );
				DevMsg( "VOICE PS3: removed remote talker %llx\n", xPlayer );
				return;
			}
		}
		DevWarning( "CEngineVoicePs3::RemovePlayerFromVoiceList for unregistered remote talker %llx!\n", xPlayer );
		return;
	}

	// Local player removed shuts down the whole voice system

	cellVoiceEnd();
	cellSysmoduleUnloadModule( CELL_SYSMODULE_VOICE );
	if ( m_memContainer != SYS_MEMORY_CONTAINER_ID_INVALID )
	{
		sys_memory_container_destroy( m_memContainer );
		m_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID;
	}

	m_bUserRegistered[ GetVoiceUserIndex( iController ) ] = kVoiceNotInitialized;
	DevMsg( "PS3 Voice: microphone library stopped and unloaded\n" );
	m_arrRemoteTalkers.Purge();
}

void CEngineVoicePs3::PlayIncomingVoiceData( XUID xuid, const byte *pbData, unsigned int dwDataSize, const bool *bAudiblePlayers )
{
	if ( !voice_xplay_enable.GetBool() )
		return;
	if ( m_bUserRegistered[ GetVoiceUserIndex( XBX_GetPrimaryUserId() ) ] < kVoiceOpen )
		return;

	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_xplay_echo.GetBool() && ( m_portOSendForRemote == m_portOVoice ) )
			{
				cellVoiceWriteToIPort( m_portIVoiceEcho, pbData, &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];

			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 );
		}
	}
	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;
	}

	//
	// Save incoming stream
	//
	for ( int k = 0; k < m_arrRemoteTalkers.Count(); ++ k )
	{
		if ( m_arrRemoteTalkers[k].m_xuid == xuid )
		{
			cellVoiceWriteToIPort( m_arrRemoteTalkers[k].m_portIRemoteVoice, pbData, &dwDataSize );
			m_arrRemoteTalkers[k].m_flLastTalkTimestamp = Plat_FloatTime();
			return;
		}
	}
}

void CEngineVoicePs3::PlayPortInterruptHandler()
{
}


void CEngineVoicePs3::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;
		}
		
		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 CEngineVoicePs3::VoiceUpdateData( int iCtrlr  )
{
	int32 dwBytes = 0;
	int32 wVoiceBytes = 0;
	bool bShouldSend = false;

	//Update UI stuff.
	UpdateHUDVoiceStatus();

	if ( m_bUserRegistered[ GetVoiceUserIndex( iCtrlr ) ] < kVoiceOpen )
		return false;

	if ( 1 )
	{
		int i = GetVoiceUserIndex( iCtrlr );

		dwBytes = m_ChatBufferSize - m_wLocalDataSize[i];

		if( dwBytes < ( m_ChatBufferSize/10 ) )
		{
			bShouldSend = true;
		}
		else
		{
			int res = cellVoiceReadFromOPort( m_portOSendForRemote, m_ChatBuffer[i] + m_wLocalDataSize[i], (uint32*) &dwBytes );
			if ( ( res >= 0 ) && ( dwBytes > 0 ) )
			{
				m_wLocalDataSize[i] += ( dwBytes ) & 0xFFFF;
				wVoiceBytes += ( dwBytes ) & 0xFFFF;

				if( m_wLocalDataSize[i] >= 64 ) // voice buffer enough size that it should get sent
				{
					bShouldSend = true;
				}
			}
		}
	}

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

void CEngineVoicePs3::SetPlaybackPriority( XUID remoteTalker, int iController, int iAllowPlayback )
{
	// No muting support in voice engine
}

void CEngineVoicePs3::GetRemoteTalkers( int *pNumTalkers, XUID *pRemoteTalkers )
{
	if ( pNumTalkers )
		*pNumTalkers = m_arrRemoteTalkers.Count();

	if ( pRemoteTalkers )
	{
		for ( int k = 0; k < m_arrRemoteTalkers.Count(); ++ k )
			pRemoteTalkers[k] = m_arrRemoteTalkers[k].m_xuid;
	}
}

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

void CEngineVoicePs3::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;

	int iController = GetVoiceUserIndex( iCtrlr );
	if ( !m_wLocalDataSize[ iController ] ) 
		return;

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

void CEngineVoicePs3::VoiceSendData( int iCtrlr, INetChannel *pChannel )
{
	if ( !pChannel )
		return;

	CCLCMsg_VoiceData_t voiceMsg;
	GetVoiceData( iCtrlr, &voiceMsg );

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

void CEngineVoicePs3::VoiceResetLocalData( int iCtrlr )
{
	iCtrlr = GetVoiceUserIndex( iCtrlr );

	if ( voice_xplay_bandwidth_debug.GetBool() && m_wLocalDataSize[iCtrlr] )
	{
		DevMsg( "PS3 Voice: microphone stream %0.2fKb\n", m_wLocalDataSize[iCtrlr]/1024.0f );
	}

	m_dwLastVoiceSend[ iCtrlr ] = Plat_FloatTime();
	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 CEngineVoicePs3::IsLocalPlayerTalking( int controllerID )
{
	controllerID = GetVoiceUserIndex( controllerID );
	return ( m_wLocalDataSize[controllerID] > 0 ) || ( Plat_FloatTime() - m_dwLastVoiceSend[controllerID] <= MAX_VOICE_BUFFER_TIME );
}

bool CEngineVoicePs3::IsPlayerTalking( XUID uid )
{
	if ( !g_pMatchFramework->GetMatchSystem()->GetMatchVoice()->CanPlaybackTalker( uid ) )
		return false;

	for ( int k = 0; k < m_arrRemoteTalkers.Count(); ++ k )
	{
		if ( m_arrRemoteTalkers[k].m_xuid == uid )
		{
			return ( ( Plat_FloatTime() - m_arrRemoteTalkers[k].m_flLastTalkTimestamp ) < 0.2 );
		}
	}
	return false;
}

bool CEngineVoicePs3::IsHeadsetPresent( int id )
{
	return ( m_bUserRegistered[ GetVoiceUserIndex( id ) ] >= kVoiceInit );
}
#pragma warning(pop)

void CEngineVoicePs3::RemoveAllTalkers()
{
	RemovePlayerFromVoiceList( NULL, XBX_GetPrimaryUserId() ); // there's only one user possibly registered, unregister it
}

CEngineVoicePs3 *Audio_GetXVoice( void )
{
	if ( CAudioPS3LibAudio::m_pSingleton )
	{
		return CAudioPS3LibAudio::m_pSingleton->GetVoiceData();
	}

	return NULL;
}


EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CEngineVoicePs3, IEngineVoice,
								  IENGINEVOICE_INTERFACE_VERSION, *Audio_GetXVoice() );
#endif