//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include "audio_pch.h"
#include "datacache/idatacache.h"
#include "utllinkedlist.h"
#include "utldict.h"
#include "filesystem/IQueuedLoader.h"
#include "cdll_int.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern IVEngineClient *engineClient;
extern IFileSystem *g_pFileSystem;
extern IDataCache *g_pDataCache;
extern double realtime;
// console streaming buffer implementation, appropriate for high latency and low memory
// shift this many buffers through the wave
#define STREAM_BUFFER_COUNT 2
// duration of audio samples per buffer, 200ms is 2x the worst frame rate (10Hz)
// the engine then has at least 400ms to deliver a new buffer or pop (assuming 2 buffers)
#define STREAM_BUFFER_TIME 0.200f
// force a single buffer when streaming waves smaller than this
#define STREAM_BUFFER_DATASIZE XBOX_DVD_ECC_SIZE
// PC single buffering implementation
// UNDONE: Allocate this in cache instead?
#define SINGLE_BUFFER_SIZE 16384
// Force a small cache for debugging cache issues.
// #define FORCE_SMALL_MEMORY_CACHE_SIZE ( 6 * 1024 * 1024 )
#define DEFAULT_WAV_MEMORY_CACHE ( 16 * 1024 * 1024 )
#define DEFAULT_XBOX_WAV_MEMORY_CACHE ( 16 * 1024 * 1024 )
#define TF_XBOX_WAV_MEMORY_CACHE ( 24 * 1024 * 1024 ) // Team Fortress uses a larger cache
// Dev builds will be missing soundcaches and hitch sometimes, we only care if its being properly launched from steam where sound caches should be complete.
ConVar snd_async_spew_blocking( "snd_async_spew_blocking", "1", 0, "Spew message to console any time async sound loading blocks on file i/o. ( 0=Off, 1=With -steam only, 2=Always" );
ConVar snd_async_spew( "snd_async_spew", "0", 0, "Spew all async sound reads, including success" );
ConVar snd_async_fullyasync( "snd_async_fullyasync", "0", 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" );
static bool SndAsyncSpewBlocking()
{
int pref = snd_async_spew_blocking.GetInt();
return ( pref >= 2 ) || ( pref == 1 && CommandLine()->FindParm( "-steam" ) != 0 );
}
#define SndAlignReads() 1
void MaybeReportMissingWav( char const *wav );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
struct asyncwaveparams_t
{
asyncwaveparams_t() : bPrefetch( false ), bCanBeQueued( false ) {}
FileNameHandle_t hFilename; // handle to sound item name (i.e. not with sound\ prefix)
int datasize;
int seekpos;
int alignment;
bool bPrefetch;
bool bCanBeQueued;
};
//-----------------------------------------------------------------------------
// Purpose: Builds a cache of the data bytes for a specific .wav file
//-----------------------------------------------------------------------------
class CAsyncWaveData
{
public:
explicit CAsyncWaveData();
// APIS required by CManagedDataCacheClient
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 ¶ms );
static unsigned int EstimatedSize( const asyncwaveparams_t ¶ms );
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
byte *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;
};
//-----------------------------------------------------------------------------
// 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_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 ( IsX360() )
{
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() || !IsX360() )
{
g_pFileSystem->FreeOptimalReadBuffer( m_pAlloc );
}
else
{
delete [] 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 = sizeof( *this );
if ( IsPC() )
{
size += m_nDataSize;
}
if ( IsX360() )
{
// the data size can shrink during streaming near end of file
// need the real contant size of this object's allocations
size += m_nBufferBytes;
}
return size;
}
//-----------------------------------------------------------------------------
// Purpose: Static method for CDataLRU
// Input : ¶ms -
// Output : CAsyncWaveData
//-----------------------------------------------------------------------------
CAsyncWaveData *CAsyncWaveData::CreateResource( const asyncwaveparams_t ¶ms )
{
CAsyncWaveData *pData = new CAsyncWaveData;
Assert( pData );
if ( pData )
{
if ( IsX360() )
{
// create buffer now for re-use during streaming process
pData->m_nBufferBytes = AlignValue( params.datasize, params.alignment );
pData->m_pAlloc = new byte[pData->m_nBufferBytes];
pData->m_pvData = pData->m_pAlloc;
}
pData->StartAsyncLoading( params );
}
return pData;
}
//-----------------------------------------------------------------------------
// Purpose: Static method
// Input : ¶ms -
// Output : static unsigned int
//-----------------------------------------------------------------------------
unsigned int CAsyncWaveData::EstimatedSize( const asyncwaveparams_t ¶ms )
{
int size = sizeof( CAsyncWaveData );
if ( IsPC() )
{
size += params.datasize;
}
if ( IsX360() )
{
// the expected size of this object's allocations
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 = ( byte * )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 ( IsX360() )
{
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 ( SndAsyncSpewBlocking() )
{
// Force it to finish
float st = ( float )Plat_FloatTime();
g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
float ed = ( float )Plat_FloatTime();
Warning( "%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.GetBool() )
{
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;
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 ( SndAsyncSpewBlocking() )
{
float st = ( float )Plat_FloatTime();
g_pFileSystem->AsyncFinish( m_hAsyncControl, true );
float ed = ( float )Plat_FloatTime();
Warning( "%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.GetBool() )
{
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.GetBool() )
{
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( IsX360() || ( 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 ( !IsX360() )
{
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 = IsX360() ? 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 ( IsX360() && ( g_pFileSystem->GetDVDMode() == DVDMODE_STRICT ) )
{
// 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 ), FILTER_CULLNONPACK, &pathType ) )
{
// not found, do callback now to handle error
m_async.pfnCallback( m_async, 0, FSASYNC_ERR_FILEOPEN );
return;
}
m_async.pszFilename = szFullName;
}
if ( IsX360() && 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 CManagedDataCacheClient<CAsyncWaveData, asyncwaveparams_t>
{
public:
CAsyncWavDataCache();
~CAsyncWavDataCache() {}
virtual bool Init( unsigned int memSize );
virtual void Shutdown();
// implementation that treats file as monolithic
virtual memhandle_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( memhandle_t& handle, char const *filename, int datasize, int startpos, void *buffer, int bufsize, int copystartpos, int bytestocopy, bool *pbPostProcessed );
virtual void SetPostProcessed( memhandle_t handle, bool proc );
virtual void Unload( memhandle_t handle );
virtual bool GetDataPointer( memhandle_t& handle, char const *filename, int datasize, int startpos, void **pData, int copystartpos, bool *pbPostProcessed );
virtual bool IsDataLoadCompleted( memhandle_t handle, bool *pIsValid );
virtual void RestartDataLoad( memhandle_t* handle, char const *filename, int datasize, int startpos );
virtual bool IsDataLoadInProgress( memhandle_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 );
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();
virtual void OnMixBegin();
virtual void OnMixEnd();
void QueueUnlock( const memhandle_t &handle );
void SpewMemoryUsage( int 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;
memhandle_t handle;
};
// tags the signature of a buffer inside a rb tree for faster than linear find
struct BufferEntry_t
{
FileNameHandle_t m_hName;
memhandle_t m_hWaveData;
int m_StartPos;
bool m_bCanBeShared;
};
static bool BufferHandleLessFunc( const BufferEntry_t& lhs, const BufferEntry_t& rhs )
{
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;
memhandle_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
};
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;
memhandle_t FindOrCreateBuffer( asyncwaveparams_t ¶ms, bool bFind );
bool m_bInitialized;
bool m_bQueueCacheUnlocks;
CUtlVector<memhandle_t> m_unlockQueue;
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAsyncWavDataCache::CAsyncWavDataCache() :
m_CacheHandles( 0, 0, CacheHandleLessFunc ),
m_BufferList( 0, 0, BufferHandleLessFunc ),
m_bInitialized( false ),
m_bQueueCacheUnlocks( false )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::Init( unsigned int memSize )
{
if ( m_bInitialized )
return true;
if ( IsX360() )
{
const char *pGame = engineClient->GetGameDirectory();
if ( !Q_stricmp( Q_UnqualifiedFileName( pGame ), "tf" ) )
{
memSize = TF_XBOX_WAV_MEMORY_CACHE;
}
else
{
memSize = DEFAULT_XBOX_WAV_MEMORY_CACHE;
}
}
else
{
if ( memSize < DEFAULT_WAV_MEMORY_CACHE )
{
memSize = DEFAULT_WAV_MEMORY_CACHE;
}
}
#if FORCE_SMALL_MEMORY_CACHE_SIZE
memSize = FORCE_SMALL_MEMORY_CACHE_SIZE;
Msg( "WARNING CAsyncWavDataCache::Init() forcing small memory cache size: %u\n", memSize );
#endif
CCacheClientBaseClass::Init( g_pDataCache, "WaveData", memSize );
m_bInitialized = true;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Shutdown()
{
if ( !m_bInitialized )
{
return;
}
Clear();
CCacheClientBaseClass::Shutdown();
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 : memhandle_t
//-----------------------------------------------------------------------------
memhandle_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 = 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 = CacheCreate( params );
}
return entry.handle;
}
//-----------------------------------------------------------------------------
// Purpose: Reclaim a buffer. A reclaimed resident buffer is ready for play.
//-----------------------------------------------------------------------------
memhandle_t CAsyncWavDataCache::FindOrCreateBuffer( asyncwaveparams_t ¶ms, bool bFind )
{
CAsyncWaveData *pWaveData;
BufferEntry_t search;
BufferHandle_t hBuffer;
search.m_hName = params.hFilename;
search.m_StartPos = params.seekpos;
search.m_bCanBeShared = bFind;
search.m_hWaveData = 0;
if ( bFind )
{
// look for an existing buffer that matches exactly (same file, offset, and share)
int iBuffer = m_BufferList.Find( search );
if ( iBuffer != m_BufferList.InvalidIndex() )
{
// found
search.m_hWaveData = m_BufferList[iBuffer].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 = CacheLock( search.m_hWaveData );
if ( !pWaveData )
{
// not in cache, create and lock
// not found, create buffer and fill with data
search.m_hWaveData = CacheCreate( params, DCAF_LOCK );
// 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 = 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 )
{
VPROF( "CAsyncWavDataCache::OpenStreamedLoad" );
StreamedEntry_t streamedEntry;
StreamHandle_t hStream;
asyncwaveparams_t params;
int i;
Assert( numBuffers > 0 && numBuffers <= STREAM_BUFFER_COUNT );
// queued load mandates one buffer
Assert( !( flags & STREAMED_QUEUEDLOAD ) || numBuffers == 1 );
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 = ( IsX360() && ( flags & STREAMED_FROMDVD ) ) ? XBOX_DVD_SECTORSIZE : 1;
// 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
bool 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;
for ( i=0; i<numBuffers; ++i )
{
params.seekpos = dataStart + startPos + i * bufferSize;
streamedEntry.m_hWaveData[i] = FindOrCreateBuffer( params, bFindBuffer );
}
// get a unique handle for each stream request
hStream = m_StreamedHandles.AddToTail( streamedEntry );
Assert( hStream != m_StreamedHandles.InvalidIndex() );
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 )
{
// multiple streams could be using the same buffer, keeping the lock count nonzero
lockCount = GetCacheSection()->GetLockCount( streamedEntry.m_hWaveData[i] );
Assert( lockCount >= 1 );
if ( lockCount > 0 )
{
lockCount = CacheUnlock( streamedEntry.m_hWaveData[i] );
}
if ( streamedEntry.m_bSinglePlay )
{
// a buffering single play stream has no reason to reuse its own buffers and destroys them
Assert( lockCount == 0 );
CacheRemove( streamedEntry.m_hWaveData[i] );
}
}
m_StreamedHandles.Remove( hStream );
}
//-----------------------------------------------------------------------------
// 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( memhandle_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 = 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 = CacheCreate( params );
data = 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
CacheUnlock( handle );
return bret;
}
//-----------------------------------------------------------------------------
// Purpose: Copy from streaming buffers into target memory, never blocks.
//-----------------------------------------------------------------------------
int CAsyncWavDataCache::CopyStreamedDataIntoMemory( int hStream, void *pBuffer, int bufferSize, int copyStartPos, int bytesToCopy )
{
VPROF( "CAsyncWavDataCache::CopyStreamedDataIntoMemory" );
int actualCopied;
int count;
int i;
int which;
CAsyncWaveData *pWaveData[STREAM_BUFFER_COUNT];
CAsyncWaveData *pFront;
asyncwaveparams_t params;
int nextStartPos;
int bufferPos;
bool bEndOfFile;
int index;
bool bWaiting;
bool bCompleted;
StreamedEntry_t &streamedEntry = m_StreamedHandles[hStream];
if ( copyStartPos >= streamedEntry.m_DataStart + streamedEntry.m_DataSize )
{
// at or past end of file
return 0;
}
for ( i=0; i<streamedEntry.m_numBuffers; ++i )
{
pWaveData[i] = CacheGetNoTouch( streamedEntry.m_hWaveData[i] );
Assert( pWaveData[i] );
}
// drive the buffering
index = streamedEntry.m_Front;
bEndOfFile = 0;
actualCopied = 0;
bWaiting = false;
while ( 1 )
{
// try to satisfy from the front
pFront = pWaveData[index % streamedEntry.m_numBuffers];
bufferPos = copyStartPos - pFront->m_async.nOffset;
// cache atomic async completion signal off to avoid coherency issues
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 stariving 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;
}
DevMsg( "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 )
{
count = bytesToCopy;
if ( bufferPos + bytesToCopy > 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;
}
Q_memcpy( pBuffer, (char *)pFront->m_pvData + bufferPos, count );
// advance past consumed bytes
actualCopied += count;
copyStartPos += count;
bufferPos += count;
}
}
else if ( bCompleted && pFront->m_bMissing )
{
// notify on any error
MaybeReportMissingWav( pFront->GetFileName() );
break;
}
else
{
// data not available
bWaiting = true;
break;
}
// cycle past obsolete or consumed buffers
if ( bufferPos < 0 || bufferPos >= pFront->m_nReadSize )
{
// move to next buffer
index++;
if ( index - streamedEntry.m_Front >= streamedEntry.m_numBuffers )
{
// out of buffers
break;
}
}
if ( actualCopied == bytesToCopy )
{
// satisfied request
break;
}
}
if ( streamedEntry.m_numBuffers > 1 )
{
// restart consumed buffers
while ( streamedEntry.m_Front < index )
{
if ( !actualCopied && !bWaiting )
{
// couldn't return any data because the buffers aren't in the right location
// oh no! caller must be skipping
// due to latency the next buffer position has to start one full buffer ahead of the caller's desired read location
// hopefully only 1 buffer will stutter
nextStartPos = copyStartPos - streamedEntry.m_DataStart + streamedEntry.m_BufferSize;
// advance past, ready for next possible iteration
copyStartPos += streamedEntry.m_BufferSize;
}
else
{
// get the next forecasted 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
params.hFilename = streamedEntry.m_hName;
params.seekpos = streamedEntry.m_DataStart + nextStartPos;
params.datasize = streamedEntry.m_DataSize - nextStartPos;
params.alignment = streamedEntry.m_SectorSize;
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;
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
pWaveData[which]->StartAsyncLoading( params );
}
else
{
// release obsolete buffer to lru management
CacheUnlock( streamedEntry.m_hWaveData[which] );
// reclaim or create/load the desired buffer
streamedEntry.m_hWaveData[which] = FindOrCreateBuffer( params, true );
}
streamedEntry.m_Front++;
}
if ( 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 actualCopied;
}
}
return 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;
CAsyncWaveData *pFront;
int index;
StreamedEntry_t &streamedEntry = m_StreamedHandles[hStream];
index = streamedEntry.m_Front % streamedEntry.m_numBuffers;
pFront = 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 = 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( memhandle_t handle, bool proc )
{
CAsyncWaveData *data = CacheGet( handle );
if ( data )
{
data->SetPostProcessed( proc );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : handle -
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Unload( memhandle_t handle )
{
// Don't actually unload, just mark it as stale
if ( GetCacheSection() )
{
GetCacheSection()->Age( handle );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : handle -
// *filename -
// datasize -
// startpos -
// **pData -
// copystartpos -
// *pbPostProcessed -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::GetDataPointer( memhandle_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 = 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 = CacheCreate( params );
data = 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 )
{
if ( datasize != data->m_nDataSize )
{
// We've had issues where we are called with datasize larger than what we read on disk.
// Ie: datasize is 277,180, data->m_nDataSize is 263,168
// This can happen due to a corrupted audio cache, but it's more likely that somehow
// we wound up reading the cache data from one language and the file from another.
DevMsg( "Cached datasize != sound datasize %d - %d.\n", datasize, data->m_nDataSize );
#ifdef STAGING_ONLY
// Adding a STAGING_ONLY debugger break to try and help track this down. Hopefully we'll
// get this crash internally with full debug information instead of just minidump files.
DebuggerBreak();
#endif
}
else if ( copystartpos < data->m_nDataSize )
{
if ( data->BlockingGetDataPointer( pData ) )
{
*pData = (char *)*pData + copystartpos;
bret = true;
}
}
}
*pbPostProcessed = data->GetPostProcessed();
// Release lock at the end of mixing
QueueUnlock( handle );
return bret;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : handle -
// *filename -
// datasize -
// startpos -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAsyncWavDataCache::IsDataLoadCompleted( memhandle_t handle, bool *pIsValid )
{
VPROF( "CAsyncWavDataCache::IsDataLoadCompleted" );
CAsyncWaveData *data = CacheGet( handle );
if ( !data )
{
*pIsValid = false;
return false;
}
*pIsValid = true;
// bump the priority
data->SetAsyncPriority( 1 );
return data->m_bLoaded;
}
void CAsyncWavDataCache::RestartDataLoad( memhandle_t *pHandle, const char *pFilename, int dataSize, int startpos )
{
CAsyncWaveData *data = CacheGet( *pHandle );
if ( !data )
{
*pHandle = AsyncLoadCache( pFilename, dataSize, startpos );
}
}
bool CAsyncWavDataCache::IsDataLoadInProgress( memhandle_t handle )
{
CAsyncWaveData *data = CacheGet( handle );
if ( data )
{
return data->IsCurrentlyLoading();
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Flush()
{
GetCacheSection()->Flush();
SpewMemoryUsage( 0 );
}
void CAsyncWavDataCache::QueueUnlock( const memhandle_t &handle )
{
// not queuing right now, just unlock
if ( !m_bQueueCacheUnlocks )
{
CacheUnlock( handle );
return;
}
// queue to unlock at the end of mixing
m_unlockQueue.AddToTail( handle );
}
void CAsyncWavDataCache::OnMixBegin()
{
Assert( !m_bQueueCacheUnlocks );
m_bQueueCacheUnlocks = true;
Assert( m_unlockQueue.Count() == 0 );
}
void CAsyncWavDataCache::OnMixEnd()
{
m_bQueueCacheUnlocks = false;
// flush the unlock queue
for ( int i = 0; i < m_unlockQueue.Count(); i++ )
{
CacheUnlock( m_unlockQueue[i] );
}
m_unlockQueue.RemoveAll();
}
//-----------------------------------------------------------------------------
// 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( int level )
{
DataCacheStatus_t status;
DataCacheLimits_t limits;
GetCacheSection()->GetStatus( &status, &limits );
int bytesUsed = status.nBytes;
int bytesTotal = limits.nMaxBytes;
if ( IsPC() )
{
float 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 ( level >= 1 )
{
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;
}
memhandle_t &handle = m_CacheHandles[ i ].handle;
CAsyncWaveData *data = 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);
}
}
Msg( "CAsyncWavDataCache: %i .wavs total %s, %.2f %% of capacity\n", m_CacheHandles.Count(), Q_pretifymem( bytesUsed, 2 ), percent );
}
}
if ( IsX360() )
{
CAsyncWaveData *pData;
BufferEntry_t *pBuffer;
BufferHandle_t h;
float percent;
int lockCount;
if ( bytesTotal <= 0 )
{
// unbounded, indeterminate
percent = 0;
bytesTotal = 0;
}
else
{
percent = 100.0f*(float)bytesUsed/(float)bytesTotal;
}
if ( level >= 1 )
{
// detail buffers
ConMsg( "Streaming Buffer List:\n" );
for ( h = m_BufferList.FirstInorder(); h != m_BufferList.InvalidIndex(); h = m_BufferList.NextInorder( h ) )
{
pBuffer = &m_BufferList[h];
pData = CacheGetNoTouch( pBuffer->m_hWaveData );
lockCount = GetCacheSection()->GetLockCount( pBuffer->m_hWaveData );
CacheLockMutex();
if ( pData )
{
ConMsg( "Start:%7d Length:%7d Lock:%3d %s\n", pData->m_async.nOffset, pData->m_nDataSize, lockCount, pData->GetFileName() );
}
CacheUnlockMutex();
}
}
ConMsg( "CAsyncWavDataCache: %.2f MB used of %.2f MB, %.2f%% of capacity", (float)bytesUsed/(1024.0f*1024.0f), (float)bytesTotal/(1024.0f*1024.0f), percent );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAsyncWavDataCache::Clear()
{
for ( int i = m_CacheHandles.FirstInorder(); m_CacheHandles.IsValidIndex(i); i = m_CacheHandles.NextInorder(i) )
{
CacheEntry_t& dat = m_CacheHandles[i];
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 )
{
GetCacheSection()->BreakLock( dat.m_hWaveData[j] );
CacheRemove( dat.m_hWaveData[j] );
}
}
m_StreamedHandles.RemoveAll();
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( 1 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFileName -
// dataOffset -
// dataSize -
//-----------------------------------------------------------------------------
void PrefetchDataStream( const char *pFileName, int dataOffset, int dataSize )
{
if ( IsX360() )
{
// 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 );
~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, int sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] );
bool IsValid() { return m_bValid; }
virtual bool IsReadyToMix();
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 buffer in samples
char *m_buffer;
int m_sampleIndex;
int m_bufferCount;
int m_dataStart;
int m_dataSize;
memhandle_t m_hCache;
StreamHandle_t m_hStream;
FileNameHandle_t m_hFileName;
bool m_bValid;
CAudioSourceCachedInfoHandle_t m_AudioCacheHandle;
int m_nCachedDataSize;
CSfxTable *m_pSfx;
};
CWaveDataStreamAsync::CWaveDataStreamAsync
(
CAudioSource &source,
IWaveStreamSource *pStreamSource,
const char *pFileName,
int fileStart,
int fileSize,
CSfxTable *sfx,
int startOffset
) :
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_hFileName = g_pFileSystem->FindOrAddFileName( pFileName );
// nothing in the buffer yet
m_sampleIndex = 0;
m_bufferCount = 0;
if ( IsPC() )
{
m_buffer = new char[SINGLE_BUFFER_SIZE];
Q_memset( m_buffer, 0, SINGLE_BUFFER_SIZE );
}
m_nCachedDataSize = 0;
if ( m_dataSize <= 0 )
{
DevMsg(1, "Can't find streaming wav file: sound\\%s\n", GetFileName() );
return;
}
if ( IsPC() )
{
m_hCache = wavedatacache->AsyncLoadCache( GetFileName(), m_dataSize, m_dataStart );
// 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 ( IsX360() )
{
// size of a sample
m_sampleSize = source.SampleSize();
// size in samples (not bytes) of the wave itself
m_waveSize = fileSize / m_sampleSize;
streamFlags_t flags = STREAMED_FROMDVD;
if ( !Q_strnicmp( pFileName, "music", 5 ) && ( pFileName[5] == '\\' || pFileName[5] == '/') )
{
// music discards and cycles its buffers
flags |= STREAMED_SINGLEPLAY;
}
else if ( !Q_strnicmp( pFileName, "vo", 2 ) && ( pFileName[2] == '\\' || pFileName[2] == '/' ) && !source.IsSentenceWord() )
{
// vo discards and cycles its buffers, except for sentence sources, which do recur
flags |= STREAMED_SINGLEPLAY;
}
int bufferSize;
if ( source.Format() == WAVE_FORMAT_XMA )
{
// each xma block has its own compression rate
// the buffer must be large enough to cover worst case delivery i/o latency
// the xma mixer expects quantum xma blocks
COMPILE_TIME_ASSERT( ( STREAM_BUFFER_DATASIZE % XMA_BLOCK_SIZE ) == 0 );
bufferSize = STREAM_BUFFER_DATASIZE;
}
else
{
// calculate a worst case buffer size based on rate
bufferSize = STREAM_BUFFER_TIME*source.SampleRate()*m_sampleSize;
if ( source.Format() == WAVE_FORMAT_ADPCM )
{
// consider adpcm as 4 bit samples
bufferSize /= 2;
}
if ( source.IsLooped() )
{
// lighten the streaming load for looping samples
// doubling the buffer halves the buffer search/load requests
bufferSize *= 2;
}
}
// streaming buffers obey alignments
bufferSize = AlignValue( bufferSize, XBOX_DVD_SECTORSIZE );
// use double buffering
int numBuffers = 2;
if ( m_dataSize <= STREAM_BUFFER_DATASIZE || m_dataSize <= numBuffers*bufferSize )
{
// no gain for buffering a small file or multiple buffering
// match the expected transfer with a single buffer
bufferSize = m_dataSize;
numBuffers = 1;
}
// size in samples of the transfer buffer
m_bufferSize = bufferSize / m_sampleSize;
// allocate a transfer buffer
// matches the size of the streaming buffer exactly
// ensures that buffers can be filled and then consumed/requeued at the same time
m_buffer = new char[bufferSize];
int loopStart;
if ( source.IsLooped() )
{
int loopBlock;
loopStart = m_pStreamSource->GetLoopingInfo( &loopBlock, NULL, NULL ) * m_sampleSize;
if ( source.Format() == 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;
}
}
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, bufferSize, numBuffers, flags );
}
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 ( IsX360() )
{
wavedatacache->CloseStreamedLoad( m_hStream );
}
delete [] m_buffer;
}
//-----------------------------------------------------------------------------
// 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 );
}
return bLoaded;
}
if ( IsX360() )
{
return wavedatacache->IsStreamedDataReady( m_hStream );
}
return false;
}
//-----------------------------------------------------------------------------
// 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, int sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] )
{
// 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 )
{
// 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 greated 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 intial 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_buffer, ( 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_buffer,
sizeof( m_buffer ),
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_buffer, m_bufferCount );
}
}
}
if ( IsX360() )
{
if ( m_hStream != INVALID_STREAM_HANDLE )
{
// request available data, may get less
// drives the buffering
m_bufferCount = wavedatacache->CopyStreamedDataIntoMemory(
m_hStream,
m_buffer,
m_bufferSize * m_sampleSize,
seekpos,
m_bufferCount * m_sampleSize );
// convert to number of samples in the buffer
m_bufferCount /= m_sampleSize;
}
else
{
return 0;
}
// do any conversion now the source needs (mixer will decode/decompress) on this buffer
m_pStreamSource->UpdateSamples( m_buffer, m_bufferCount );
}
}
// If we have some samples in the buffer that are within range of the request
// Use unsigned comparisons so that if sampleIndex is somehow negative that
// will be treated as out of range.
if ( (unsigned)sampleIndex < (unsigned)m_bufferCount )
{
// Get the desired starting sample
*pData = (void *)&m_buffer[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, int sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] );
virtual bool IsReadyToMix();
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, int 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 )
{
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 ( IsX360() )
{
// expected to be resident and valid, otherwise being called prior to load
Assert( 0 );
}
return 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 )
{
CWaveDataStreamAsync *pStream = new CWaveDataStreamAsync( source, pStreamSource, pFileName, dataStart, dataSize, pSfx, startOffset );
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;
}