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

//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose: 
//
// $NoKeywords: $
//
//===========================================================================//

#include "audio_pch.h"
#include "utllinkedlist.h"
#include "utldict.h"
#include "filesystem/IQueuedLoader.h"
#include "cdll_int.h"
#include "mempool.h"
#include "memstack.h"
#include "ienginetoolinternal.h"
#include "vstdlib/jobthread.h"
#include "tier3/tier3.h"

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

extern IVEngineClient *engineClient;
extern IFileSystem *g_pFileSystem;
extern double realtime;

// console streaming buffer implementation, appropriate for high latency and low memory
// shift this many buffers through the wave

// We need to be careful with these settings as depending of the values, this may reduce the number we can play simultaneously.
//	If per sound, 2 buffers of 32 Kb are allocated, then we can have 64 different sounds simultaneously.
//  If per sound, 4 buffers of 64 Kb are allocated, then we can have 16 different sounds simultaneously.

// For non-looped sounds, only 2 buffers are needed for streaming.
// For looped sounds, we may need up to 4 buffers. (assuming that the last sound frame is at the beginning of the buffer, and the first loop sound frame is at the end of a buffer).

#if IsX360()
# define STREAM_BUFFER_COUNT				2
#if !defined( CSTRIKE15 )
# define STREAM_BUFFER_DATASIZE				( 2 * XBOX_DVD_ECC_SIZE )		// On X360 DVD, to reduce the number of seeks we actually read 64 Kb at a time instead of 32 Kb
																			// This increases the memory in term of temp buffer, it reduces the number of different sounds stored in the cache
#else
# define STREAM_BUFFER_DATASIZE				( 1 * XBOX_DVD_ECC_SIZE )		// CSTRIKE15 is not shipping on a DVD
#endif

// XBox has enough memory, and needs to lighten the i/o for the DVD (not using the HDD on this product)
// NOTE: in the case of asian languages, we need to spend an extra 7MB loading a large font file - this is taken from the audio cache.
# define CONSOLE_STREAMING_AUDIO_PORTAL2	( 20 * 1024 * 1024 )
# define ASIAN_FONT_MEMORY_USAGE			(  7 * 1024 * 1024 )
#elif IsPS3()
# define STREAM_BUFFER_COUNT				4				// Don't use memory for 4 buffers but 3, as in most case it is enough. In rare cases, we may have a latency issue.
															// However due to the latency introduced by the saving mechanism (also using the HHD), let's use a bit more for looped sounds.
															// Note that looped sounds on PS3 are not MP3 encoded but WAV encoded, so they are much bigger, we'll use 4 instead of 3 due to the save latency.
# define STREAM_BUFFER_DATASIZE				( 32 * 1024 )	// Blu-Ray has a block size of 64 Kb. We could reduce this to 32 Kb to allow more different sounds, but this would make the loading less optimal.
															// We actually reduced it to 32 Kb (like for X360) as we are now using FIOS for caching on the HDD. 32 Kb is a good size for the HDD.
// We should be good in term of memory on PS3 now.
# define CONSOLE_STREAMING_AUDIO_PORTAL2	( 4 * 1024 * 1024 )
# define ASIAN_FONT_MEMORY_USAGE			( 0 )
#else
# define STREAM_BUFFER_COUNT				4
# define STREAM_BUFFER_DATASIZE				( 64 * 1024 )
# define CONSOLE_STREAMING_AUDIO_PORTAL2	( 4 * 1024 * 1024 )
# define ASIAN_FONT_MEMORY_USAGE			( 0 )
#endif

// PC single buffering implementation
// UNDONE: Allocate this in cache instead?
#define SINGLE_BUFFER_SIZE		( 16 * 1024 )

// console streaming pool
#define CONSOLE_STREAMING_AUDIO_DEFAULT			( 4 * 1024 * 1024 )
#define CONSOLE_STREAMING_AUDIO_TF				( 12 * 1024 * 1024 )
#define CONSOLE_STREAMING_AUDIO_LEFT4DEAD		( 10 * 1024 * 1024 )
#define CONSOLE_STREAMING_AUDIO_LEFT4DEAD_DVD	( 12 * 1024 * 1024 )
#define CONSOLE_STREAMING_AUDIO_CSTRIKE15		( 9 * 1024 * 1024 )

// console static pool
#define CONSOLE_STATIC_AUDIO_DEFAULT			( 8.7 * 1024 * 1024 )
#define CONSOLE_STATIC_AUDIO_PORTAL2			( 2 * 1024 * 1024 )
#define CONSOLE_STATIC_AUDIO_CSTRIKE15			( 0.3 * 1024 * 1024 )

#define DEFAULT_WAV_MEMORY_CACHE				( 20 * 1024 * 1024 )

ConVar snd_async_spew_blocking( "snd_async_spew_blocking", "0", 0, "Spew message to console any time async sound loading blocks on file i/o." );
ConVar snd_async_fullyasync( "snd_async_fullyasync", "1", 0, "All playback is fully async (sound doesn't play until data arrives)." );
ConVar snd_async_stream_spew( "snd_async_stream_spew", "0", 0, "Spew streaming info ( 0=Off, 1=streams, 2=buffers" );
ConVar snd_async_stream_fail( "snd_async_stream_fail", "0", 0, "Spew stream pool failures." );
ConVar snd_async_stream_purges( "snd_async_stream_purges", "0", 0, "Spew stream pool purges." );
ConVar snd_async_stream_static_alloc( "snd_async_stream_static_alloc", "0", 0, "If 1, spews allocations on the static alloc pool. Set to 0 for no spew." );
ConVar snd_async_stream_recover_from_exhausted_stream( "snd_async_stream_recover_from_exhausted_stream", "1", 0, "If 1, recovers when the stream is exhausted when playing PCM sounds (prevents music or ambiance sounds to stop if too many sounds are played). Set to 0, to stop the sound otherwise." );
ConVar snd_async_stream_spew_exhausted_buffer( "snd_async_stream_spew_exhausted_buffer", IsCert() ? "0" : "1", 0, "If 1, spews warnings when the buffer is exhausted (recommended). Set to 0 for no spew (for debugging purpose only)." );
ConVar snd_async_stream_spew_exhausted_buffer_time( "snd_async_stream_spew_exhausted_buffer_time", "1000", 0, "Number of milliseconds between each exhausted buffer spew." );
ConVar snd_async_stream_spew_delayed_start_time( "snd_async_stream_spew_delayed_start_time", "500", 0, "Spew any asynchronous sound that starts with more than N milliseconds delay. By default spew when there is more than 500 ms delay." );
ConVar snd_async_stream_spew_delayed_start_filter( "snd_async_stream_spew_delayed_start_filter", "vo", 0, "Filter used to spew sounds that starts late. Use an empty string \"\" to display all sounds. By default only the VO are displayed.");
extern ConVar snd_report_loop_sound;

#define SndAlignReads() 1

void MaybeReportMissingWav( char const *wav );

// xbox pools its transient fixed sized streaming buffers
static CUtlMemoryPool *g_pAudioStreamPool;
static CMemoryStack *g_pAudioStaticPool;



//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
struct asyncwaveparams_t
{
	asyncwaveparams_t() : 
		bPrefetch( false ), 
		bCanBeQueued( false ),
		bIsTransient( false ),
		bIsStaticPooled( false )
	{}

	FileNameHandle_t	hFilename;	// handle to sound item name (i.e. not with sound\ prefix)
	int					datasize;
	int					seekpos;
	int					alignment;
	unsigned int		bPrefetch : 1;
	unsigned int		bCanBeQueued : 1;
	unsigned int		bIsTransient : 1;
	unsigned int		bIsStaticPooled : 1;
};

//-----------------------------------------------------------------------------
// Purpose: Builds a cache of the data bytes for a specific .wav file
//-----------------------------------------------------------------------------
class CAsyncWaveData
{
public:
	explicit CAsyncWaveData();

	void DestroyResource();
	CAsyncWaveData *GetData();
	unsigned int Size();

	static void AsyncCallback( const FileAsyncRequest_t &asyncRequest, int numReadBytes, FSAsyncStatus_t err );
	static void QueuedLoaderCallback( void *pContext, void *pContext2, const void *pData, int nSize, LoaderError_t loaderError );
	static CAsyncWaveData *CreateResource( const asyncwaveparams_t &params );
	static unsigned int EstimatedSize( const asyncwaveparams_t &params );

	void OnAsyncCompleted( const FileAsyncRequest_t* asyncFilePtr, int numReadBytes, FSAsyncStatus_t err );
	bool BlockingCopyData( void *destbuffer, int destbufsize, int startoffset, int count );
	bool BlockingGetDataPointer( void **ppData );
	void SetAsyncPriority( int priority );
	void StartAsyncLoading( const asyncwaveparams_t& params );
	bool GetPostProcessed();
	void SetPostProcessed( bool proc );

	bool IsCurrentlyLoading();
	char const *GetFileName();

	// Data
public:
	int					m_nDataSize;		// bytes requested
	int					m_nReadSize;		// bytes actually read
	void				*m_pvData;			// target buffer
	void				*m_pAlloc;			// memory of buffer (base may not match)
	FileAsyncRequest_t	m_async;
	FSAsyncControl_t	m_hAsyncControl;
	float				m_start;			// time at request invocation
	float				m_arrival;			// time at data arrival
	FileNameHandle_t	m_hFileNameHandle;
	int					m_nBufferBytes;		// size of any pre-allocated target buffer
	BufferHandle_t		m_hBuffer;			// used to dequeue the buffer after lru
	unsigned int		m_bLoaded : 1;
	unsigned int		m_bMissing : 1;
	unsigned int		m_bPostProcessed : 1;
	unsigned int		m_bIsTransient : 1;
	unsigned int		m_bIsStaticPooled : 1;
};

enum WaveCacheAddFlags_t
{
	WCAF_LOCK		= ( 1 << 0 ),
	WCAF_DEFAULT	= 0,
};

struct WaveCacheStatus_t
{
	int nBytes;
};

struct WaveCacheLimits_t
{
	int nMaxBytes;
};

struct WaveCache_t
{
	CAsyncWaveData *m_pWaveData;
	unsigned int	m_nDataSize;
	unsigned int	m_nAgeStamp;
	unsigned int	m_nLockCount;
	int				m_hUnlock;
};

// Replacement for wavedata hosted by datacache which had some costlier aspects. When small purges needed
// to occur for the console streaming solution, the datacache's global lru list would need to be iterated.
// This replacement class attempts to provide the minimal necessary thread safe behavior to provide just
// the service that the wavedatacache uses. The lru list (only unlocked resources) is maintained by an age
// count, not link order.
class CWaveCache
{
public:
	CWaveCache()
	{
		m_nCurrentMemorySize = 0;
		m_nMaxMemorySize = UINT_MAX;
		m_nAgeStamp = 1;

		// reserve the 0 entry, want to use 0 as invalid to remain compliant to datacache code
		// which used 0 as an invalid handle
		WaveCacheHandle_t hData = m_HandleTable.AddHandle();
		Assert( hData == 0 );
		hData;
	}

	void Init( unsigned int nMemorySize )
	{
#if defined(LINUX) && !defined(DEDICATED)
		m_nMaxMemorySize = -1;
#else
		// can be -1 (i.e. unlimited, no implicit purge occurs via create)
		m_nMaxMemorySize = nMemorySize;
#endif
	}

	void Shutdown()
	{
	}

	CAsyncWaveData *CacheGet( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return NULL;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return NULL;

		pCacheData->m_nAgeStamp = m_nAgeStamp++;

		return pCacheData->m_pWaveData;
	}

	CAsyncWaveData *CacheGetNoTouch( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return NULL;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return NULL;

		return pCacheData->m_pWaveData;
	}

	CAsyncWaveData *CacheLock( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return NULL;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return NULL;

		pCacheData->m_nAgeStamp = m_nAgeStamp++;

		pCacheData->m_nLockCount++;
		if ( pCacheData->m_nLockCount == 1 && pCacheData->m_hUnlock != m_UnlockedList.InvalidIndex() )
		{
			// remove from unlocked list
			m_UnlockedList.Remove( pCacheData->m_hUnlock );
			pCacheData->m_hUnlock = m_UnlockedList.InvalidIndex();
		}

		return pCacheData->m_pWaveData;
	}

	int CacheUnlock( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return 0;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return 0;

		if ( pCacheData->m_nLockCount > 0 )
		{
			pCacheData->m_nLockCount--;
			if ( pCacheData->m_nLockCount == 0 )
			{
				// add to unlocked list
				pCacheData->m_hUnlock = m_UnlockedList.AddToTail( hData );
			}
		}

		return pCacheData->m_nLockCount;
	}

	WaveCacheHandle_t CacheCreate( asyncwaveparams_t params, WaveCacheAddFlags_t flags = WCAF_DEFAULT )
	{
		AUTO_LOCK_FM( m_WaveCacheMutex );

		if ( m_nMaxMemorySize != UINT_MAX )
		{
			unsigned int nBytesToPurge = CAsyncWaveData::EstimatedSize( params );

			if ( m_nCurrentMemorySize + nBytesToPurge > m_nMaxMemorySize )
			{
				Purge( nBytesToPurge );

				if ( m_nCurrentMemorySize + nBytesToPurge > m_nMaxMemorySize )
				{
					// not enough memory
					return INVALID_WAVECACHE_HANDLE;
				}
			}
		}

		CAsyncWaveData *pWaveData = CAsyncWaveData::CreateResource( params );
		if ( !pWaveData )
		{
			return INVALID_WAVECACHE_HANDLE;
		}

		WaveCache_t *pCacheData = new WaveCache_t;

		pCacheData->m_pWaveData = pWaveData;
		pCacheData->m_nDataSize = pWaveData->Size();
		pCacheData->m_nAgeStamp = m_nAgeStamp++;

		m_nCurrentMemorySize += pCacheData->m_nDataSize;

		WaveCacheHandle_t hData = m_HandleTable.AddHandle();

		if ( flags & WCAF_LOCK )
		{
			pCacheData->m_nLockCount = 1;
			pCacheData->m_hUnlock = m_UnlockedList.InvalidIndex();
		}
		else
		{
			pCacheData->m_nLockCount = 0;
			pCacheData->m_hUnlock = m_UnlockedList.AddToTail( hData );
		}

		m_HandleTable.SetHandle( hData, pCacheData );

		return hData;
	}

	bool CacheRemove( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return false;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData || pCacheData->m_nLockCount != 0 )
			return false;

		if ( snd_async_stream_purges.GetBool() )
		{
			Msg( "CacheRemove: Age:%d %s\n", pCacheData->m_nAgeStamp, pCacheData->m_pWaveData->GetFileName() );
		}

		pCacheData->m_pWaveData->DestroyResource();

		m_nCurrentMemorySize -= pCacheData->m_nDataSize;
		
		if ( pCacheData->m_hUnlock != m_UnlockedList.InvalidIndex() )
		{
			m_UnlockedList.Remove( pCacheData->m_hUnlock );
		}

		m_HandleTable.RemoveHandle(	hData );

		delete pCacheData;

		return true;
	}

	void BreakLock( WaveCacheHandle_t hData ) 
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return;

		if ( pCacheData->m_nLockCount != 0 )
		{
			pCacheData->m_nLockCount = 0;

			// add to unlocked list
			pCacheData->m_hUnlock = m_UnlockedList.AddToTail( hData );
		}
	}

	void Age( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return;

		// the oldest sounds are ones that have not been touched
		pCacheData->m_nAgeStamp = 0;
	}

	int GetLockCount( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return 0;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return 0;

		return pCacheData->m_nLockCount;
	}

	unsigned int GetAgeStamp( WaveCacheHandle_t hData )
	{
		if ( hData == INVALID_WAVECACHE_HANDLE )
		{
			// must trap, the 0 entry is a valid index
			return 0;
		}

		AUTO_LOCK_FM( m_WaveCacheMutex );

		WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
		if ( !pCacheData )
			return 0;

		return pCacheData->m_nAgeStamp;
	}

	void Purge( unsigned int nBytesToPurge )
	{
		AUTO_LOCK_FM( m_WaveCacheMutex );

		// keep purging the oldest unlocked until desired memory is available
		// trying to keep this as cheap as possible, so no sorting, just an iteration to find oldest
		unsigned int nBytesPurged = 0;
		while ( nBytesPurged < nBytesToPurge )
		{
			unsigned int nCandidateSize = 0;
			unsigned int nCandidateAge = UINT_MAX;
			WaveCacheHandle_t hCandidate = INVALID_WAVECACHE_HANDLE;
			for ( int hUnlock = m_UnlockedList.Head(); hUnlock != m_UnlockedList.InvalidIndex(); hUnlock = m_UnlockedList.Next( hUnlock ) )
			{
				WaveCacheHandle_t hData = m_UnlockedList[hUnlock];
				WaveCache_t *pCacheData = m_HandleTable.GetHandle( hData );
				if ( pCacheData && pCacheData->m_nAgeStamp < nCandidateAge )
				{
					nCandidateAge = pCacheData->m_nAgeStamp;
					nCandidateSize = pCacheData->m_nDataSize;
					hCandidate = hData;
				}
			}

			if ( hCandidate != INVALID_WAVECACHE_HANDLE && CacheRemove( hCandidate ) )
			{
				nBytesPurged += nCandidateSize;
			}
			else
			{
				// there are no unlocked candidates
				// or the qualified remove failed
				break;
			}
		}
	}

	void Flush()
	{
		AUTO_LOCK_FM( m_WaveCacheMutex );

		CUtlVector< WaveCacheHandle_t > purgeList( 0, m_UnlockedList.Count() );
		for ( int hUnlock = m_UnlockedList.Head(); hUnlock != m_UnlockedList.InvalidIndex(); hUnlock = m_UnlockedList.Next( hUnlock ) )
		{
			purgeList.AddToTail( m_UnlockedList[hUnlock] );
		}

		// remove all unlocked resources
		for ( int i = 0; i < purgeList.Count(); i++ )
		{
			CacheRemove( purgeList[i] );
		}
	}

	void CacheLockMutex()
	{
		m_WaveCacheMutex.Lock();
	}

	void CacheUnlockMutex()
	{
		m_WaveCacheMutex.Unlock();
	}

	void GetStatus( WaveCacheStatus_t *pStatus, WaveCacheLimits_t *pLimits )
	{
		pStatus->nBytes = m_nCurrentMemorySize;
		pLimits->nMaxBytes = m_nMaxMemorySize;
	}

private:
	unsigned int m_nCurrentMemorySize;
	unsigned int m_nMaxMemorySize;

	unsigned int m_nAgeStamp;

	CThreadFastMutex m_WaveCacheMutex;

	// 2048 simultaneous sound handles in the cache
	CUtlHandleTable< WaveCache_t, 11 > m_HandleTable;

	CUtlLinkedList< WaveCacheHandle_t > m_UnlockedList;
};
CWaveCache s_WaveCache;

//-----------------------------------------------------------------------------
// Purpose: C'tor
//-----------------------------------------------------------------------------
CAsyncWaveData::CAsyncWaveData() :
	m_nDataSize( 0 ),
	m_nReadSize( 0 ),
	m_pvData( 0 ),
	m_pAlloc( 0 ),
	m_hBuffer( INVALID_BUFFER_HANDLE ),
	m_nBufferBytes( 0 ),
	m_hAsyncControl( NULL ),
	m_bLoaded( false ),
	m_bMissing( false ),
	m_start( 0.0 ),
	m_arrival( 0.0 ),
	m_bPostProcessed( false ),
	m_bIsTransient( false ),
	m_bIsStaticPooled( false ),
	m_hFileNameHandle( 0 )
{
}

//-----------------------------------------------------------------------------
// Purpose: // APIS required by CDataLRU
//-----------------------------------------------------------------------------
void CAsyncWaveData::DestroyResource()
{
	if ( IsPC() )
	{
		if ( m_hAsyncControl )
		{
			if ( !m_bLoaded && !m_bMissing )
			{
				// NOTE:  We CANNOT call AsyncAbort since if the file is actually being read we'll end 
				//  up still getting a callback, but our this ptr (deleted below) will be feeefeee and we'll trash the heap 
				//  pretty bad.  So we call AsyncFinish, which will do a blocking read and will definitely succeed	
				// Block until we are finished
				g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
			}
			
			g_pFileSystem->AsyncRelease( m_hAsyncControl );
			m_hAsyncControl = NULL;
		}
	}

	if ( IsGameConsole() )
	{
		if ( m_hAsyncControl )
		{
			if ( !m_bLoaded && !m_bMissing )
			{
				// force an abort
				int errStatus = g_pFileSystem->AsyncAbort( m_hAsyncControl );
				if ( errStatus != FSASYNC_ERR_UNKNOWNID )
				{
					// must wait for abort to finish before deallocating data
					g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
				}
			}
			g_pFileSystem->AsyncRelease( m_hAsyncControl );
			m_hAsyncControl = NULL;
		}
		if ( m_hBuffer != INVALID_BUFFER_HANDLE )
		{
			// hint the manager that this tracked buffer is invalid
			wavedatacache->MarkBufferDiscarded( m_hBuffer );
		}
	}

	// delete buffers
	if ( IsPC() )
	{
		g_pFileSystem->FreeOptimalReadBuffer( m_pAlloc );
	}

	if ( IsGameConsole() )
	{
		if ( m_bIsTransient )
		{
			g_pAudioStreamPool->Free( m_pAlloc );
		}
		else if ( m_bIsStaticPooled )
		{
			// freed as part of pool purge
		}
		else
		{
			free( m_pAlloc );
		}
	}

	delete this;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : char const
//-----------------------------------------------------------------------------
char const *CAsyncWaveData::GetFileName()
{
	static char sz[MAX_PATH];

	if ( m_hFileNameHandle )	
	{
		if ( g_pFileSystem->String( m_hFileNameHandle, sz, sizeof( sz ) ) )
		{
			return sz;
		}
	}
	
	Assert( 0 );
	return "";
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : CAsyncWaveData
//-----------------------------------------------------------------------------
CAsyncWaveData *CAsyncWaveData::GetData()
{ 
	return this; 
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : unsigned int
//-----------------------------------------------------------------------------
unsigned int CAsyncWaveData::Size()
{ 
	int size;

	if ( IsPC() )
	{
		size = sizeof( *this ) + m_nDataSize;
	}

	if ( IsGameConsole() )
	{
		// the data size is volatile and shrinks during streaming near end of file
		// report the real constant size of this object's allocation
		size = m_nBufferBytes;
	}

	return size;
}

//-----------------------------------------------------------------------------
// Purpose: Static method for CDataLRU
// Input  : &params - 
// Output : CAsyncWaveData
//-----------------------------------------------------------------------------
CAsyncWaveData *CAsyncWaveData::CreateResource( const asyncwaveparams_t &params )
{
	MEM_ALLOC_CREDIT_( "CAsyncWaveData::CreateResource" );

	CAsyncWaveData *pData = NULL;

	if ( IsGameConsole() )
	{
		// create buffers now for re-use during streaming process
		void *pBuffer = NULL;
		int bufferSize;
		bool bIsStaticPooled = params.bIsStaticPooled;
		if ( params.bIsTransient )
		{
			// streaming transient sounds pool their fixed size dynamic buffers to lighten fragmentation
			bufferSize = STREAM_BUFFER_DATASIZE;
			pBuffer = g_pAudioStreamPool->Alloc();
			if ( !pBuffer )
			{
				// pool is empty, purge required
				// failure case detected by create logic, will drive purge and retry
				return NULL;
			}
		}
		else
		{
			// non-streaming sounds have buffers that are only transient during map transitions
			bufferSize = AlignValue( params.datasize, params.alignment );
			if ( bIsStaticPooled )
			{
				// pool these sounds
				pBuffer = g_pAudioStaticPool->Alloc( bufferSize );
				if ( snd_async_stream_static_alloc.GetBool() )
				{
					Msg( "CAsyncWavDataCache: Static Pool: %.2f MB used of %.2f MB\n", g_pAudioStaticPool->GetUsed() / ( 1024.0f * 1024.0f ), g_pAudioStaticPool->GetSize() / ( 1024.0f * 1024.0f ) );
				}
				if ( !pBuffer )
				{
					Warning( "CAsyncWaveData:: Static Pool OVERFLOW, failing to standard heap!\n" );
					// flip and fail to other heap
					bIsStaticPooled = false;
				}
			}

			if ( !bIsStaticPooled )
			{
				// use the standard heap for non-streaming non-pooled buffers
				pBuffer = new byte[bufferSize];
			}
		}

		pData = new CAsyncWaveData;
		pData->m_nBufferBytes = bufferSize;
		pData->m_pAlloc = pData->m_pvData = pBuffer;
		pData->m_bIsTransient = params.bIsTransient;
		pData->m_bIsStaticPooled = bIsStaticPooled;
	}
	else
	{
		pData = new CAsyncWaveData;
		Assert( pData );
	}

	if ( pData )
	{
		pData->StartAsyncLoading( params );
	}

	return pData;
}

//-----------------------------------------------------------------------------
// Purpose: Static method
// Input  : &params - 
// Output : static unsigned int
//-----------------------------------------------------------------------------
unsigned int CAsyncWaveData::EstimatedSize( const asyncwaveparams_t &params )
{
	int size;

	if ( IsPC() )
	{
		size = 	sizeof( CAsyncWaveData ) + params.datasize;
	}

	if ( IsGameConsole() )
	{
		// the expected size of this object's allocations
		if ( params.bIsTransient )
		{
			size = STREAM_BUFFER_DATASIZE;
		}
		else
		{
			size = AlignValue( params.datasize, params.alignment );
		}
	}

	return size;
}

//-----------------------------------------------------------------------------
// Purpose: Static method, called by thread, don't call anything non-threadsafe from handler!!!
// Input  : asyncFilePtr - 
//			numReadBytes - 
//			err - 
//-----------------------------------------------------------------------------
void CAsyncWaveData::AsyncCallback(const FileAsyncRequest_t &asyncRequest, int numReadBytes, FSAsyncStatus_t err )
{
	CAsyncWaveData *pObject = reinterpret_cast< CAsyncWaveData * >( asyncRequest.pContext );
	Assert( pObject );
	if ( pObject )
	{
		pObject->OnAsyncCompleted( &asyncRequest, numReadBytes, err );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Static method, called by thread, don't call anything non-threadsafe from handler!!!
//-----------------------------------------------------------------------------
void CAsyncWaveData::QueuedLoaderCallback( void *pContext, void *pContext2, const void *pData, int nSize, LoaderError_t loaderError )
{
	CAsyncWaveData *pObject = reinterpret_cast< CAsyncWaveData * >( pContext );
	Assert( pObject );

	pObject->OnAsyncCompleted( NULL, nSize, loaderError == LOADERERROR_NONE ? FSASYNC_OK : FSASYNC_ERR_FILEOPEN );
}

//-----------------------------------------------------------------------------
// Purpose: NOTE: THIS IS CALLED FROM A THREAD SO YOU CAN'T CALL INTO ANYTHING NON-THREADSAFE
//  such as CUtlSymbolTable/CUtlDict (many of the CUtl* are non-thread safe)!!!
// Input  : asyncFilePtr - 
//			numReadBytes - 
//			err - 
//-----------------------------------------------------------------------------
void CAsyncWaveData::OnAsyncCompleted( const FileAsyncRequest_t *asyncFilePtr, int numReadBytes, FSAsyncStatus_t err )
{
	if ( IsPC() )
	{
		// Take hold of pointer (we can just use delete[] across .dlls because we are using a shared memory allocator...)
		if ( err == FSASYNC_OK || err == FSASYNC_ERR_READING )
		{
			m_arrival = ( float )Plat_FloatTime();

			// Take over ptr
			m_pAlloc = asyncFilePtr->pData;
			if ( SndAlignReads() )
			{
				m_async.nOffset = ( m_async.nBytes - m_nDataSize );
				m_async.nBytes -= m_async.nOffset;
				m_pvData = ((byte *)m_pAlloc) + m_async.nOffset;
				m_nReadSize	= numReadBytes - m_async.nOffset;
			}
			else
			{
				m_pvData = m_pAlloc;
				m_nReadSize = numReadBytes;
			}

			// Needs to be post-processed
			m_bPostProcessed = false;

			// Finished loading
			m_bLoaded = true;
		}
		else if ( err == FSASYNC_ERR_FILEOPEN )
		{
			// SEE NOTE IN FUNCTION COMMENT ABOVE!!!
			// Tracker 22905, et al.
			// Because this api gets called from the other thread, don't spew warning here as it can
			//  cause a crash in searching CUtlSymbolTables since they use a global var for a LessFunc context!!!
			m_bMissing = true;
		}
	}

	if ( IsGameConsole() )
	{
		m_arrival = (float)Plat_FloatTime();

		// possibly reading more than intended due to alignment restriction
		m_nReadSize = numReadBytes;
		if ( m_nReadSize > m_nDataSize )
		{
			// clamp to expected, extra data is unreliable
			m_nReadSize = m_nDataSize;
		}

		if ( err != FSASYNC_OK )
		{
			// track as any error
			m_bMissing = true;
		}

		if ( err != FSASYNC_ERR_FILEOPEN )
		{
			// some data got loaded
			m_bLoaded = true;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *destbuffer - 
//			destbufsize - 
//			startoffset - 
//			count - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWaveData::BlockingCopyData( void *destbuffer, int destbufsize, int startoffset, int count )
{
	if ( !m_bLoaded )
	{
		Assert( m_hAsyncControl );
		// Force it to finish
		// It could finish between the above line and here, but the AsyncFinish call will just have a bogus id, not a big deal
		if ( snd_async_spew_blocking.GetBool() )
		{
			// Force it to finish
			float st = ( float )Plat_FloatTime();
			g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
			float ed = ( float )Plat_FloatTime();
			DevMsg( "%f BCD:  Async I/O Force %s (%8.2f msec / %8.2f msec total)\n", realtime, GetFileName(), 1000.0f * (float)( ed - st ), 1000.0f * (float)( m_arrival - m_start ) );
		}
		else
		{
			g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
		}
	}

	// notify on any error
	if ( m_bMissing )
	{
		// Only warn once
		m_bMissing = false;

		char fn[MAX_PATH];
		if ( g_pFileSystem->String( m_hFileNameHandle, fn, sizeof( fn ) ) )
		{
			MaybeReportMissingWav( fn );
		}
	}

	if ( !m_bLoaded )
	{
		return false;
	}
	else if ( m_arrival != 0 && snd_async_spew_blocking.GetInt() >= 2 )
	{
		DevMsg( "%f Async I/O Read successful %s (%8.2f msec)\n", realtime, GetFileName(), 1000.0f * (float)( m_arrival - m_start ) );
		m_arrival = 0;
	}

	// clamp requested to available
	if ( count > m_nReadSize )
	{
		count = m_nReadSize - startoffset;
	}

	if ( count < 0 )
	{
		return false;
	}

	// Copy data from stream buffer
	Q_memcpy( destbuffer, (char *)m_pvData + ( startoffset - m_async.nOffset ), count );

	g_pFileSystem->AsyncRelease( m_hAsyncControl );
	m_hAsyncControl = NULL;
	return true;
}


bool CAsyncWaveData::IsCurrentlyLoading()
{
	if ( m_bLoaded )
		return true;
	if ( m_bMissing )
		return false;
	FSAsyncStatus_t status = g_pFileSystem->AsyncStatus( m_hAsyncControl );
	if ( status == FSASYNC_STATUS_INPROGRESS || status == FSASYNC_OK )
		return true;
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : **ppData - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWaveData::BlockingGetDataPointer( void **ppData )
{
	Assert( ppData );
	if ( !m_bLoaded )
	{
		// Force it to finish
		// It could finish between the above line and here, but the AsyncFinish call will just have a bogus id, not a big deal
		if ( snd_async_spew_blocking.GetBool() )
		{
			float st = ( float )Plat_FloatTime();
			g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
			float ed = ( float )Plat_FloatTime();
			DevMsg( "%f BlockingGetDataPointer:  Async I/O Force %s (%8.2f msec / %8.2f msec total )\n", realtime, GetFileName(), 1000.0f * (float)( ed - st ), 1000.0f * (float)( m_arrival - m_start ) );
		}
		else
		{
			g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
		}
	}

	// notify on any error
	if ( m_bMissing )
	{
		// Only warn once
		m_bMissing = false;

		char fn[MAX_PATH];
		if ( g_pFileSystem->String( m_hFileNameHandle, fn, sizeof( fn ) ) )
		{
			MaybeReportMissingWav( fn );
		}
	}

	if ( !m_bLoaded )
	{
		return false;
	}
	else if ( m_arrival != 0 && snd_async_spew_blocking.GetInt() >= 2 )
	{
		DevMsg( "%f Async I/O Read successful %s (%8.2f msec)\n", realtime, GetFileName(), 1000.0f * (float)( m_arrival - m_start ) );
		m_arrival = 0;
	}

	*ppData = m_pvData;

	g_pFileSystem->AsyncRelease( m_hAsyncControl );
	m_hAsyncControl = NULL;

	return true;
}

void CAsyncWaveData::SetAsyncPriority( int priority )
{
	if ( m_async.priority != priority )
	{
		m_async.priority = priority;
		g_pFileSystem->AsyncSetPriority( m_hAsyncControl, m_async.priority );
		if ( snd_async_spew_blocking.GetInt() >= 2 ) 
		{
			DevMsg( "%f Async I/O Bumped priority for %s (%8.2f msec)\n", realtime, GetFileName(), 1000.0f * (float)( Plat_FloatTime() - m_start ) );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : params - 
//-----------------------------------------------------------------------------
void CAsyncWaveData::StartAsyncLoading( const asyncwaveparams_t& params )
{
	Assert( IsGameConsole() || ( IsPC() && !m_bLoaded ) );

	// expected to be relative to the sound\ dir
	m_hFileNameHandle = params.hFilename;

	// build the real filename
	char szFilename[MAX_PATH];
	Q_snprintf( szFilename, sizeof( szFilename ), "sound\\%s", GetFileName() );

	int nPriority = 1;
	if ( params.bPrefetch )
	{
		// lower the priority of prefetched sounds, so they don't block immediate sounds from being loaded
		nPriority = 0;
	}

	if ( !IsGameConsole() )
	{
		m_async.pData = NULL;
		if ( SndAlignReads() )
		{
			m_async.nOffset = 0;
			m_async.nBytes = params.seekpos + params.datasize;
		}
		else
		{
			m_async.nOffset = params.seekpos;
			m_async.nBytes = params.datasize;
		}
	}
	else
	{
		Assert( params.datasize > 0 );

		// using explicit allocated buffer on xbox
		m_async.pData = m_pvData;
		m_async.nOffset = params.seekpos;
		m_async.nBytes = AlignValue( params.datasize, params.alignment ); 
	}

	m_async.pfnCallback	= AsyncCallback;	// optional completion callback
	m_async.pContext = (void *)this;		// caller's unique context
	m_async.priority = nPriority;			// inter list priority, 0=lowest
	m_async.flags = IsGameConsole() ? 0 : FSASYNC_FLAGS_ALLOCNOFREE;
	m_async.pszPathID = "GAME";

	m_bLoaded = false;
	m_bMissing = false;
	m_nDataSize = params.datasize;
	m_start = (float)Plat_FloatTime();
	m_arrival = 0;
	m_nReadSize = 0;
	m_bPostProcessed = false;

	// The async layer creates a copy of this string, ok to send a local reference
	m_async.pszFilename	= szFilename;

	char szFullName[MAX_PATH];
	if ( IsGameConsole() )
	{
		// all audio is expected be in zips
		// resolve to absolute name now, where path can be filtered to just the zips (fast find, no real i/o)
		// otherwise the dvd will do a costly seek for each zip miss due to search path fall through
		PathTypeQuery_t pathType;
		if ( !g_pFileSystem->RelativePathToFullPath( m_async.pszFilename, m_async.pszPathID, szFullName, sizeof( szFullName ), GetAudioPathFilter(), &pathType ) )
		{
			// not found, do callback now to handle error
			m_async.pfnCallback( m_async, 0, FSASYNC_ERR_FILEOPEN );
			return;
		}
		m_async.pszFilename	= szFullName;
	}

	if ( IsGameConsole() && params.bCanBeQueued )
	{
		// queued loader takes over
		LoaderJob_t loaderJob;
		loaderJob.m_pFilename = m_async.pszFilename;
		loaderJob.m_pPathID = m_async.pszPathID;
		loaderJob.m_pCallback = QueuedLoaderCallback;
		loaderJob.m_pContext = (void *)this;
		loaderJob.m_Priority = LOADERPRIORITY_DURINGPRELOAD;
		loaderJob.m_pTargetData = m_async.pData;
		loaderJob.m_nBytesToRead = m_async.nBytes;
		loaderJob.m_nStartOffset = m_async.nOffset;
		g_pQueuedLoader->AddJob( &loaderJob );
		return;
	}

	MEM_ALLOC_CREDIT();
	
	// Commence async I/O
	Assert( !m_hAsyncControl );
	g_pFileSystem->AsyncRead( m_async, &m_hAsyncControl );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWaveData::GetPostProcessed()
{
	return m_bPostProcessed;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : proc - 
//-----------------------------------------------------------------------------
void CAsyncWaveData::SetPostProcessed( bool proc )
{
	m_bPostProcessed = proc;
}

//-----------------------------------------------------------------------------
// Purpose: Implements a cache of .wav / .mp3 data based on filename
//-----------------------------------------------------------------------------
class CAsyncWavDataCache : public IAsyncWavDataCache
{
public:
	CAsyncWavDataCache();
	~CAsyncWavDataCache() {}

	virtual bool			Init( unsigned int memSize );
	virtual void			Shutdown();

	// implementation that treats file as monolithic
	virtual WaveCacheHandle_t	AsyncLoadCache( char const *filename, int datasize, int startpos, bool bIsPrefetch = false );
	virtual void			PrefetchCache( char const *filename, int datasize, int startpos );
	virtual bool			CopyDataIntoMemory( char const *filename, int datasize, int startpos, void *buffer, int bufsize, int copystartpos, int bytestocopy, bool *pbPostProcessed );
	virtual bool			CopyDataIntoMemory( WaveCacheHandle_t& handle, char const *filename, int datasize, int startpos, void *buffer, int bufsize, int copystartpos, int bytestocopy, bool *pbPostProcessed );
	virtual void			SetPostProcessed( WaveCacheHandle_t handle, bool proc );
	virtual void			Unload( WaveCacheHandle_t handle );
	virtual bool			GetDataPointer( WaveCacheHandle_t& handle, char const *filename, int datasize, int startpos, void **pData, int copystartpos, bool *pbPostProcessed );
	virtual bool			IsDataLoadCompleted( WaveCacheHandle_t handle, bool *pIsValid, bool *pIsMissing );
	virtual void			RestartDataLoad( WaveCacheHandle_t* handle, char const *filename, int datasize, int startpos );
	virtual bool			IsDataLoadInProgress( WaveCacheHandle_t handle );

	// Xbox: alternate multi-buffer streaming implementation
	virtual StreamHandle_t	OpenStreamedLoad( char const *pFileName, int dataSize, int dataStart, int startPos, int loopPos, int bufferSize, int numBuffers, streamFlags_t flags, SoundError &soundError );
	virtual void			CloseStreamedLoad( StreamHandle_t hStream );
	virtual int				CopyStreamedDataIntoMemory( StreamHandle_t hStream, void *pBuffer, int bufferSize, int copyStartPos, int bytesToCopy );
	virtual bool			IsStreamedDataReady( StreamHandle_t hStream );
	virtual void			MarkBufferDiscarded( BufferHandle_t hBuffer );
	virtual void			*GetStreamedDataPointer( StreamHandle_t hStream, bool bSync );

	virtual	void			Flush( bool bTearDownStaticPool = false );

	virtual void			UpdateLoopPosition( StreamHandle_t hStream, int nLoopPosition );

	enum MemoryUsageType
	{
		SPEW_BASIC = 0,
		SPEW_MUSIC_NONSTREAMING,
		SPEW_NONSTREAMING,
		SPEW_ALL,
	};
	void					SpewMemoryUsage( MemoryUsageType level );

	// Cache helpers
	bool					GetItemName( DataCacheClientID_t clientId, const void *pItem, char *pDest, unsigned nMaxLen  );

private:
	void					Clear();

	struct CacheEntry_t
	{
		CacheEntry_t() :
			name( 0 ),
			handle( 0 )
		{
		}
		FileNameHandle_t	name;
		WaveCacheHandle_t	handle;
	};

	// tags the signature of a buffer inside a rb tree for faster than linear find
	struct BufferEntry_t
	{
		FileNameHandle_t	m_hName;
		WaveCacheHandle_t	m_hWaveData;
		int					m_StartPos;
		unsigned int		m_bIsTransient : 1;
		unsigned int		m_bCanBeShared : 1;
	};

	static bool BufferHandleLessFunc( const BufferEntry_t& lhs, const BufferEntry_t& rhs )
	{
		if ( lhs.m_bIsTransient != rhs.m_bIsTransient )
		{
			return lhs.m_bIsTransient < rhs.m_bIsTransient;
		}

		if ( lhs.m_hName != rhs.m_hName )
		{
			return lhs.m_hName < rhs.m_hName;
		}

		if ( lhs.m_StartPos != rhs.m_StartPos )
		{
			return lhs.m_StartPos < rhs.m_StartPos;
		}

		return lhs.m_bCanBeShared < rhs.m_bCanBeShared;
	}

	CUtlRBTree< BufferEntry_t, BufferHandle_t >	m_BufferList;

	// encapsulates (n) buffers for a streamed wave object
	struct StreamedEntry_t
	{
		FileNameHandle_t	m_hName;
		WaveCacheHandle_t	m_hWaveData[STREAM_BUFFER_COUNT];
		int					m_Front;			// buffer index, forever incrementing
		int					m_NextStartPos;		// predicted offset if mixing linearly
		int					m_DataSize;			// length of the data set in bytes
		int					m_DataStart;		// file offset where data set starts
		int					m_LoopStart;		// offset in data set where loop starts
		int					m_BufferSize;		// size of the buffer in bytes
		int					m_numBuffers;		// number of buffers (1 or 2) to march through
		int					m_SectorSize;		// size of sector on stream device
		bool				m_bSinglePlay;		// hint to keep same buffers
		bool				m_bIsTransient;		// hint for buffer lifetime
	};
	CUtlLinkedList< StreamedEntry_t, StreamHandle_t >	m_StreamedHandles;

	static bool CacheHandleLessFunc( const CacheEntry_t& lhs, const CacheEntry_t& rhs )
	{
		return lhs.name < rhs.name;
	}
	CUtlRBTree< CacheEntry_t, int >	m_CacheHandles;

	// these are buffers that were still in-flight at time of stream closure
	// we track these until we can remove an outstanding lock
	// some of these buffers are allowed to be reclaimed
	struct DeadBufferEntry_t
	{
		WaveCacheHandle_t	hWaveData;
		bool				bSinglePlay;
	};
	CUtlVector< DeadBufferEntry_t >	m_DeadBuffers;

	WaveCacheHandle_t		FindOrCreateBuffer( asyncwaveparams_t &params, bool bFind );		
	void					CleanupDeadBuffers( bool bSync );
	bool					m_bInitialized;

	struct  StreamData_t
	{
		int				actualCopied;
		CAsyncWaveData	*pWaveData[STREAM_BUFFER_COUNT];
		int				index;
		bool			bWaiting;
		int				copyStartPos;
	};

	bool InitializeStreamData( const StreamedEntry_t &streamedEntry, StreamData_t & streamData, int copyStartPos );
	void CopyFromCurrentBuffers( StreamedEntry_t &streamedEntry, StreamData_t & streamData, StreamHandle_t hStream, void *pBuffer, int bufferSize, int bytesToCopy );
	void PrefetchNextBuffers( StreamedEntry_t &streamedEntry, StreamData_t & streamData );
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CAsyncWavDataCache::CAsyncWavDataCache() :  
	m_CacheHandles( 0, 0, CacheHandleLessFunc ),
	m_BufferList( 0, 0, BufferHandleLessFunc ),
	m_bInitialized( false )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::Init( unsigned int memSize )
{
	if ( m_bInitialized )
		return true;
	
	if ( IsGameConsole() )
	{	
		// xbox non-streaming audio is uncapped, all these sounds allocate as required
		// streaming audio is constrained, explicitly managed, and pooled
		unsigned int nStaticPoolSize = CONSOLE_STATIC_AUDIO_DEFAULT;

		const char *pGame = engineClient->GetGameDirectory();
		if ( !Q_stricmp( Q_UnqualifiedFileName( pGame ), "tf" ) )
		{
			memSize = CONSOLE_STREAMING_AUDIO_TF;
		}
		else if ( StringHasPrefix( Q_UnqualifiedFileName( pGame ), "left4dead2") )
		{
			if ( g_pFullFileSystem->IsDVDHosted() )
			{
				memSize = CONSOLE_STREAMING_AUDIO_LEFT4DEAD_DVD;
			}
			else
			{
				memSize = CONSOLE_STREAMING_AUDIO_LEFT4DEAD;
			}
		}
		else if ( StringHasPrefix( Q_UnqualifiedFileName( pGame ), "portal2") )
		{
			nStaticPoolSize = CONSOLE_STATIC_AUDIO_PORTAL2;
			memSize = CONSOLE_STREAMING_AUDIO_PORTAL2;
			if ( IsX360() && XBX_IsRestrictiveLanguage() )
			{
				COMPILE_TIME_ASSERT( !IsX360() || ( CONSOLE_STREAMING_AUDIO_PORTAL2 == 20*1024*1024 ) ); // Might want to revisit this tradeoff if this changes
				memSize -= ASIAN_FONT_MEMORY_USAGE;
			}
		}
		else if ( StringHasPrefix( Q_UnqualifiedFileName( pGame ), "csgo" ) )
		{
			nStaticPoolSize = CONSOLE_STATIC_AUDIO_CSTRIKE15;
			memSize = CONSOLE_STREAMING_AUDIO_CSTRIKE15;
		}	
		else
		{
			memSize = CONSOLE_STREAMING_AUDIO_DEFAULT;
		}
		
		// needs to be integral
		Assert( memSize % STREAM_BUFFER_DATASIZE == 0 );
		g_pAudioStreamPool = new CUtlMemoryPool( STREAM_BUFFER_DATASIZE, memSize/STREAM_BUFFER_DATASIZE, CUtlMemoryPool::GROW_NONE, "CAsyncWavDataCache::AudioStreamPool" );
		// force the actual pool allocation to occur on first alloc
		g_pAudioStreamPool->Clear();
	
		// create a pool to hold the non-streaming static data
		g_pAudioStaticPool = new CMemoryStack;
		g_pAudioStaticPool->Init( "g_pAudioStaticPool", nStaticPoolSize, 0, nStaticPoolSize );

		// NOTE!!!!
		// console audio section is unlimited, purges are *explicitly* invoked via FindOrCreateBuffer()
		// the create will cause the resource to be created which checks the pools, fails, and then the explicit purge occurs
		memSize = (unsigned int)-1;
	}
	else
	{
		if ( memSize < DEFAULT_WAV_MEMORY_CACHE )
		{
			memSize = DEFAULT_WAV_MEMORY_CACHE;
		}
	}

	s_WaveCache.Init( memSize );

	m_bInitialized = true;
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Shutdown()
{
	if ( !m_bInitialized )
	{
		return;
	}

	Clear();

	s_WaveCache.Shutdown();

	delete g_pAudioStreamPool;

	m_bInitialized = false;
}

//-----------------------------------------------------------------------------
// Purpose: Creates initial cache object if it doesn't already exist, starts async loading the actual data
//  in any case.
// Input  : *filename - 
//			datasize - 
//			startpos - 
// Output : WaveCacheHandle_t
//-----------------------------------------------------------------------------
WaveCacheHandle_t CAsyncWavDataCache::AsyncLoadCache( char const *filename, int datasize, int startpos, bool bIsPrefetch )
{
	VPROF( "CAsyncWavDataCache::AsyncLoadCache" );

	FileNameHandle_t fnh = g_pFileSystem->FindOrAddFileName( filename );

	CacheEntry_t search;
	search.name = fnh;
	search.handle = 0;

	// find or create the handle
	int idx = m_CacheHandles.Find( search );
	if ( idx == m_CacheHandles.InvalidIndex() )
	{
		idx = m_CacheHandles.Insert( search );
		Assert( idx != m_CacheHandles.InvalidIndex() );
	}

	CacheEntry_t &entry = m_CacheHandles[idx];

	// Try and pull it into cache
	CAsyncWaveData *data = s_WaveCache.CacheGet( entry.handle );
	if ( !data )
	{
		// Try and reload it
		asyncwaveparams_t	params;
		params.hFilename = fnh;
		params.datasize = datasize;
		params.seekpos = startpos;
		params.bPrefetch = bIsPrefetch;
		entry.handle = s_WaveCache.CacheCreate( params );
	}

	return entry.handle;
}


//-----------------------------------------------------------------------------
// Purpose: Reclaim a buffer. A reclaimed resident buffer is ready for play.
//-----------------------------------------------------------------------------
WaveCacheHandle_t CAsyncWavDataCache::FindOrCreateBuffer( asyncwaveparams_t &params, bool bFind )
{
	CAsyncWaveData *pWaveData;
	BufferEntry_t	search;
	BufferHandle_t	hBuffer;

	search.m_hName = params.hFilename;
	search.m_StartPos = params.seekpos;
	search.m_bIsTransient = params.bIsTransient;
	search.m_bCanBeShared = bFind;
	search.m_hWaveData = INVALID_WAVECACHE_HANDLE;

	if ( bFind )
	{
		// look for an existing buffer that matches signature (same file, offset, etc)
		int hBuffer = m_BufferList.Find( search );
		if ( hBuffer != m_BufferList.InvalidIndex() )
		{
			// found
			search.m_hWaveData = m_BufferList[hBuffer].m_hWaveData;
			if ( snd_async_stream_spew.GetInt() >= 2 )
			{
				char tempBuff[MAX_PATH];
				g_pFileSystem->String( params.hFilename, tempBuff, sizeof( tempBuff ) );
				Msg( "Found Buffer: %s, offset: %d\n", tempBuff, params.seekpos );
			}
		}
	}
	
	// each resource buffer stays locked (valid) while in use
	// a buffering stream is not subject to lru and can rely on it's buffers
	// a buffering stream may obsolete it's buffers by reducing the lock count, allowing for lru
	pWaveData = s_WaveCache.CacheLock( search.m_hWaveData );
	if ( !pWaveData )
	{
		// not in cache, create and lock
		// not found, create buffer and fill with data
		int numFails = 0;
		while ( 1 ) 
		{
			search.m_hWaveData = s_WaveCache.CacheCreate( params, WCAF_LOCK );
			if ( search.m_hWaveData != INVALID_WAVECACHE_HANDLE )
			{
				break;
			}

			if ( !params.bIsTransient )
			{
				// yikes!, creation can fail if out of system memory or the stream memory pool was full
				// only transient streams would fail if the stream pool was full
				Assert( 0 );
				return INVALID_WAVECACHE_HANDLE;
			}

			numFails++;
			if ( numFails >= 2 )
			{
				// second attempt
				// yikes!, stream pool isn't getting purged, all must be locked
				Assert( 0 );
				if ( snd_async_stream_fail.GetBool() )
				{
					Warning( "Stream pool: No buffers available! (dead:%d)\n", m_DeadBuffers.Count() );
				}
				return INVALID_WAVECACHE_HANDLE;
			}
			
			if ( numFails == 1 )
			{
				// first time failure
				// try and reclaim dead buffers before the purge
				CleanupDeadBuffers( false );
			}

			// lru purge the stream pool and retry
			s_WaveCache.Purge( STREAM_BUFFER_DATASIZE );
		}

		// add the buffer to our managed list
		hBuffer = m_BufferList.Insert( search );
		Assert( hBuffer != m_BufferList.InvalidIndex() );

		// store the handle into our managed list
		// used during a lru discard as a means to keep the list in-sync
		pWaveData = s_WaveCache.CacheGet( search.m_hWaveData );
		pWaveData->m_hBuffer = hBuffer;
	}
	else
	{
		// still in cache
		// same as requesting it and having it arrive instantly
		pWaveData->m_start = pWaveData->m_arrival = (float)Plat_FloatTime();
	}

	return search.m_hWaveData;
}

//-----------------------------------------------------------------------------
// Purpose: Load data asynchronously via multi-buffers, returns specialized handle
//-----------------------------------------------------------------------------
StreamHandle_t CAsyncWavDataCache::OpenStreamedLoad( char const *pFileName, int dataSize, int dataStart, int startPos, int loopPos, int bufferSize, int numBuffers, streamFlags_t flags, SoundError &soundError )
{
	VPROF( "CAsyncWavDataCache::OpenStreamedLoad" );

	StreamedEntry_t			streamedEntry;
	StreamHandle_t			hStream;
	asyncwaveparams_t		params;

	Assert( numBuffers > 0 && numBuffers <= STREAM_BUFFER_COUNT );

	if ( flags & STREAMED_QUEUEDLOAD )
	{
		if ( numBuffers != 1 )
		{
			// queued load mandates one buffer, caller has violated code expectations
			Assert( 0 );
			numBuffers = 1;
		}

		if ( flags & STREAMED_TRANSIENT )
		{
			// not allowed, queued loads are for static resident sounds
			Assert( 0 );
			flags &= ~STREAMED_TRANSIENT;
		}
	}

	if ( ( flags & STREAMED_TRANSIENT ) && ( bufferSize != STREAM_BUFFER_DATASIZE ) )
	{
		// stream pool mandates the pool block size, caller has violated code expectations
		Assert( 0 );
		bufferSize = STREAM_BUFFER_DATASIZE;
	}

	if ( !( flags & STREAMED_TRANSIENT ) && ( flags & STREAMED_SINGLEPLAY ) )
	{
		// singleplay is a streaming concept requiring transient buffers
		// nonsense concept if used by memory resident wavs
		// caller has violated code expectations
		Assert( 0 );
		flags &= ~STREAMED_SINGLEPLAY;
	}

	streamedEntry.m_hName = g_pFileSystem->FindOrAddFileName( pFileName );
	streamedEntry.m_Front = 0;
	streamedEntry.m_DataSize = dataSize;
	streamedEntry.m_DataStart = dataStart;
	streamedEntry.m_NextStartPos = startPos + numBuffers * bufferSize;
	streamedEntry.m_LoopStart = loopPos;
	streamedEntry.m_BufferSize = bufferSize;
	streamedEntry.m_numBuffers = numBuffers;
	streamedEntry.m_bSinglePlay = ( flags & STREAMED_SINGLEPLAY ) != 0;
	streamedEntry.m_SectorSize = ( IsGameConsole() && ( flags & STREAMED_FROMDVD ) ) ? XBOX_DVD_SECTORSIZE : 1;
	streamedEntry.m_bIsTransient = IsGameConsole() && ( flags & STREAMED_TRANSIENT ) != 0;

	bool bFindBuffer;
	if ( !( flags & STREAMED_TRANSIENT ) && !( flags & STREAMED_QUEUEDLOAD ) )
	{
		// static sounds created outside the queued loader end up in the standard heap
		// these would be UI sounds or other engine startup sounds
		// for simplicity and stability, they don't alias
		bFindBuffer = false;
	}
	else
	{
		// single play streams expect to uniquely own and thus recycle their buffers though the data
		// single play streams are guaranteed that their buffers are private and cannot be shared
		// a non-single play stream wants persisting buffers and attempts to reclaim a matching buffer
		bFindBuffer = ( streamedEntry.m_bSinglePlay == false );
	}

	// initial load populates buffers
	// mixing starts after front buffer viable
	// buffer rotation occurs after front buffer consumed
	// there should be no blocking
	params.hFilename = streamedEntry.m_hName;
	params.datasize = bufferSize;
	params.alignment = streamedEntry.m_SectorSize;
	params.bCanBeQueued = ( flags & STREAMED_QUEUEDLOAD ) != 0;
	params.bIsTransient = streamedEntry.m_bIsTransient;
	params.bIsStaticPooled = ( flags & STREAMED_QUEUEDLOAD ) != 0;

	bool bFailed = false;
	for ( int i = 0; i < numBuffers; ++i )
	{
		int nOffset = streamedEntry.m_SectorSize * ( ( startPos + i * bufferSize ) / streamedEntry.m_SectorSize );		// So it matches the alignment of the streamer after
		params.seekpos = dataStart + nOffset;
		WaveCacheHandle_t hWaveData = INVALID_WAVECACHE_HANDLE;
		if ( !bFailed )
		{
			hWaveData = FindOrCreateBuffer( params, bFindBuffer );
			bFailed = ( hWaveData == INVALID_WAVECACHE_HANDLE );
		}
		streamedEntry.m_hWaveData[i] = hWaveData;
	}

	// get a unique handle for each stream request
	hStream = m_StreamedHandles.AddToTail( streamedEntry );
	Assert( hStream != m_StreamedHandles.InvalidIndex() );

	if ( bFailed )
	{
		// partial failure, didn't get all the buffers required
		// have to do cleanup, cannot leave dangling buffers
		CloseStreamedLoad( hStream );

		// sorry, this sound will not play, system is unable to provide streaming buffers
		// streaming buffers are should have been available
		hStream = INVALID_STREAM_HANDLE;
		soundError = SE_NO_STREAM_BUFFER;
	}
	else
	{
		soundError = SE_OK;
	}

	return hStream;
}


//-----------------------------------------------------------------------------
// Purpose: Cleanup a streamed load's resources.
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::CloseStreamedLoad( StreamHandle_t hStream )
{
	VPROF( "CAsyncWavDataCache::CloseStreamedLoad" );

	if ( hStream == INVALID_STREAM_HANDLE )
	{
		return;
	}

	int	lockCount;
	StreamedEntry_t	&streamedEntry = m_StreamedHandles[hStream];
	for ( int i=0; i<streamedEntry.m_numBuffers; ++i )
	{
		WaveCacheHandle_t hWaveData = streamedEntry.m_hWaveData[i];
		if ( hWaveData == INVALID_WAVECACHE_HANDLE )
		{
			// cleaning up unexpected bad entry
			// skip over logic that would otherwise assert
			continue;
		}

		// multiple streams could be using the same buffer, keeping the lock count nonzero
		lockCount = s_WaveCache.GetLockCount( hWaveData );
		Assert( lockCount >= 1 );
		if ( lockCount > 1 )
		{
			// just remove our lock, it will eventuall free when the last consumer releases
			s_WaveCache.CacheUnlock( hWaveData );
			continue;
		}
	
		CAsyncWaveData *pBuffer = s_WaveCache.CacheGetNoTouch( hWaveData );
		if ( pBuffer )
		{
			// going to a zero lock count with an async operation in flight would cause memory corruption	
			if ( !pBuffer->m_bMissing && !pBuffer->m_bLoaded )
			{
				// still in flight, add to list of dead buffers
				// have to now track these to remove our lock when they async-finish
				int iEntryIndex = m_DeadBuffers.AddToTail();
				m_DeadBuffers[iEntryIndex].hWaveData = hWaveData;
				m_DeadBuffers[iEntryIndex].bSinglePlay =  streamedEntry.m_bSinglePlay;
				continue;
			}
		}

		lockCount = s_WaveCache.CacheUnlock( hWaveData );
		if ( streamedEntry.m_bSinglePlay )
		{
			// a buffering single play stream has no reason to reuse its own buffers and destroys them
			// these buffers are uniquely owned, so the lock count can/should only be 0 at this point
			// if !=0 the remove will respect the lock and do nothing and the buffer becomes a zombie
			Assert( lockCount == 0 );
			s_WaveCache.CacheRemove( hWaveData );
		}
	}

	m_StreamedHandles.Remove( hStream );
}

//-----------------------------------------------------------------------------
// Cleanup any streaming buffers that could not be released during the close
// because they had async data in-flight. These buffers may have become owned
// by another stream. We do this polling to avoid having to sync stop the
// buffers which would cause the game to hitch.
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::CleanupDeadBuffers( bool bSync )
{
	if ( !IsGameConsole() )
	{
		return;
	}

	for ( int iEntryIndex = 0; iEntryIndex < m_DeadBuffers.Count(); )
	{
		WaveCacheHandle_t hWaveData = m_DeadBuffers[iEntryIndex].hWaveData;
		bool bSinglePlay = m_DeadBuffers[iEntryIndex].bSinglePlay;

		int lockCount = s_WaveCache.GetLockCount( hWaveData );
		Assert( lockCount >= 1 );
		if ( lockCount > 1 )
		{
			// this buffer got re-claimed by some stream
			// just remove the oustanding lock that should have occurred during the initial close but was prevented
			// this buffer will eventually free when the last consumer releases
			s_WaveCache.CacheUnlock( hWaveData );

			// no longer tracking
			m_DeadBuffers.Remove( iEntryIndex );
			continue;
		}

		// going to a zero lock count with an async operation in flight would cause memory corruption	
		// check the buffer to ensure it has completed
		CAsyncWaveData *pBuffer = s_WaveCache.CacheGetNoTouch( hWaveData );
		if ( pBuffer )
		{
			if ( !pBuffer->m_bMissing && !pBuffer->m_bLoaded )
			{
				if ( !bSync )
				{
					// still in flight, it will eventually finish 
					// keep tracking
					iEntryIndex++;
					continue;
				}
				else
				{
					// cause a sync operation to force the async operation to finish 
					void *pData = NULL;
					pBuffer->BlockingGetDataPointer( &pData );
				}
			}
		}

		// remove the outstanding lock
		lockCount = s_WaveCache.CacheUnlock( hWaveData );

		if ( bSinglePlay )
		{
			// a buffering single play stream has no reason to reuse its own buffers and destroys them
			// these buffers are uniquely owned, so the lock count can/should only be 0 at this point
			// if !=0 the remove will respect the lock and do nothing and the buffer becomes a zombie
			Assert( lockCount == 0 );
			s_WaveCache.CacheRemove( hWaveData );
		}

		//  no longer tracking
		m_DeadBuffers.Remove( iEntryIndex );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *filename - 
//			datasize - 
//			startpos - 
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::PrefetchCache( char const *filename, int datasize, int startpos )
{
	// Just do an async load, but don't get cache handle
	AsyncLoadCache( filename, datasize, startpos, true );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *filename - 
//			datasize - 
//			startpos - 
//			*buffer - 
//			bufsize - 
//			copystartpos - 
//			bytestocopy - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::CopyDataIntoMemory( char const *filename, int datasize, int startpos, void *buffer, int bufsize, int copystartpos, int bytestocopy, bool *pbPostProcessed )
{
	VPROF( "CAsyncWavDataCache::CopyDataIntoMemory" );

	bool bret = false;

	// Add to caching system
	AsyncLoadCache( filename, datasize, startpos );

	FileNameHandle_t fnh = g_pFileSystem->FindOrAddFileName( filename );

	CacheEntry_t search;
	search.name = fnh;
	search.handle = 0;

	// Now look it up, it should be in the system
	int idx = m_CacheHandles.Find( search );
	if ( idx == m_CacheHandles.InvalidIndex() )
	{
		Assert( 0 );
		return bret;
	}

	// Now see if the handle has been paged out...
	return CopyDataIntoMemory( m_CacheHandles[ idx ].handle, filename, datasize, startpos, buffer, bufsize, copystartpos, bytestocopy, pbPostProcessed );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handle - 
//			*filename - 
//			datasize - 
//			startpos - 
//			*buffer - 
//			bufsize - 
//			copystartpos - 
//			bytestocopy - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::CopyDataIntoMemory( WaveCacheHandle_t& handle, char const *filename, int datasize, int startpos, void *buffer, int bufsize, int copystartpos, int bytestocopy, bool *pbPostProcessed )
{
	VPROF( "CAsyncWavDataCache::CopyDataIntoMemory" );

	*pbPostProcessed = false;

	bool bret = false;

	CAsyncWaveData *data = s_WaveCache.CacheLock( handle );
	if ( !data )
	{
		FileNameHandle_t fnh = g_pFileSystem->FindOrAddFileName( filename );

		CacheEntry_t search;
		search.name = fnh;
		search.handle = 0;

		// Now look it up, it should be in the system
		int idx = m_CacheHandles.Find( search );
		if ( idx == m_CacheHandles.InvalidIndex() )
		{
			Assert( 0 );
			return false;
		}

		// Try and reload it
		asyncwaveparams_t params;
		params.hFilename = fnh;
		params.datasize = datasize;
		params.seekpos = startpos;

		handle = m_CacheHandles[ idx ].handle = s_WaveCache.CacheCreate( params );
		data = s_WaveCache.CacheLock( handle );
		if ( !data )
		{
			return bret;
		}
	}

	// Cache entry exists, but if filesize == 0 then the file itself wasn't on disk...
	if ( data->m_nDataSize != 0 )
	{
		bret = data->BlockingCopyData( buffer, bufsize, copystartpos, bytestocopy );
	}

	*pbPostProcessed = data->GetPostProcessed();

	// Release lock
	s_WaveCache.CacheUnlock( handle );
	return bret;
}

bool CAsyncWavDataCache::InitializeStreamData( const StreamedEntry_t &streamedEntry, StreamData_t & streamData, int copyStartPos )
{
	for ( int i=0; i<streamedEntry.m_numBuffers; ++i )
	{
		streamData.pWaveData[i] = s_WaveCache.CacheGetNoTouch( streamedEntry.m_hWaveData[i] );
		Assert( streamData.pWaveData[i] );
		if ( streamData.pWaveData[i] == NULL )
		{
			// oops, where are our locked buffers?
			// The buffers can go away in midst of streaming if the streaming buffer pool is filled,
			// no buffers can be lru'd, and then can't provide the next stream buffer to fill.
			// There is no choice but to abort this streaming sound.
			return false;			
		}
	}
	streamData.index = streamedEntry.m_Front;
	streamData.actualCopied = 0;
	streamData.bWaiting = false;
	streamData.copyStartPos = copyStartPos;
	return true;
}

void CAsyncWavDataCache::CopyFromCurrentBuffers( StreamedEntry_t &streamedEntry, StreamData_t & streamData, StreamHandle_t hStream, void *pBuffer, int bufferSize, int bytesToCopy )
{
	int nRemainingBytesToCopy = bytesToCopy;
	while ( 1 )
	{
		// try to satisfy from the front
		CAsyncWaveData *pFront = streamData.pWaveData[streamData.index % streamedEntry.m_numBuffers];
		int bufferPos = streamData.copyStartPos - pFront->m_async.nOffset;

		// cache atomic async completion signal off to avoid coherency issues
		bool bCompleted = pFront->m_bLoaded || pFront->m_bMissing;

		if ( snd_async_stream_spew.GetInt() >= 1 )
		{
			// interval is the audio block clock rate, the block must be available within this interval
			// a faster audio rate or smaller block size implies a smaller interval
			// latency is the actual block delivery time
			// latency must not exceed the delivery interval or starving occurs and audio pops
			float nowTime = Plat_FloatTime();
			int interval = (int)(1000.0f*(nowTime-pFront->m_start));
			int latency;
			if ( bCompleted && pFront->m_bLoaded )
			{
				latency = (int)(1000.0f*(pFront->m_arrival-pFront->m_start));
			}
			else
			{
				// buffer has not arrived yet
				latency = -1;
			}
			Msg( "Stream:%2d interval:%5dms latency:%5dms offset:%d length:%d (%s)\n", hStream, interval, latency, pFront->m_async.nOffset, pFront->m_nReadSize, pFront->GetFileName() );
		}

		if ( bCompleted && pFront->m_hAsyncControl && ( pFront->m_bLoaded || pFront->m_bMissing) )
		{
			g_pFileSystem->AsyncRelease( pFront->m_hAsyncControl );
			pFront->m_hAsyncControl = NULL;
		}

		if ( bCompleted && pFront->m_bLoaded )
		{
			if ( bufferPos >= 0 && bufferPos < pFront->m_nReadSize )
			{
				int count = nRemainingBytesToCopy;
				if ( bufferPos + count > pFront->m_nReadSize )
				{
					// clamp requested to actual available
					count = pFront->m_nReadSize - bufferPos;
				}
				if ( bufferPos + count > bufferSize )
				{
					// clamp requested to caller's buffer dimension
					count = bufferSize - bufferPos;
				}

				if ( count > 0 )
				{
					// We have to test for count as in some cases it could be negative (as BufferSize gets reduced if it spans over more than one loop).
					// This is actually very rare though.

					Q_memcpy( pBuffer, (char *)pFront->m_pvData + bufferPos, count );

					// advance past consumed bytes
					streamData.actualCopied += count;
					streamData.copyStartPos += count;
					nRemainingBytesToCopy -= count;
					bufferPos += count;							// Once we copied it, update bufferPos so we can look at the next buffer if needed.
					pBuffer = (void *)((intp)pBuffer + count);	// Skip written bytes
					bufferSize -= count;
				}
				else
				{
					// Nothing else can be done. We'll see with next request.
					Warning( "%s(%d): Protecting against negative memcpy. BufferSize = %d. Buffer Pos = %d. Count = %d.\n", __FILE__, __LINE__, bufferSize, bufferPos, count );
					return;
				}
			}
		}
		else if ( bCompleted && pFront->m_bMissing )
		{
			// notify on any error
			MaybeReportMissingWav( pFront->GetFileName() );
			break;
		}
		else
		{
			// data not available
			streamData.bWaiting = true;
			break;
		}

		// cycle past obsolete or consumed buffers
		if ( bufferPos < 0 || bufferPos >= pFront->m_nReadSize )
		{
			// move to next buffer
			streamData.index++;
			if ( streamData.index - streamedEntry.m_Front >= streamedEntry.m_numBuffers )
			{
				// out of buffers
				break;
			}
		}

		if ( streamData.actualCopied == bytesToCopy )
		{
			// satisfied request
			return;
		}
	}

	// If the request is not satisfied, let's make sure that at least the buffers are in the range asked.
	// If that's not the case, then we need to make sure that the next pos retrieved is in the range.
	bool bInRange = false;
	for ( int i = 0 ; i < streamedEntry.m_numBuffers ; ++i )
	{
		CAsyncWaveData *pWaveData = streamData.pWaveData[i];
		if ( pWaveData->m_bMissing )
		{
			continue;
		}
		int bufferPos = streamData.copyStartPos - pWaveData->m_async.nOffset;
		if ( ( bufferPos >= 0 ) && ( bufferPos < pWaveData->m_nDataSize ) )
		{
			bInRange = true;
		}
	}
	if ( bInRange == false )
	{
		// None on the buffers are in range, make sure next buffer is the one we are currently requesting.
		streamedEntry.m_NextStartPos = streamData.copyStartPos - streamedEntry.m_DataStart;
	}
}

void CAsyncWavDataCache::PrefetchNextBuffers( StreamedEntry_t &streamedEntry, StreamData_t & streamData )
{
	if ( streamedEntry.m_numBuffers > 1 )
	{
		int nextStartPos;

		// restart consumed buffers
		while ( streamedEntry.m_Front < streamData.index )
		{
			if ( !streamData.actualCopied && !streamData.bWaiting )
			{
				// couldn't return any data because the buffers aren't in the right location
				nextStartPos = streamData.copyStartPos - streamedEntry.m_DataStart;
			}
			else
			{
				// get the next forecast read location
				nextStartPos = streamedEntry.m_NextStartPos;
			}

			if ( nextStartPos >= streamedEntry.m_DataSize )
			{
				// next buffer is at or past end of file 
				if ( streamedEntry.m_LoopStart >= 0 )
				{
					// wrap back around to loop position
					nextStartPos = streamedEntry.m_LoopStart;
				}
				else
				{
					// advance past consumed buffer
					streamedEntry.m_Front++;
					// start no further buffers
					break;
				}
			}

			// still valid data left to read
			// snap the buffer position to required alignment
			nextStartPos = streamedEntry.m_SectorSize * (nextStartPos/streamedEntry.m_SectorSize);

			// start loading back buffer at future location
			asyncwaveparams_t	params;
			params.hFilename = streamedEntry.m_hName;
			params.seekpos = streamedEntry.m_DataStart + nextStartPos;
			params.datasize = streamedEntry.m_DataSize - nextStartPos;
			params.alignment = streamedEntry.m_SectorSize;
			params.bIsTransient = streamedEntry.m_bIsTransient;
			if ( params.datasize > streamedEntry.m_BufferSize )
			{
				// clamp to buffer size
				params.datasize = streamedEntry.m_BufferSize;
			}

			// save next start position
			streamedEntry.m_NextStartPos = nextStartPos + params.datasize;

			int which = streamedEntry.m_Front % streamedEntry.m_numBuffers;
			if ( streamedEntry.m_bSinglePlay )
			{
				// a single play wave has no reason to persist its buffers into the lru
				// reuse buffer and restart until finished
				streamData.pWaveData[which]->StartAsyncLoading( params );
			}
			else
			{
				// release obsolete buffer to lru management
				s_WaveCache.CacheUnlock( streamedEntry.m_hWaveData[which] );

				// reclaim or create/load the desired buffer
				WaveCacheHandle_t hWaveData = FindOrCreateBuffer( params, true );
				streamedEntry.m_hWaveData[which] = hWaveData;
				if ( hWaveData == INVALID_WAVECACHE_HANDLE )
				{
					// very bad, failed to get an expected buffer
					// return whatever we have
					// retry logic will eventually get a 0 and cease sound
					return;
				}
			}
			streamData.bWaiting = true;
			streamedEntry.m_Front++;

			// Then if there is more stream buffer available, let's continue at the next position
			nextStartPos = streamData.copyStartPos - streamedEntry.m_DataStart + streamedEntry.m_BufferSize;
			streamData.copyStartPos += streamedEntry.m_BufferSize;
		}

		if ( streamData.bWaiting )
		{
			// oh no! data needed is not yet available in front buffer
			// caller requesting data faster than can be provided or caller skipped
			// can only return what has been copied thus far (could be 0)
			return;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Copy from streaming buffers into target memory, never blocks.
//-----------------------------------------------------------------------------
int CAsyncWavDataCache::CopyStreamedDataIntoMemory( StreamHandle_t hStream, void *pBuffer, int bufferSize, int copyStartPos, int bytesToCopy )
{
	VPROF( "CAsyncWavDataCache::CopyStreamedDataIntoMemory" );

	StreamedEntry_t		&streamedEntry = m_StreamedHandles[hStream];
	if ( copyStartPos >= streamedEntry.m_DataStart + streamedEntry.m_DataSize )
	{
		// at or past end of file
		return 0;
	}

	StreamData_t streamData;
	if ( InitializeStreamData( streamedEntry, streamData, copyStartPos ) == false )
	{
		return 0;
	}

	CopyFromCurrentBuffers( streamedEntry, streamData, hStream, pBuffer, bufferSize, bytesToCopy );
	PrefetchNextBuffers( streamedEntry, streamData );
	return streamData.actualCopied;
}

//-----------------------------------------------------------------------------
// Purpose: Get the front buffer, optionally block.
// Intended for user of a single buffer stream.
//-----------------------------------------------------------------------------
void *CAsyncWavDataCache::GetStreamedDataPointer( StreamHandle_t hStream, bool bSync )
{
	void			*pData = NULL;
	CAsyncWaveData	*pFront;
	int				index;
	StreamedEntry_t &streamedEntry = m_StreamedHandles[hStream];

	index  = streamedEntry.m_Front % streamedEntry.m_numBuffers;
	pFront = s_WaveCache.CacheGetNoTouch( streamedEntry.m_hWaveData[index] );
	Assert( pFront );
	if ( !pFront )
	{
		// shouldn't happen
		return NULL;
	}

	if ( !pFront->m_bMissing && pFront->m_bLoaded )
	{
		return pFront->m_pvData;
	}

	if ( bSync && pFront->BlockingGetDataPointer( &pData ) )
	{
		return pData;
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: The front buffer must be valid
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::IsStreamedDataReady( int hStream )
{
	VPROF( "CAsyncWavDataCache::IsStreamedDataReady" );

	if ( hStream == INVALID_STREAM_HANDLE )
	{
		return false;
	}

	StreamedEntry_t &streamedEntry = m_StreamedHandles[hStream];

	if ( streamedEntry.m_Front )
	{
		// already streaming, the buffers better be arriving as expected
		return true;
	}

	// only the first front buffer must be present
	CAsyncWaveData *pFront = s_WaveCache.CacheGetNoTouch( streamedEntry.m_hWaveData[0] );
	Assert( pFront );
	if ( !pFront )
	{
		// shouldn't happen
		// let the caller think data is ready, so stream can shutdown
		return true;
	}

	// regardless of any errors
	// errors handled during data fetch
	return pFront->m_bLoaded || pFront->m_bMissing;
}


//-----------------------------------------------------------------------------
// Purpose: Dequeue the buffer entry (backdoor for list management)
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::MarkBufferDiscarded( BufferHandle_t hBuffer )
{
	m_BufferList.RemoveAt( hBuffer );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handle - 
//			proc - 
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::SetPostProcessed( WaveCacheHandle_t handle, bool proc )
{
	CAsyncWaveData *data = s_WaveCache.CacheGet( handle );
	if ( data )
	{
		data->SetPostProcessed( proc );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handle - 
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Unload( WaveCacheHandle_t handle )
{
	// Don't actually unload, just mark it as stale
	s_WaveCache.Age( handle );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handle - 
//			*filename - 
//			datasize - 
//			startpos - 
//			**pData - 
//			copystartpos - 
//			*pbPostProcessed - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::GetDataPointer( WaveCacheHandle_t& handle, char const *filename, int datasize, int startpos, void **pData, int copystartpos, bool *pbPostProcessed )
{
	VPROF( "CAsyncWavDataCache::GetDataPointer" );

	Assert( pbPostProcessed );
	Assert( pData );

	*pbPostProcessed = false;

	bool bret = false;
	*pData = NULL;

	CAsyncWaveData *data = s_WaveCache.CacheLock( handle );
	if ( !data )
	{
		FileNameHandle_t fnh = g_pFileSystem->FindOrAddFileName( filename );

		CacheEntry_t search;
		search.name = fnh;
		search.handle = 0;

		int idx = m_CacheHandles.Find( search );
		if ( idx == m_CacheHandles.InvalidIndex() )
		{
			Assert( 0 );
			return bret;
		}

		// Try and reload it
		asyncwaveparams_t params;
		params.hFilename = fnh;
		params.datasize = datasize;
		params.seekpos = startpos;

		handle = m_CacheHandles[ idx ].handle = s_WaveCache.CacheCreate( params );
		data = s_WaveCache.CacheLock( handle );
		if ( !data )
		{
			return bret;
		}
	}

	// Cache entry exists, but if filesize == 0 then the file itself wasn't on disk...
	if ( data->m_nDataSize != 0 && copystartpos < data->m_nDataSize )
	{
		if ( data->BlockingGetDataPointer( pData ) )
		{
			*pData = (char *)*pData + copystartpos;
			bret = true;
		}
	}

	*pbPostProcessed = data->GetPostProcessed();

	// Release lock
	s_WaveCache.CacheUnlock( handle );
	return bret;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handle - 
//			*filename - 
//			datasize - 
//			startpos - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::IsDataLoadCompleted( WaveCacheHandle_t handle, bool *pIsValid, bool *pIsMissing )
{
	VPROF( "CAsyncWavDataCache::IsDataLoadCompleted" );

	CAsyncWaveData *data = s_WaveCache.CacheGet( handle );
	if ( !data )
	{
		*pIsValid = false;
		return false;
	}
	*pIsValid = true;
	if ( pIsMissing )
	{
		*pIsMissing = data->m_bMissing;
	}
	// bump the priority
	data->SetAsyncPriority( 1 );

	return data->m_bLoaded;
}


void CAsyncWavDataCache::RestartDataLoad( WaveCacheHandle_t *pHandle, const char *pFilename, int dataSize, int startpos )
{
	CAsyncWaveData *data = s_WaveCache.CacheGet( *pHandle );
	if ( !data )
	{
		*pHandle = AsyncLoadCache( pFilename, dataSize, startpos );
	}
}

bool CAsyncWavDataCache::IsDataLoadInProgress( WaveCacheHandle_t handle )
{
	CAsyncWaveData *data = s_WaveCache.CacheGet( handle );
	if ( data )
	{
		return data->IsCurrentlyLoading();
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Flush( bool bTearDownStaticPool )
{
	if ( !m_bInitialized )
	{
		return;
	}

	if ( IsGameConsole() )
	{
		// this will sync stop (and unlock) any buffers that could not be unlocked at stream closure
		CleanupDeadBuffers( true );
	}

	// purge all unlocked resources
	s_WaveCache.Flush();

	MemoryUsageType spewType = SPEW_BASIC;
 
	if ( IsGameConsole() )
	{
		if ( bTearDownStaticPool )
		{
			// The caller has unlocked all static resources that should have been in this pool
			// and flush should have released them.
			// This is VERY scary, with this technique there is no way to ensure all resources from this pool
			// are really unlocked unless we scan the cache section annd make queries. And if they aren't,
			// nothing can be done because this is a stack, so either way it's just fatal.
			// Tear the pool down.
			g_pAudioStaticPool->FreeAll( false );
		}

		// a flush nominally occurs during level transitions to free up memory
		// the underlying pool's blob needs to get freed to use for level transition work
		// the next first allocation will re-establish the blob
		if ( !g_pAudioStreamPool->Count() )
		{
			g_pAudioStreamPool->Clear();
		}
		else
		{
			// this is used between levels, no sounds should be occuring, lock counts *should* be 0
			// the flush should have caused the stream buffers to destroy and thus the pool to be emptied
			// if sounds are not playing, buffers that are remaining are locked and would be zombied
			// zombied buffers would just accumulate until the stream pool couldn't play any more sounds
			// spewing more details into the log to scan after playtests to track (if any) down
			Warning( "CAsyncWavDataCache: Failed to clear stream pool during flush\n" );
			// need more detailed breakdown
			spewType = SPEW_ALL;
		}
	}

	SpewMemoryUsage( spewType );
}

//-----------------------------------------------------------------------------
// Purpose: Update loop position if a more accurate value has been found.
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::UpdateLoopPosition( StreamHandle_t hStream, int nLoopPosition )
{
	StreamedEntry_t &streamedEntry = m_StreamedHandles[hStream];
	streamedEntry.m_LoopStart = nLoopPosition;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::GetItemName( DataCacheClientID_t clientId, const void *pItem, char *pDest, unsigned nMaxLen  )
{
	CAsyncWaveData *pWaveData = (CAsyncWaveData *)pItem;
	Q_strncpy( pDest, pWaveData->GetFileName(), nMaxLen );
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Spew a cache summary to the console
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::SpewMemoryUsage( MemoryUsageType level )
{
	WaveCacheStatus_t status;
	WaveCacheLimits_t limits;
	s_WaveCache.GetStatus( &status, &limits );

	int bytesUsed = status.nBytes;
	int bytesTotal = limits.nMaxBytes;

	if ( IsPC() )
	{
		if ( level != SPEW_BASIC )
		{
			for ( int i = m_CacheHandles.FirstInorder(); m_CacheHandles.IsValidIndex(i); i = m_CacheHandles.NextInorder(i) )
			{
				char name[MAX_PATH];
				if ( !g_pFileSystem->String( m_CacheHandles[ i ].name, name, sizeof( name ) ) )
				{
					Assert( 0 );
					continue;
				}

				if ( level == SPEW_MUSIC_NONSTREAMING && V_stristr( name, "music" ) == NULL )
					continue;

				WaveCacheHandle_t &handle = m_CacheHandles[ i ].handle;
				CAsyncWaveData *data = s_WaveCache.CacheGetNoTouch( handle );
				if ( data )
				{
					Msg( "\t%16.16s : %s\n", Q_pretifymem(data->Size()),name);
				}
				else
				{
					Msg( "\t%16.16s : %s\n", "not resident",name);
				}
			}
		}

		float percent;
		if ( bytesTotal <= 0 )
		{
			// unbounded, indeterminate
			percent = 0;
			bytesTotal = 0;
		}
		else
		{
			percent = 100.0f * (float)bytesUsed / (float)bytesTotal;
		}
		Msg( "CAsyncWavDataCache:  %i .wavs total %s, %.2f %% of capacity\n", m_CacheHandles.Count(), Q_pretifymem( bytesUsed, 2 ), percent );
	}
	
	if ( IsGameConsole() )
	{
		if ( level == SPEW_BASIC )
		{
			// basic spew memory usage is the total of all the outstanding buffers
			// this isn't intended as an entirely accurate memory usage report
			Msg( "CAsyncWavDataCache: %.2f MB used\n", bytesUsed / ( 1024.0f * 1024.0f ) );
			Msg( "CAsyncWavDataCache: Static Pool: %.2f MB used of %.2f MB\n", g_pAudioStaticPool->GetUsed() / ( 1024.0f * 1024.0f ), g_pAudioStaticPool->GetSize() / ( 1024.0f * 1024.0f ) );
			Msg( "CAsyncWavDataCache: Stream Pool: %.2f MB used of %.2f MB\n", ( g_pAudioStreamPool->Count() * g_pAudioStreamPool->BlockSize() ) / ( 1024.0f * 1024.0f ), g_pAudioStreamPool->Size() / ( 1024.0f * 1024.0f ) );
			Msg( "CAsyncWavDataCache: Dead Buffers: %d\n", m_DeadBuffers.Count() );
		}
		else
		{
			// detailed spew breaks the stream buffers into resident (pooled or standard) or streaming types
			// iterate non-stream buffers
			int nonStreamBytesUsedPooled = 0;
			Msg( "\nCAsyncWavDataCache: Non-Stream Buffer List (Pooled Heap):\n" );
			for ( BufferHandle_t h = m_BufferList.FirstInorder(); h != m_BufferList.InvalidIndex(); h = m_BufferList.NextInorder( h ) )
			{
				BufferEntry_t *pBuffer = &m_BufferList[h];
				CAsyncWaveData *pData = s_WaveCache.CacheGetNoTouch( pBuffer->m_hWaveData );
				s_WaveCache.CacheLockMutex();
				if ( pData && !pData->m_bIsTransient && pData->m_bIsStaticPooled )
				{
					int lockCount = s_WaveCache.GetLockCount( pBuffer->m_hWaveData );
					unsigned int ageStamp = s_WaveCache.GetAgeStamp( pBuffer->m_hWaveData );
					Msg( "Start:%7d Size:%7d Lock:%3d Age:%4d %s\n", pBuffer->m_StartPos, pData->m_nBufferBytes, lockCount, ageStamp, pData->GetFileName() );
					nonStreamBytesUsedPooled += pData->m_nBufferBytes;
				}
				s_WaveCache.CacheUnlockMutex();
			}
			Msg( "CAsyncWavDataCache: Non-Stream Buffers (Pooled): %.2f MB used\n", (float)nonStreamBytesUsedPooled / ( 1024.0f * 1024.0f ) );

			int nonStreamBytesUsedStandard = 0;
			Msg( "\nCAsyncWavDataCache: Non-Stream Buffer List (Standard Heap):\n" );
			for ( BufferHandle_t h = m_BufferList.FirstInorder(); h != m_BufferList.InvalidIndex(); h = m_BufferList.NextInorder( h ) )
			{
				BufferEntry_t *pBuffer = &m_BufferList[h];
				CAsyncWaveData *pData = s_WaveCache.CacheGetNoTouch( pBuffer->m_hWaveData );
				s_WaveCache.CacheLockMutex();
				if ( pData && !pData->m_bIsTransient && !pData->m_bIsStaticPooled )
				{
					int lockCount = s_WaveCache.GetLockCount( pBuffer->m_hWaveData );
					unsigned int ageStamp = s_WaveCache.GetAgeStamp( pBuffer->m_hWaveData );
					Msg( "Start:%7d Size:%7d Lock:%3d Age:%4d %s\n", pBuffer->m_StartPos, pData->m_nBufferBytes, lockCount, ageStamp, pData->GetFileName() );
					nonStreamBytesUsedStandard += pData->m_nBufferBytes;
				}
				s_WaveCache.CacheUnlockMutex();
			}
			Msg( "CAsyncWavDataCache: Non-Stream Buffers (Standard): %.2f MB used\n", (float)nonStreamBytesUsedStandard / ( 1024.0f * 1024.0f ) );

			// iterate stream buffers
			int streamBytesUsed = 0;
			Msg( "\nCAsyncWavDataCache: Stream Buffer List:\n" );
			for ( BufferHandle_t h = m_BufferList.FirstInorder(); h != m_BufferList.InvalidIndex(); h = m_BufferList.NextInorder( h ) )
			{
				BufferEntry_t *pBuffer = &m_BufferList[h];
				CAsyncWaveData *pData = s_WaveCache.CacheGetNoTouch( pBuffer->m_hWaveData );
				s_WaveCache.CacheLockMutex();
				if ( pData && pData->m_bIsTransient )
				{
					int lockCount = s_WaveCache.GetLockCount( pBuffer->m_hWaveData );
					unsigned int ageStamp = s_WaveCache.GetAgeStamp( pBuffer->m_hWaveData );
					Msg( "Start:%7d Size:%7d Lock:%3d Age:%4d %s\n", pBuffer->m_StartPos, pData->m_nBufferBytes, lockCount, ageStamp, pData->GetFileName() );
					streamBytesUsed += pData->m_nBufferBytes;
				}
				s_WaveCache.CacheUnlockMutex();
			}
			Msg( "CAsyncWavDataCache: Stream Buffers: %.2f MB used\n", (float)streamBytesUsed / ( 1024.0f * 1024.0f ) );

			// the stream pool usage should match exactly with the streaming buffer iteration results
			Msg( "\nCAsyncWavDataCache: Stream Pool\n" );
			Msg( "  Block Size: %d bytes\n", g_pAudioStreamPool->BlockSize() );
			Msg( "  Blocks:     %d\n", g_pAudioStreamPool->Count() );
			Msg( "  Allocated:  %.2f MB \n", ( g_pAudioStreamPool->Count() * g_pAudioStreamPool->BlockSize() ) / ( 1024.0f * 1024.0f ) );
			Msg( "  Pool:       %.2f MB \n", g_pAudioStreamPool->Size() / ( 1024.0f * 1024.0f ) );
			Msg( "  Dead:       %d\n", m_DeadBuffers.Count() );
		}
	}
}

//-----------------------------------------------------------------------------
// This is a scary function. It doesn't check for possible outstanding async operations
// It is part of shutdown.
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Clear()
{
	int i;
	for ( i = m_CacheHandles.FirstInorder(); m_CacheHandles.IsValidIndex(i); i = m_CacheHandles.NextInorder(i) )
	{
		CacheEntry_t& dat = m_CacheHandles[i];
		s_WaveCache.CacheRemove( dat.handle );
	}
	m_CacheHandles.RemoveAll();

	FOR_EACH_LL( m_StreamedHandles, i )
	{
		StreamedEntry_t &dat = m_StreamedHandles[i];
		for ( int j=0; j<dat.m_numBuffers; ++j )
		{
			s_WaveCache.BreakLock( dat.m_hWaveData[j] );
			s_WaveCache.CacheRemove( dat.m_hWaveData[j] );
		}
	}
	m_StreamedHandles.RemoveAll();

	for ( int i = 0; i < m_DeadBuffers.Count(); i++ )
	{
		s_WaveCache.BreakLock( m_DeadBuffers[i].hWaveData );
		s_WaveCache.CacheRemove( m_DeadBuffers[i].hWaveData );
		
	}
	m_DeadBuffers.Purge();

	m_BufferList.RemoveAll();
}


static CAsyncWavDataCache g_AsyncWaveDataCache;
IAsyncWavDataCache *wavedatacache = &g_AsyncWaveDataCache;

CON_COMMAND( snd_async_flush, "Flush all unlocked async audio data" )
{
	g_AsyncWaveDataCache.Flush();
}

CON_COMMAND( snd_async_showmem, "Show async memory stats" )
{
	g_AsyncWaveDataCache.SpewMemoryUsage( CAsyncWavDataCache::SPEW_ALL );
}

CON_COMMAND( snd_async_showmem_summary, "Show brief async memory stats" )
{
	g_AsyncWaveDataCache.SpewMemoryUsage( CAsyncWavDataCache::SPEW_BASIC );
}

CON_COMMAND( snd_async_showmem_music, "Show async memory stats for just non-streamed music" )
{
	g_AsyncWaveDataCache.SpewMemoryUsage( CAsyncWavDataCache::SPEW_MUSIC_NONSTREAMING );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pFileName - 
//			dataOffset - 
//			dataSize - 
//-----------------------------------------------------------------------------
void PrefetchDataStream( const char *pFileName, int dataOffset, int dataSize )
{
	if ( IsGameConsole() )
	{
		// Xbox streaming buffer implementation does not support this "hinting"
		return;
	}

	wavedatacache->PrefetchCache( pFileName, dataSize, dataOffset );
}

//-----------------------------------------------------------------------------
// Purpose: This is an instance of a stream.
//			This contains the file handle and streaming buffer
//			The mixer doesn't know the file is streaming.  The IWaveData
//			abstracts the data access.  The mixer abstracts data encoding/format
//-----------------------------------------------------------------------------
class CWaveDataStreamAsync : public IWaveData
{
public:
	CWaveDataStreamAsync( CAudioSource &source, IWaveStreamSource *pStreamSource, const char *pFileName, int fileStart, int fileSize, CSfxTable *sfx, int startOffset, SoundError &soundError );
	~CWaveDataStreamAsync( void );

	// return the source pointer (mixer needs this to determine some things like sampling rate)
	CAudioSource &Source( void ) { return m_source; }

	// Read data from the source - this is the primary function of a IWaveData subclass
	// Get the data from the buffer (or reload from disk)
	virtual int ReadSourceData( void **pData, int64 sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] );
	bool IsValid() { return m_bValid; }
	virtual bool IsReadyToMix();
	virtual void UpdateLoopPosition( int nLoopPosition );

private:
	CWaveDataStreamAsync( const CWaveDataStreamAsync & );

	//-----------------------------------------------------------------------------
	// Purpose: 
	// Output : byte
	//-----------------------------------------------------------------------------
	inline byte *GetCachedDataPointer()
	{
		VPROF( "CWaveDataStreamAsync::GetCachedDataPointer" );

		CAudioSourceCachedInfo *info = m_AudioCacheHandle.Get( CAudioSource::AUDIO_SOURCE_WAV, m_pSfx->IsPrecachedSound(), m_pSfx, &m_nCachedDataSize );
		if ( !info )
		{
			Assert( !"CAudioSourceWave::GetCachedDataPointer info == NULL" );
			return NULL;
		}

		return (byte *)info->CachedData();
	}

	char const				*GetFileName();
	CAudioSource			&m_source;					// wave source
	IWaveStreamSource		*m_pStreamSource;			// streaming
	int						m_sampleSize;				// size of a sample in bytes
	int						m_waveSize;					// total number of samples in the file

	int						m_bufferSize;				// size of transfer buffer in samples
	char					*m_pBuffer;					// transfer buffer
	int64					m_sampleIndex;
	int						m_bufferCount;
	int						m_dataStart;
	int						m_dataSize;

	WaveCacheHandle_t		m_hCache;
	StreamHandle_t			m_hStream;
	FileNameHandle_t		m_hFileName;
	
	CAudioSourceCachedInfoHandle_t m_AudioCacheHandle;
	int						m_nCachedDataSize;
	CSfxTable				*m_pSfx;

	// These members are used to handle more gracefully exhausted streaming
	static const int SIZE_LAST_SAMPLE = 8;				// Support up to stereo 32 bits sample
	uint8					m_LastSample[SIZE_LAST_SAMPLE];

	unsigned int			m_bValid : 1;
};

CWaveDataStreamAsync::CWaveDataStreamAsync
	( 
		CAudioSource &source, 
		IWaveStreamSource *pStreamSource, 
		const char *pFileName, 
		int fileStart, 
		int fileSize, 
		CSfxTable *sfx,
		int startOffset,
		SoundError &soundError
	) : 
	m_source( source ), 
	m_dataStart( fileStart ), 
	m_dataSize( fileSize ), 
	m_pStreamSource( pStreamSource ), 
	m_bValid( false ), 
	m_hCache( 0 ),
	m_hStream( INVALID_STREAM_HANDLE ),
	m_hFileName( 0 ), 
	m_pSfx( sfx ),
	m_pBuffer( NULL )
{
	soundError = SE_OK;
	m_hFileName = g_pFileSystem->FindOrAddFileName( pFileName );

	// nothing in the buffer yet
	m_sampleIndex = 0;
	m_bufferCount = 0;

	m_nCachedDataSize = 0;

	if ( m_dataSize <= 0 )
	{
		DevMsg( 1, "Can't find streaming wav file: sound\\%s\n", GetFileName() );
		soundError = SE_FILE_NOT_FOUND;
		return;
	}

	if ( IsPC() )
	{
		m_hCache = wavedatacache->AsyncLoadCache( GetFileName(), m_dataSize, m_dataStart );

		m_pBuffer = new char[SINGLE_BUFFER_SIZE];
		Q_memset( m_pBuffer, 0, SINGLE_BUFFER_SIZE );

		// size of a sample
		m_sampleSize = source.SampleSize();
		// size in samples of the buffer
		m_bufferSize = SINGLE_BUFFER_SIZE / m_sampleSize;
		// size in samples (not bytes) of the wave itself
		m_waveSize = fileSize / m_sampleSize;

		m_AudioCacheHandle.Get( CAudioSource::AUDIO_SOURCE_WAV, m_pSfx->IsPrecachedSound(), m_pSfx, &m_nCachedDataSize );
	}
	
	if ( IsGameConsole() )
	{
		// size of a sample
		m_sampleSize = source.SampleSize();
		// size in samples (not bytes) of the wave itself
		m_waveSize = fileSize / m_sampleSize;

		// mark as transient to let streamer better configure the buffers for a streaming wave	
		// absence of transient indicates a memory resident wave
		streamFlags_t flags = STREAMED_FROMDVD | STREAMED_TRANSIENT;
		if ( IsGameConsole() )
		{
			char cleanName[MAX_PATH];
			V_strncpy( cleanName, pFileName, sizeof( cleanName ) );
			V_FixSlashes( cleanName, '/' );

			bool bForceToSinglePlay = false;

			if ( bForceToSinglePlay || 
				V_stristr( cleanName, "music/" ) || 
				V_stristr( cleanName, "commentary/" ) ||
				V_stristr( cleanName, "playonce/" ))
			{
				// music discards and cycles its buffers
				flags |= STREAMED_SINGLEPLAY;
			}
			else if ( !source.IsSentenceWord() && V_stristr( cleanName, "vo/" ) )
			{
				// vo discards and cycles its buffers, except for sentence sources which recur
				flags |= STREAMED_SINGLEPLAY;
			}
	}

#if IsX360()
		// the xma mixer expects quantum xma blocks
		COMPILE_TIME_ASSERT( ( STREAM_BUFFER_DATASIZE % XMA_BLOCK_SIZE ) == 0 );
		// streaming buffers must be sector compliant
		COMPILE_TIME_ASSERT( ( STREAM_BUFFER_DATASIZE % XBOX_DVD_SECTORSIZE ) == 0 );
#endif

		int transferSize = STREAM_BUFFER_DATASIZE;
		int nAlignedDataSize = AlignValue( m_dataSize, transferSize );
		int numBuffers = nAlignedDataSize / transferSize;					// Number of buffers that we would need at max

		int nNecessaryBuffers = source.IsLooped() ? 4 : 2;					// By default we need 2 buffers, but when looping the safe number is 4
		nNecessaryBuffers = MIN( nNecessaryBuffers, STREAM_BUFFER_COUNT );	// Max numbers of buffers allowed on that platform
		numBuffers = MIN( numBuffers, nNecessaryBuffers );					// Don't allocate more buffers than necessary to load completely the sound

		if ( numBuffers == 1 )
		{
			// the transfer buffer can be exact sized
			// [oliviern] I kept the old behavior but it seems to me that this would fragment the memory (and would not help in worst case anyway)
			transferSize = m_dataSize;
		}

		// allocate a transfer buffer
		// when multiple buffering, exactly matches the size of the streaming buffer
		// ensures that a streaming buffer can be entirely consumed and requeued during the transfer
		m_pBuffer = new char[transferSize];
		// size in samples of the transfer buffer
		m_bufferSize = transferSize / m_sampleSize;

		int loopStart;
		if ( source.IsLooped() )
		{
			int loopBlock;
			loopStart = m_pStreamSource->GetLoopingInfo( &loopBlock, NULL, NULL ) * m_sampleSize;

			// Note that the loop start is inaccurate for some format (like WAVE_FORMAT_MP3).
			// It is a bytes position in uncompressed samples, but this is not valid for MP3.
			// We actually update the loopStart when we parse the sound (while playing it) and we find the MP3 frame that contains the loop position.
			// We then call UpdateLoopPosition() with the corresponding MP3 frame.
			// In most cases, the full MP3 sound is going to fit in the streaming buffers. For long sounds when the looping points is far (like at the beginning),
			// loopStart is going to be updated before it is actually used.
			// There is a potential for rare cases where we will start streaming with an incorrect loop position, then update the loop point at a later time.
			// In this case, we may stream some memory for nothing or in some extreme cases, have the streamed buffers not ready in time.
			// This would happen only for the first loop.
			// The XMA format fixes that by approximating loopStart with loopBlock (because compressed samples are fortunately aligned on 2048 bytes).
#if defined( _GAMECONSOLE )
			switch ( source.Format() )
			{
#if IsX360()
			case WAVE_FORMAT_XMA:
				// xma works in blocks, mixer handles inter-block accurate loop positioning
				// block streaming will cycle from the block where the loop occurs
				loopStart = loopBlock * XMA_BLOCK_SIZE;
				break;
#endif
#if IsPS3()
			case WAVE_FORMAT_MP3:
				loopStart /= 10;		// We assume that we have a compression factor of 10.
										// With the streamed buffer, it is better to start before than after (as the current impl. reads several buffers forward).
				if ( loopStart > fileSize )
				{
					// Make sure we are in a reasonable range
					loopStart = fileSize - transferSize;
					if ( loopStart < 0 )
					{
						loopStart = 0;
					}
				}
				break;

			case WAVE_FORMAT_TEMP:
				// Uncompressed, so keep it roughly the same
				break;
#endif
			default:
				// Nothing to fix up
				break;
			}
#endif

		}
		else
		{
			// sample not looped
			loopStart = -1;
		}

		// load the file piecewise through a buffering implementation
		m_hStream = wavedatacache->OpenStreamedLoad( pFileName, m_dataSize, m_dataStart, startOffset, loopStart, STREAM_BUFFER_DATASIZE, numBuffers, flags, soundError );
		if ( m_hStream == INVALID_STREAM_HANDLE )
		{
			if ( soundError == SE_NO_STREAM_BUFFER )
			{
				DevWarning( "[Sound] Not enough stream buffer available to setup wav file: '\\%s'\n", GetFileName() );
			}
			else
			{
				DevWarning( "[Sound] Failed to setup streaming wav file: sound\\%s\n", GetFileName() );
			}
			m_bValid = false;
			return;
		}
		else
		{
			m_sampleIndex = startOffset;		// Do not forget to initialize the sample index at the correct position
												// otherwise this is going to put the whole streaming algorithm off.
												// The whole streaming layer in this file should be re-written by the way as it is needlessly complicated
												// and only works in very specific conditions.
		}
	}

	V_memset( m_LastSample, 0, sizeof( m_LastSample ) );

	m_bValid = true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CWaveDataStreamAsync::~CWaveDataStreamAsync( void ) 
{
	if ( IsPC() && m_source.IsPlayOnce() && m_source.CanDelete() )
	{
		m_source.SetPlayOnce( false ); // in case it gets used again
		wavedatacache->Unload( m_hCache );
	}

	if ( IsGameConsole() )
	{
		wavedatacache->CloseStreamedLoad( m_hStream ); 
	}

	delete [] m_pBuffer;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : char const
//-----------------------------------------------------------------------------
char const *CWaveDataStreamAsync::GetFileName()
{
	static char fn[MAX_PATH];

	if ( m_hFileName )
	{
		if ( g_pFileSystem->String( m_hFileName, fn, sizeof( fn ) ) )
		{
			return fn;
		}
	}

	Assert( 0 );
	return "";
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWaveDataStreamAsync::IsReadyToMix()
{
	if ( IsPC() )
	{
		// If not async loaded, start mixing right away
		if ( !m_source.IsAsyncLoad() && !snd_async_fullyasync.GetBool() )
		{
			return true;
		}

		bool bCacheValid;
		bool bLoaded = wavedatacache->IsDataLoadCompleted( m_hCache, &bCacheValid );
		if ( !bCacheValid )
		{
			wavedatacache->RestartDataLoad( &m_hCache, GetFileName(), m_dataSize, m_dataStart );
		}

		// When laying off a movie, all sound access is forced to be synchronous to get better 
		//  synchronization (avoids async loading random delay)
		if ( g_pEngineToolInternal->IsRecordingMovie() )
		{
			return true;
		}

		return bLoaded;
	}

	if ( IsGameConsole() )
	{
		return wavedatacache->IsStreamedDataReady( m_hStream );
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CWaveDataStreamAsync::UpdateLoopPosition( int nLoopPosition )
{
	if ( m_hStream != INVALID_STREAM_HANDLE )
	{
		wavedatacache->UpdateLoopPosition( m_hStream, nLoopPosition );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Read data from the source - this is the primary function of a IWaveData subclass
//  Get the data from the buffer (or reload from disk)
// Input  : **pData - 
//			sampleIndex - 
//			sampleCount - 
//			copyBuf[AUDIOSOURCE_COPYBUF_SIZE] - 
// Output : int
//-----------------------------------------------------------------------------
int CWaveDataStreamAsync::ReadSourceData( void **pData, int64 sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] )
{
	int nOldBufferCount = m_bufferCount;
	int nOldSampleIndex = m_sampleIndex;

	// Current file position
	int seekpos = m_dataStart + m_sampleIndex * m_sampleSize;

	// wrap position if looping
	if ( m_source.IsLooped() )
	{
		sampleIndex = m_pStreamSource->UpdateLoopingSamplePosition( sampleIndex );
		if ( sampleIndex < m_sampleIndex )
		{
			if ( snd_report_loop_sound.GetBool() )
			{
				Warning( "[Sound] Sound \"%s\" just looped.\n", GetFileName( ) );
			}

			// looped back, buffer has no samples yet
			m_sampleIndex = sampleIndex;
			m_bufferCount = 0;

			// update file position
			seekpos = m_dataStart + sampleIndex * m_sampleSize;
		}
	}

	// UNDONE: This is an error!!
	// The mixer playing back the stream tried to go backwards!?!?!
	// BUGBUG: Just play the beginning of the buffer until we get to a valid linear position
	if ( sampleIndex < m_sampleIndex )
		sampleIndex = m_sampleIndex;

	// calc sample position relative to the current buffer
	// m_sampleIndex is the sample position of the first byte of the buffer
	sampleIndex -= m_sampleIndex;
	
	// out of range? refresh buffer
	if ( sampleIndex >= m_bufferCount )
	{
		// advance one buffer (the file is positioned here)
		m_sampleIndex += m_bufferCount;
		// next sample to load
		sampleIndex -= m_bufferCount;

		// if the remainder is greater than one buffer size, seek over it.  Otherwise, read the next chunk
		// and leave the remainder as an offset.

		// number of buffers to "skip" (as in the case where we are starting a streaming sound not at the beginning)
		int skips = sampleIndex / m_bufferSize;
		
		// If we are skipping over a buffer, do it with a seek instead of a read.
		if ( skips )
		{
			// skip directly to next position
			m_sampleIndex += sampleIndex;
			sampleIndex = 0;
		}

		// move the file to the new position
		seekpos = m_dataStart + (m_sampleIndex * m_sampleSize);

		// This is the maximum number of samples we could read from the file
		m_bufferCount = m_waveSize - m_sampleIndex;
		
		// past the end of the file?  stop the wave.
		if ( m_bufferCount <= 0 )
			return 0;

		// clamp available samples to buffer size
		if ( m_bufferCount > m_bufferSize )
			m_bufferCount = m_bufferSize;

		if ( IsPC() )
		{
			// See if we can load in the initial data right out of the cached data lump instead.
			int cacheddatastartpos = ( seekpos - m_dataStart );

			// FastGet doesn't call into IsPrecachedSound if the handle appears valid...
			CAudioSourceCachedInfo *info = m_AudioCacheHandle.FastGet();
			if ( !info )
			{
				// Full recache
				info = m_AudioCacheHandle.Get( CAudioSource::AUDIO_SOURCE_WAV, m_pSfx->IsPrecachedSound(), m_pSfx, &m_nCachedDataSize );
			}

			bool startupCacheUsed = false;

			if  ( info && 
				( m_nCachedDataSize > 0 ) && 
				( cacheddatastartpos < m_nCachedDataSize ) )
			{
				// Get a ptr to the cached data
				const byte *cacheddata = info->CachedData();
				if ( cacheddata )
				{
					// See how many samples of cached data are available (cacheddatastartpos is zero on the first read)
					int availSamples = ( m_nCachedDataSize - cacheddatastartpos ) / m_sampleSize;

					// Clamp to size of our internal buffer
					if ( availSamples > m_bufferSize )
					{
						availSamples = m_bufferSize;
					}

					// Mark how many we are returning
					m_bufferCount = availSamples;
					// Copy raw sample data directly out of cache
					Q_memcpy( m_pBuffer, ( char * )cacheddata + cacheddatastartpos, availSamples * m_sampleSize );

					startupCacheUsed = true;
				}
			}

			// Not in startup cache, grab data from async cache loader (will block if data hasn't arrived yet)
			if ( !startupCacheUsed )
			{
				bool postprocessed = false;
				
				// read in the max bufferable, available samples
				if ( !wavedatacache->CopyDataIntoMemory( 
					m_hCache, 
					GetFileName(), 
					m_dataSize, 
					m_dataStart,
					m_pBuffer, 
					m_bufferSize * m_sampleSize,
					seekpos, 
					m_bufferCount * m_sampleSize,
					&postprocessed ) )
				{
					return 0;
				}

				// do any conversion the source needs (mixer will decode/decompress)
				if ( !postprocessed )
				{
					// Note that we don't set the postprocessed flag on the underlying data, since for streaming we're copying the
					//  original data into this buffer instead.
					m_pStreamSource->UpdateSamples( m_pBuffer, m_bufferCount );
				}
			}
		}

		if ( IsGameConsole() )
		{
			if ( m_hStream != INVALID_STREAM_HANDLE )
			{
				// request available data, may get less
				// drives the buffering
				int nBytesFilled = wavedatacache->CopyStreamedDataIntoMemory( 
									m_hStream, 
									m_pBuffer, 
									m_bufferSize * m_sampleSize,
									seekpos, 
									m_bufferCount * m_sampleSize );

				if ( nBytesFilled == 0 )
				{
					// If we reach here, it means the streamer is behind
					// Let's try to recover so the sound does not stop abruptly. It only works for PCM sounds though,
					// for XMA and MP3 sounds, we have to do this at their own level (as we can't send simulated data for them).
					if ( snd_async_stream_recover_from_exhausted_stream.GetBool() && ( m_source.Format() == WAVE_FORMAT_PCM ) )
					{
						if ( m_sampleSize <= SIZE_LAST_SAMPLE )
						{
							if ( snd_async_stream_spew_exhausted_buffer.GetBool() && ( g_pQueuedLoader->IsMapLoading() == false ) )
							{
								static uint sOldTime = 0;
								uint nCurrentTime = Plat_MSTime();
								if ( nCurrentTime >= sOldTime + snd_async_stream_spew_exhausted_buffer_time.GetInt() )
								{
									Warning( "[Sound] The stream buffer is exhausted for sound '%s'. Except after loading, fill a bug to have the number of sounds played reduced.\n", GetFileName() );
									sOldTime = nCurrentTime;
								}
							}
							// This code is not optimized, but hopefully never executed.
							int nSamplesToFill = imin( m_bufferCount, AUDIOSOURCE_COPYBUF_SIZE  / m_sampleSize );
							nSamplesToFill = imin( nSamplesToFill, sampleCount );
							if ( copyBuf != NULL )
							{
								for ( int i = 0 ; i < nSamplesToFill ; ++i )
								{
									V_memcpy( &copyBuf[ i * m_sampleSize ], &m_LastSample, m_sampleSize );
								}
							}
							*pData = copyBuf;

							m_bufferCount = nOldBufferCount;		// Put back the values to the state before any change were applied.
							m_sampleIndex = nOldSampleIndex;		// In some cases, we could actually have a buffer filled with static if the sound was smaller than one buffer long.
							return nSamplesToFill;
						}
					}
				}
				else
				{
					if ( m_sampleSize <= SIZE_LAST_SAMPLE )
					{
						// Let's copy the last sample, in case next time the streamer is too late. We fill with the last sample instead of zero to reduce potential pops.
						V_memcpy( &m_LastSample, &m_pBuffer[ nBytesFilled - m_sampleSize ], m_sampleSize );
					}
				}

				// convert to number of samples in the buffer
				m_bufferCount = nBytesFilled / m_sampleSize;
			}
			else
			{
				return 0;
			}

			// do any conversion now the source needs (mixer will decode/decompress) on this buffer
			m_pStreamSource->UpdateSamples( m_pBuffer, m_bufferCount );
		}
	}

	// If we have some samples in the buffer that are within range of the request
	if ( sampleIndex < m_bufferCount )
	{
		// Get the desired starting sample
		*pData = (void *)&m_pBuffer[sampleIndex * m_sampleSize];

		// max available
		int available = m_bufferCount - sampleIndex;
		// clamp available to max requested
		if ( available > sampleCount )
			available = sampleCount;

		return available;
	}

	return 0;
}

//-----------------------------------------------------------------------------
// Purpose: Iterator for wave data (this is to abstract streaming/buffering)
//-----------------------------------------------------------------------------
class CWaveDataMemoryAsync : public IWaveData
{
public:
	CWaveDataMemoryAsync( CAudioSource &source );
	~CWaveDataMemoryAsync( void ) {}
	CAudioSource &Source( void ) { return m_source; }
	
	virtual int ReadSourceData( void **pData, int64 sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] );
	virtual bool IsReadyToMix();
	virtual void UpdateLoopPosition( int nLoopPosition );

private:
	CAudioSource		&m_source;	// pointer to source
};

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &source - 
//-----------------------------------------------------------------------------
CWaveDataMemoryAsync::CWaveDataMemoryAsync( CAudioSource &source ) : 
	m_source(source) 
{
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : **pData - 
//			sampleIndex - 
//			sampleCount - 
//			copyBuf[AUDIOSOURCE_COPYBUF_SIZE] - 
// Output : int
//-----------------------------------------------------------------------------
int CWaveDataMemoryAsync::ReadSourceData( void **pData, int64 sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] )
{
	return m_source.GetOutputData( pData, sampleIndex, sampleCount, copyBuf );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWaveDataMemoryAsync::IsReadyToMix()
{
	if ( !m_source.IsAsyncLoad() && !snd_async_fullyasync.GetBool() )
	{
		// Wait until we're pending at least
		if ( m_source.GetCacheStatus() == CAudioSource::AUDIO_NOT_LOADED || m_source.GetCacheStatus() == CAudioSource::AUDIO_ERROR_LOADING )
		{
			// When laying off a movie, all sound access is forced to be synchronous to get better 
			//  synchronization (avoids async loading random delay)
			if ( g_pEngineToolInternal->IsRecordingMovie() )
			{
				return true;
			}

			return false;
		}
		return true;
	}

	if ( m_source.IsCached() )
	{
		return true;
	}

	if ( IsPC() )
	{
		// Msg( "Waiting for data '%s'\n", m_source.GetFileName() );
		m_source.CacheLoad();
	}

	if ( IsGameConsole() )
	{
		// expected to be resident and valid, otherwise being called prior to load
		Assert( 0 );
	}

	return false;
}

void CWaveDataMemoryAsync::UpdateLoopPosition( int nLoopPosition )
{
	// Should not be necessary in this implementation...
	Assert( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &source - 
//			*pStreamSource - 
//			&io - 
//			*pFileName - 
//			dataOffset - 
//			dataSize - 
// Output : IWaveData
//-----------------------------------------------------------------------------
IWaveData *CreateWaveDataStream( CAudioSource &source, IWaveStreamSource *pStreamSource, const char *pFileName, int dataStart, int dataSize, CSfxTable *pSfx, int startOffset, int skipInitialSamples, SoundError &soundError )
{
	CWaveDataStreamAsync *pStream = new CWaveDataStreamAsync( source, pStreamSource, pFileName, dataStart, dataSize, pSfx, startOffset, soundError );
	if ( !pStream || !pStream->IsValid() )
	{
		delete pStream;
		pStream = NULL;
	}
	return pStream;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &source - 
// Output : IWaveData
//-----------------------------------------------------------------------------
IWaveData *CreateWaveDataMemory( CAudioSource &source )
{
	CWaveDataMemoryAsync *mem = new CWaveDataMemoryAsync( source );
	return mem;
}

// set this to zero to revert to the previous scalar code
#define PHONON_USE_SIMD 0


namespace
{
	const int PHONON_FRAME_SIZE = 1024 * 2;

	ThreadHandle_t g_hPhononThread;
	bool g_bPhononThreadExit;
	CThreadFastMutex g_phononMutex;

	IPLAudioFormat g_phononInputFormat, g_phononOutputFormat;
	IPLhandle g_phononContext = 0;

	static const int PHONON_SAMPLE_SIZE = 4;
	struct PhononJob
	{
		~PhononJob()
		{
			if (phononEffect)
			{
				iplDestroyBinauralEffect(&phononEffect);
			}
		}
		IPLHrtfInterpolation interpolation;
		int nChannels;
		int nDataWidth;

		Vector vec;
		float lerp;
		IPLhandle phononEffect;

		bool bComplete;

		CThreadFastMutex mutex;

		char inputBuf[PHONON_FRAME_SIZE * PHONON_SAMPLE_SIZE];
		short outputBuf[PHONON_FRAME_SIZE * 2];

		float fSubmitTime, fCompleteTime;
	};

	void ProcessPhononJob(PhononJob& job)
	{
		TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "ProcessPhononJob %d", PHONON_FRAME_SIZE );
		if (!job.phononEffect)
		{
			TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "iplCreateBinauralEffect" );
			IPLerror error = iplCreateBinauralEffect(g_phononContext, g_phononInputFormat, g_phononOutputFormat, &job.phononEffect);
			if (error)
			{
				ConVarRef snd_use_hrtf("snd_use_hrtf");
				snd_use_hrtf.SetValue(false);
				DevMsg("Failed to create binaural effect: %d. Turning off binaural rendering\n", (int)error);
				memset( job.outputBuf, 0, sizeof( job.outputBuf ) );
				return;
			}
		}
		float ALIGN16 phononInputBuf[PHONON_FRAME_SIZE];

		// stereo inputs are scaled by 0.5 to avoid distortion
		float flStereoScale = 0.5f;

		const short *in = (const short*)job.inputBuf;
		// base scalar code for clarity
#if !PHONON_USE_SIMD
//		if ( !PHONON_USE_SIMD )
		{
			TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "ConvertMultiToFloat" );
			for ( int n = 0; n != PHONON_FRAME_SIZE; ++n )
			{
				int value = 0;

				for ( int i = 0; i != job.nChannels; ++i )
				{
					value += *in / job.nChannels;
					++in;
				}

				phononInputBuf[ n ] = value / ( 65536.0 * 0.5 );
			}
		}
#else  //!PHONON_USE_SIMD
//		else
		{
			const float flSigned16ToUnitScale = 1.0f / 32768.0f;

			if ( job.nChannels == 1 )
			{
				TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "ConvertShortToFloat" );
				ConvertShortToFloat( phononInputBuf, in, PHONON_FRAME_SIZE, flSigned16ToUnitScale );
			}
			else
			{
				TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "SumStereoShortToFloat" );
				SumStereoShortToFloat( phononInputBuf, in, PHONON_FRAME_SIZE, flSigned16ToUnitScale * flStereoScale );
			}
		}
#endif //!PHONON_USE_SIMD
		float ALIGN16 phononOutputBuf[PHONON_FRAME_SIZE * 2];
		memset( phononOutputBuf, 0, sizeof( phononOutputBuf ) );

		IPLAudioBuffer input_buffer;
		input_buffer.format = g_phononInputFormat;
		input_buffer.numSamples = PHONON_FRAME_SIZE;
		input_buffer.interleavedBuffer = phononInputBuf;
		input_buffer.deinterleavedBuffer = nullptr;

		IPLAudioBuffer output_buffer;
		output_buffer.format = g_phononOutputFormat;
		output_buffer.numSamples = PHONON_FRAME_SIZE;
		output_buffer.interleavedBuffer = phononOutputBuf;
		output_buffer.deinterleavedBuffer = nullptr;

		IPLVector3 iplvec;
		iplvec.x = job.vec.x;
		iplvec.y = job.vec.y;
		iplvec.z = job.vec.z;

		{
			TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "iplApplyBinauralEffect" );
			iplApplyBinauralEffect( job.phononEffect, input_buffer, iplvec, job.interpolation, output_buffer );
		}

#if !PHONON_USE_SIMD
		//if ( !PHONON_USE_SIMD )
		{
			TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "Convert" );
			for ( int n = 0; n < PHONON_FRAME_SIZE * 2; ++n )
			{
				Assert( phononOutputBuf[ n ] > -8.0 && phononOutputBuf[ n ] < 8.0 );
				int out = static_cast<int>( phononOutputBuf[ n ] * 65536.0 / 16.0 );
				job.outputBuf[ n ] = static_cast<short>( out );
			}
		}
#else  //!PHONON_USE_SIMD
		//else
		{
			TM_ZONE( TELEMETRY_LEVEL0, TMZF_NONE, "ConvertSIMD" );
			// convert from float [-1,1] to short [-32767, 32768], but phonon may have amplified so reduce to 0.125f
			float flScaleFactorFloat = ( 32768.0f ) * ( 0.125f );
			ConvertFloatToShort( job.outputBuf, &phononOutputBuf[ 0 ], PHONON_FRAME_SIZE * 2, flScaleFactorFloat );
		}
#endif //!PHONON_USE_SIMD
	}

	void SetupPhononContext()
	{
		if (g_phononContext)
		{
			return;
		}

		ConVarRef snd_use_hrtf("snd_use_hrtf");

		IPLGlobalContext iplContext;
		memset(&iplContext, 0, sizeof(iplContext));
		iplContext.logCallback = nullptr;

		IPLDspParams dspParams;
		dspParams.samplingRate = 44100;
		dspParams.frameSize = PHONON_FRAME_SIZE;

		IPLerror phononError = iplCreate3DContext(iplContext, dspParams, nullptr, &g_phononContext);
		if (phononError != IPL_STATUS_SUCCESS)
		{
			DevMsg( "Failed to init phonon: %d\n", (int)phononError );
			snd_use_hrtf.SetValue(false);
			return;
		}

		g_phononInputFormat.channelLayoutType = IPL_CHANNELLAYOUTTYPE_SPEAKERS;
		g_phononInputFormat.channelLayout = IPL_CHANNELLAYOUT_MONO;
		g_phononInputFormat.numSpeakers = 1;
		g_phononInputFormat.speakerDirections = nullptr;
		g_phononInputFormat.channelOrder = IPL_CHANNELORDER_INTERLEAVED;

		g_phononOutputFormat = g_phononInputFormat;
		g_phononOutputFormat.channelLayout = IPL_CHANNELLAYOUT_STEREO;
		g_phononOutputFormat.numSpeakers = 2;
	}

	CTSQueue<PhononJob*> g_phononJobQueue, g_phononDeleteQueue;

	CThreadEvent g_eventPhononThread;

	int g_benchSecond = 0;
	float g_sleepTime = 0.0;
	float g_fMaxJobTime = 0.0;
	float g_fBenchRunway = -1.0f;
	int g_nBenchSkips = 0;
	int g_nBenchNumSounds = 0;
	int g_nBenchMaxNumSounds = 0;
	CThreadFastMutex g_mutexBenchSkips;

	ConVar snd_hrtf_benchmark("snd_hrtf_benchmark", "0", FCVAR_NONE, "");

	void PhononThread()
	{
		SetupPhononContext();

		while (!g_bPhononThreadExit)
		{
			PhononJob *job = nullptr;
			while (g_phononJobQueue.PopItem(&job))
			{
				//				float t = Plat_FloatTime();
				ProcessPhononJob(*job);
				//				DevMsg("HRTF: Processed HRTF job %p in %f\n", job, Plat_FloatTime() - t);

				if (snd_hrtf_benchmark.GetBool())
				{
					float fTime = Plat_FloatTime();
					float fElapsed = fTime - job->fSubmitTime;
					job->fCompleteTime = fTime;
					if (fElapsed > g_fMaxJobTime)
					{
						g_fMaxJobTime = fElapsed;
					}
				}

				job->mutex.Lock();
				job->bComplete = true;
				job->mutex.Unlock();
			}

			while (g_phononDeleteQueue.Count() > 0 && g_phononJobQueue.Count() == 0)
			{
				if (g_phononDeleteQueue.PopItem(&job))
				{
					delete job;
				}
			}

			if (snd_hrtf_benchmark.GetBool())
			{
				float start_sleep = Plat_FloatTime();
				g_eventPhononThread.Wait(10);
				float end_sleep = Plat_FloatTime();
				int sec = (int)end_sleep;
				if (sec != g_benchSecond)
				{
					g_sleepTime += float(sec) - start_sleep;

					g_mutexBenchSkips.Lock();
					const int nSkips = g_nBenchSkips;
					const float fRunway = g_fBenchRunway;
					g_nBenchSkips = 0;
					g_fBenchRunway = -1.0f;
					const int nSounds = g_nBenchMaxNumSounds;
					g_nBenchMaxNumSounds = g_nBenchNumSounds;
					g_mutexBenchSkips.Unlock();


					float busy = (1.0 - g_sleepTime)*100.0f;
					DevMsg("HRTF: sounds: %d busy: %0.2f%% Max latency: %0.3fms runway: %0.3fms skips: %d\n", nSounds, busy, g_fMaxJobTime*1000.0f, fRunway*1000.0f, nSkips);
					g_sleepTime = end_sleep - float(sec);

					g_fMaxJobTime = 0.0f;

					g_benchSecond = sec;
				}
				else
				{
					g_sleepTime += end_sleep - start_sleep;
				}
			}
			else
			{
				//Wait for a signal that there is more work or at
				//most 10ms.
				g_eventPhononThread.Wait(10);
			}
		}
	}

}

ConVar snd_hrtf_passthrough("snd_hrtf_passthrough", "0", FCVAR_NONE, "");
ConVar snd_hrtf_async("snd_hrtf_async", "1", FCVAR_NONE, "");
ConVar snd_hrtf_lerp_method("snd_hrtf_lerp_method", "0", FCVAR_NONE, "");

void StartPhononThread()
{
	if (!snd_hrtf_async.GetBool())
	{
		SetupPhononContext();
		return;
	}

	if (!g_hPhononThread )
	{
		g_bPhononThreadExit = false;
		g_hPhononThread = ThreadExecuteSolo("SndMixPhonon", PhononThread);
		if (!g_hPhononThread)
		{
			DevMsg("Failed to start phonon thread\n");
		}
	}
}

void ShutdownPhononThread()
{
	if (g_hPhononThread)
	{
		g_bPhononThreadExit = true;
		g_eventPhononThread.Set();
		ThreadJoin(g_hPhononThread);
		ReleaseThreadHandle(g_hPhononThread);
		g_hPhononThread = NULL;
	}
}

class CWaveDataHRTF : public IWaveData
{
public:
	CWaveDataHRTF(IWaveData* pData, hrtf_info_t* dir);
	~CWaveDataHRTF();
	
	CAudioSource &Source() { return m_pData->Source(); }

	virtual int ReadSourceData(void **pData, int64 sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE]);
	virtual bool IsReadyToMix()
	{
		if (snd_hrtf_passthrough.GetBool())
		{
			return m_pData->IsReadyToMix();
		}

		if (m_bAsync == false)
		{
			return m_pData->IsReadyToMix() || SamplesAvailableToRead() >= 512;
		}

		TryCompleteJob();

		bool bResult = m_bEOF || SamplesAvailableToRead() > 0;
		if (snd_hrtf_benchmark.GetBool())
		{
			if (bResult && m_bHasStartedMixing == false)
			{
				m_bHasStartedMixing = true;
			}
			else if (bResult == false && m_bHasStartedMixing && !m_bEOF)
			{
				g_mutexBenchSkips.Lock();
				++g_nBenchSkips;
				g_mutexBenchSkips.Unlock();
			}
			else if (bResult && m_bHasStartedMixing && SamplesAvailableToRead() < 512 + PHONON_FRAME_SIZE)
			{
				float fRunway = Plat_FloatTime() - m_pJob->fCompleteTime;
				g_mutexBenchSkips.Lock();
				if (fRunway < g_fBenchRunway || g_fBenchRunway == -1.0f)
				{
					g_fBenchRunway = fRunway;
				}
				g_mutexBenchSkips.Unlock();
			}
		}

		TrySubmitJob();
		TryCompleteJob();

		return bResult;
	}
	virtual void UpdateLoopPosition(int nLoopPosition)
	{
		m_pData->UpdateLoopPosition(nLoopPosition);
	}

private:
	IWaveData* m_pData;
	hrtf_info_t* m_pDir;

	void TryCompleteJob();
	void TrySubmitJob();

	PhononJob *m_pJob;
	bool m_bJobPending;

	int m_nChannels;
	int m_nDataWidth;

	int64 m_nDataStreamReadPos;
	bool m_bEOF;
	bool m_bAsync;

	int64 m_readIndex;

	char m_outputBuf[PHONON_FRAME_SIZE * PHONON_SAMPLE_SIZE * 2];
	char* m_readPos;
	char* m_writePos;

	bool m_bHasStartedMixing;

	bool m_bBenchmarking;

	int SamplesAvailableToRead() const
	{
		if (m_readPos <= m_writePos)
		{
			return (m_writePos - m_readPos)/PHONON_SAMPLE_SIZE;
		}
		else
		{
			const char *end = m_outputBuf + sizeof(m_outputBuf);
			return ((end - m_readPos) + (m_writePos - m_outputBuf)) / PHONON_SAMPLE_SIZE;
		}
	}

	int SamplesAvailableToWrite() const
	{
		return sizeof(m_outputBuf) / PHONON_SAMPLE_SIZE - SamplesAvailableToRead();
	}

	CWaveDataHRTF(const CWaveDataHRTF&);
	void operator=(const CWaveDataHRTF&);
};

CWaveDataHRTF::CWaveDataHRTF(IWaveData* pData, hrtf_info_t* dir) : m_pData(pData), m_pDir(dir), m_bJobPending(false), m_nDataStreamReadPos(0), m_bEOF(false), m_bAsync(snd_hrtf_async.GetBool()), m_bHasStartedMixing(false), m_bBenchmarking(snd_hrtf_benchmark.GetBool())
{
	if ( m_bBenchmarking )
	{
		g_mutexBenchSkips.Lock();
		g_nBenchNumSounds++;
		if ( g_nBenchNumSounds > g_nBenchMaxNumSounds )
		{
			g_nBenchMaxNumSounds = g_nBenchNumSounds;
		}

		g_mutexBenchSkips.Unlock();
	}

	m_pJob = new PhononJob;
	memset(m_pJob, 0, sizeof(*m_pJob));

	m_readIndex = 0;
	m_readPos = m_writePos = m_outputBuf;

	if (pData->Source().IsStereoWav())
	{
		m_nChannels = 2;
	}
	else
	{
		m_nChannels = 1;
	}

	m_nDataWidth = 2;
}

CWaveDataHRTF::~CWaveDataHRTF()
{
	if ( m_bBenchmarking )
	{
		g_mutexBenchSkips.Lock();
		g_nBenchNumSounds--;
		g_mutexBenchSkips.Unlock();
	}

	if (m_bAsync)
	{
		g_phononDeleteQueue.PushItem(m_pJob);
		g_eventPhononThread.Set();
	}
	else
		delete m_pJob;

	delete m_pData;
}

int CWaveDataHRTF::ReadSourceData(void **pData, int64 sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE])
{
	if (snd_hrtf_passthrough.GetBool())
	{
		return m_pData->ReadSourceData(pData, sampleIndex, sampleCount, copyBuf);
	}

	if (m_bAsync)
	{
		TryCompleteJob();
	}
	else
	{
		int nLastAvail = -1;
		while (SamplesAvailableToRead() < sampleCount && SamplesAvailableToRead() > nLastAvail && SamplesAvailableToWrite() > PHONON_FRAME_SIZE && m_pData->IsReadyToMix())
		{
			nLastAvail = SamplesAvailableToRead();
			TrySubmitJob();
			TryCompleteJob();
		}
	}

	const int nAvail = SamplesAvailableToRead();
	if (nAvail == 0 && m_bEOF)
	{
		*pData = nullptr;
		return 0;
	}

	int nRead = sampleCount < nAvail ? sampleCount : nAvail;
	if (nAvail < sampleCount && !m_bEOF)
	{
		DevMsg("HRTF: Not enough data, wanted %d, got %d\n", sampleCount, nAvail);
		g_mutexBenchSkips.Lock();
		++g_nBenchSkips;
		g_mutexBenchSkips.Unlock();
	}

	if (nRead > AUDIOSOURCE_COPYBUF_SIZE / PHONON_SAMPLE_SIZE)
	{
		nRead = AUDIOSOURCE_COPYBUF_SIZE / PHONON_SAMPLE_SIZE;
	}

	if (m_readIndex != sampleIndex)
	{
		Warning("Read index mismatch sampleIndex: %d vs %d\n", (int)m_readIndex, (int)sampleIndex);
	}

	m_readIndex += nRead;

	if ((m_outputBuf + sizeof(m_outputBuf)) - m_readPos >= nRead * PHONON_SAMPLE_SIZE)
	{
		memcpy(copyBuf, m_readPos, nRead*PHONON_SAMPLE_SIZE);
		m_readPos += nRead * PHONON_SAMPLE_SIZE;
	}
	else
	{
		char* out = copyBuf;
		const int at_end = (m_outputBuf + sizeof(m_outputBuf)) - m_readPos;
		const int at_begin = nRead*PHONON_SAMPLE_SIZE - at_end;
		memcpy(out, m_readPos, at_end);
		out += at_end;
		m_readPos = m_outputBuf;

		memcpy(out, m_readPos, at_begin);
		m_readPos += at_begin;
	}

	*pData = (void*)copyBuf;

	TrySubmitJob();

	return nRead;
}

void CWaveDataHRTF::TryCompleteJob()
{
	if (!m_bAsync && m_bJobPending)
	{
		ProcessPhononJob(*m_pJob);
		m_pJob->bComplete = true;
	}

	if (!m_bJobPending )
	{
		return;
	}

	m_pJob->mutex.Lock();
	const bool bComplete = m_pJob->bComplete;
	m_pJob->mutex.Unlock();

	if (!bComplete)
	{
		return;
	}

	m_pJob->bComplete = false;
	m_bJobPending = false;
	memcpy(m_writePos, m_pJob->outputBuf, sizeof( m_pJob->outputBuf ) );
	m_writePos += sizeof( m_pJob->outputBuf );
	if (m_writePos == m_outputBuf + sizeof(m_outputBuf))
	{
		m_writePos = m_outputBuf;
	}
}

void CWaveDataHRTF::TrySubmitJob()
{
	TryCompleteJob();

	if (m_bJobPending || SamplesAvailableToWrite() <= PHONON_FRAME_SIZE || m_bEOF)
	{
		return;
	}

	if (!m_pData->IsReadyToMix())
	{
		return;
	}

	char copyBuf[AUDIOSOURCE_COPYBUF_SIZE];

	char* buf = nullptr;

	int nLoaded = m_pData->ReadSourceData((void**)&buf, m_nDataStreamReadPos, PHONON_FRAME_SIZE, copyBuf);

	m_nDataStreamReadPos += nLoaded;

	if (nLoaded <= 0)
	{
		m_bEOF = true;
		return;
	}

	const int nBytesLoaded = nLoaded * sizeof(short) * m_nChannels;
	if (nLoaded < PHONON_FRAME_SIZE)
	{
		
		memcpy(m_pJob->inputBuf, buf, nBytesLoaded);
		memset(m_pJob->inputBuf + nBytesLoaded, 0, sizeof(m_pJob->inputBuf) - nBytesLoaded);
		m_bEOF = true;
	}
	else if (nLoaded == PHONON_FRAME_SIZE)
	{
		memcpy(m_pJob->inputBuf, buf, nBytesLoaded);
	}
	else
	{
		DevMsg("HRTF: Unexpected too many bytes from ReadSourceData: %d vs %d\n", PHONON_FRAME_SIZE, nLoaded);
		return;
	}

	m_pJob->nChannels = m_nChannels;
	m_pJob->nDataWidth = m_nDataWidth;
	m_pJob->interpolation = snd_hrtf_lerp_method.GetInt() == 0 && m_pDir->bilinear_filtering == false ? IPL_HRTFINTERPOLATION_NEAREST : IPL_HRTFINTERPOLATION_BILINEAR;
	m_pJob->vec = m_pDir->vec;	
	m_pJob->lerp = m_pDir->lerp;
	m_pJob->bComplete = false;

	if (snd_hrtf_benchmark.GetBool())
	{
		m_pJob->fSubmitTime = Plat_FloatTime();
	}

	m_bJobPending = true;
	

	if (m_bAsync)
	{
		g_phononJobQueue.PushItem(m_pJob);
		g_eventPhononThread.Set();
	}
	else
	{
		TryCompleteJob();
	}
}

IWaveData *CreateWaveDataHRTF(IWaveData* pData, hrtf_info_t* dir)
{
	if (dir == nullptr)
		return pData;

	CWaveDataHRTF* res = new CWaveDataHRTF(pData, dir);
	return res;
}