Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

959 lines
30 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: XMA Decoding
//
//=====================================================================================//
#include "audio_pch.h"
#include "tier1/mempool.h"
#include "circularbuffer.h"
#include "tier1/utllinkedlist.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//#define DEBUG_XMA
// Failed attempt to allow mixer to request data that is immediately discarded
// to support < 0 delay samples
//#define ALLOW_SKIP_SAMPLES
// XMA is supposed to decode at an ideal max of 512 mono samples every 4msec.
// XMA can only peel a max of 1984 stereo samples per poll request (if available).
// Max is not achievable and degrades based on quality settings, stereo, etc, but using these numbers for for calcs.
// 1984 stereo samples should be decoded by xma in 31 msec.
// 1984 stereo samples at 44.1Khz dictates a request every 45 msec.
// GetOutputData() must be clocked faster than 45 msec or samples will not be available.
// However, the XMA decoder must be serviced much faster. It was designed for 5 msec.
// 15 msec seems to be fast enough for XMA to decode enough to keep the smaller buffer sizes satisfied, and have slop for +/- 5 msec swings.
// Need at least this amount of decoded pcm samples before mixing can commence.
// This needs to be able to cover the initial mix request, while a new decode cycle is in flight.
#define MIN_READYTOMIX ( ( 2 * XMA_POLL_RATE ) * 0.001f )
// number of samples that xma decodes
// must be 128 aligned for mono (1984 is hw max for stereo)
#define XMA_MONO_OUTPUT_BUFFER_SAMPLES 2048
#define XMA_STEREO_OUTPUT_BUFFER_SAMPLES 1920
// for decoder input
// xma blocks are fetched from the datacache into one of these hw buffers for decoding
// must be in quantum units of XMA_BLOCK_SIZE
#define XMA_INPUT_BUFFER_SIZE ( 8 * XMA_BLOCK_SIZE )
// circular staging buffer to drain xma decoder and stage until mixer requests
// must be large enough to hold the slowest expected mixing frame worth of samples
#define PCM_STAGING_BUFFER_TIME 200
// xma physical heap, supplies xma input buffers for hw decoder
// each potential channel must be able to peel 2 buffers for driving xma decoder
#define XMA_PHYSICAL_HEAP_SIZE ( 2 * MAX_CHANNELS * XMA_INPUT_BUFFER_SIZE )
// in millseconds
#define MIX_IO_DATA_TIMEOUT 2000 // async i/o from dvd could be very late
#define MIX_DECODER_TIMEOUT 3000 // decoder might be very busy
#define MIX_DECODER_POLLING_LATENCY 5 // not faster than 5ms, or decoder will sputter
// diagnostic errors
#define ERROR_IO_DATA_TIMEOUT -1 // async i/o taking too long to deliver xma blocks
#define ERROR_IO_TRUNCATED_BLOCK -2 // async i/o failed to deliver complete blocks
#define ERROR_IO_NO_XMA_DATA -3 // async i/o failed to deliver any block
#define ERROR_DECODER_TIMEOUT -4 // decoder taking too long to decode xma blocks
#define ERROR_OUT_OF_MEMORY -5 // not enough physical memory for xma blocks
#define ERROR_XMA_PARSE -6 // decoder barfed on xma blocks
#define ERROR_XMA_CANTLOCK -7 // hw not acting as expected
#define ERROR_XMA_CANTSUBMIT -8 // hw not acting as expected
#define ERROR_XMA_CANTRESUME -9 // hw not acting as expected
#define ERROR_XMA_NO_PCM_DATA -10 // no xma decoded pcm data ready
#define ERROR_NULL_BUFFER -11 // logic flaw, expected buffer is null
const char *g_XMAErrorStrings[] =
{
"Unknown Error Code",
"Async I/O Data Timeout", // ERROR_IO_DATA_TIMEOUT
"Async I/O Truncated Block", // ERROR_IO_TRUNCATED_BLOCK
"Async I/O Data Not Ready", // ERROR_IO_NO_XMA_DATA
"Decoder Timeout", // ERROR_DECODER_TIMEOUT
"Out Of Memory", // ERROR_OUT_OF_MEMORY
"XMA Parse", // ERROR_XMA_PARSE
"XMA Cannot Lock", // ERROR_XMA_CANTLOCK
"XMA Cannot Submit", // ERROR_XMA_CANTSUBMIT
"XMA Cannot Resume", // ERROR_XMA_CANTRESUME
"XMA No PCM Data Ready", // ERROR_XMA_NO_PCM_DATA
"NULL Buffer", // ERROR_NULL_BUFFER
};
class CXMAAllocator
{
public:
static void *Alloc( int bytes )
{
MEM_ALLOC_CREDIT();
return XMemAlloc( bytes,
MAKE_XALLOC_ATTRIBUTES(
0,
false,
TRUE,
FALSE,
eXALLOCAllocatorId_XAUDIO,
XALLOC_PHYSICAL_ALIGNMENT_4K,
XALLOC_MEMPROTECT_WRITECOMBINE_LARGE_PAGES,
FALSE,
XALLOC_MEMTYPE_PHYSICAL ) );
}
static void Free( void *p )
{
XMemFree( p,
MAKE_XALLOC_ATTRIBUTES(
0,
false,
TRUE,
FALSE,
eXALLOCAllocatorId_XAUDIO,
XALLOC_PHYSICAL_ALIGNMENT_4K,
XALLOC_MEMPROTECT_WRITECOMBINE_LARGE_PAGES,
FALSE,
XALLOC_MEMTYPE_PHYSICAL ) );
}
};
// for XMA decoding, fixed size allocations aligned to 4K from a single physical heap
CAlignedMemPool< XMA_INPUT_BUFFER_SIZE, 4096, XMA_PHYSICAL_HEAP_SIZE, CXMAAllocator > g_XMAMemoryPool;
ConVar snd_xma_spew_warnings( "snd_xma_spew_warnings", "0" );
ConVar snd_xma_spew_startup( "snd_xma_spew_startup", "0" );
ConVar snd_xma_spew_mixers( "snd_xma_spew_mixers", "0" );
ConVar snd_xma_spew_decode( "snd_xma_spew_decode", "0" );
ConVar snd_xma_spew_drain( "snd_xma_spew_drain", "0" );
#ifdef DEBUG_XMA
ConVar snd_xma_record( "snd_xma_record", "0" );
ConVar snd_xma_spew_errors( "snd_xma_spew_errors", "0" );
#endif
//-----------------------------------------------------------------------------
// Purpose: Mixer for ADPCM encoded audio
//-----------------------------------------------------------------------------
class CAudioMixerWaveXMA : public CAudioMixerWave
{
public:
typedef CAudioMixerWave BaseClass;
CAudioMixerWaveXMA( IWaveData *data, int initialStreamPosition );
~CAudioMixerWaveXMA( void );
virtual void Mix( IAudioDevice *pDevice, channel_t *pChannel, void *pData, int outputOffset, int inputOffset, fixedint fracRate, int outCount, int timecompress );
virtual int GetOutputData( void **pData, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] );
virtual void SetSampleStart( int newPosition );
virtual int GetPositionForSave();
virtual void SetPositionFromSaved( int savedPosition );
virtual int GetMixSampleSize() { return CalcSampleSize( 16, m_NumChannels ); }
virtual bool IsReadyToMix();
virtual bool ShouldContinueMixing();
private:
int GetXMABlocksAndSubmitToDecoder( bool bDecoderLocked );
int UpdatePositionForLooping( int *pNumRequestedSamples );
int ServiceXMADecoder( bool bForceUpdate );
int GetPCMSamples( int numRequested, char *pData );
XMAPLAYBACK *m_pXMAPlayback;
// input buffers, encoded xma
byte *m_pXMABuffers[2];
int m_XMABufferIndex;
// output buffer, decoded pcm samples, a staging circular buffer, waiting for mixer requests
// due to staging nature, contains decoded samples from multiple input buffers
CCircularBuffer *m_pPCMSamples;
int m_SampleRate;
int m_NumChannels;
// maximum possible decoded samples
int m_SampleCount;
// decoded sample position
int m_SamplePosition;
// current data marker
int m_LastDataOffset;
int m_DataOffset;
// total bytes of data
int m_TotalBytes;
#if defined( ALLOW_SKIP_SAMPLES )
// number of samples to throwaway
int m_SkipSamples;
#endif
// timers
unsigned int m_StartTime;
unsigned int m_LastDrainTime;
unsigned int m_LastPollTime;
int m_hMixerList;
int m_Error;
unsigned int m_bStartedMixing : 1;
unsigned int m_bFinished : 1;
unsigned int m_bLooped : 1;
};
CUtlFixedLinkedList< CAudioMixerWaveXMA * > g_XMAMixerList;
CON_COMMAND( snd_xma_info, "Spew XMA Info" )
{
Msg( "XMA Memory:\n" );
Msg( " Blocks Allocated: %d\n", g_XMAMemoryPool.NumAllocated() );
Msg( " Blocks Free: %d\n", g_XMAMemoryPool.NumFree() );
Msg( " Total Bytes: %d\n", g_XMAMemoryPool.BytesTotal() );
Msg( "Active XMA Mixers: %d\n", g_XMAMixerList.Count() );
for ( int hMixer = g_XMAMixerList.Head(); hMixer != g_XMAMixerList.InvalidIndex(); hMixer = g_XMAMixerList.Next( hMixer ) )
{
CAudioMixerWaveXMA *pXMAMixer = g_XMAMixerList[hMixer];
Msg( " rate:%5d ch:%1d '%s'\n", pXMAMixer->GetSource()->SampleRate(), pXMAMixer->GetSource()->IsStereoWav() ? 2 : 1, pXMAMixer->GetSource()->GetFileName() );
}
}
CAudioMixerWaveXMA::CAudioMixerWaveXMA( IWaveData *data, int initialStreamPosition ) : CAudioMixerWave( data )
{
Assert( dynamic_cast<CAudioSourceWave *>(&m_pData->Source()) != NULL );
m_Error = 0;
m_NumChannels = m_pData->Source().IsStereoWav() ? 2 : 1;
m_SampleRate = m_pData->Source().SampleRate();
m_bLooped = m_pData->Source().IsLooped();
m_SampleCount = m_pData->Source().SampleCount();
m_TotalBytes = m_pData->Source().DataSize();
#if defined( ALLOW_SKIP_SAMPLES )
m_SkipSamples = 0;
#endif
m_LastDataOffset = initialStreamPosition;
m_DataOffset = initialStreamPosition;
m_SamplePosition = 0;
if ( initialStreamPosition )
{
m_SamplePosition = m_pData->Source().StreamToSamplePosition( initialStreamPosition );
CAudioMixerWave::m_sample_loaded_index = m_SamplePosition;
CAudioMixerWave::m_sample_max_loaded = m_SamplePosition + 1;
}
m_bStartedMixing = false;
m_bFinished = false;
m_StartTime = 0;
m_LastPollTime = 0;
m_LastDrainTime = 0;
m_pXMAPlayback = NULL;
m_pPCMSamples = NULL;
m_pXMABuffers[0] = NULL;
m_pXMABuffers[1] = NULL;
m_XMABufferIndex = 0;
m_hMixerList = g_XMAMixerList.AddToTail( this );
#ifdef DEBUG_XMA
if ( snd_xma_record.GetBool() )
{
WaveCreateTmpFile( "debug.wav", m_SampleRate, 16, m_NumChannels );
}
#endif
if ( snd_xma_spew_mixers.GetBool() )
{
Msg( "XMA: 0x%8.8x (%2d), Mixer Alloc, '%s'\n", (unsigned int)this, g_XMAMixerList.Count(), m_pData->Source().GetFileName() );
}
}
CAudioMixerWaveXMA::~CAudioMixerWaveXMA( void )
{
if ( m_pXMAPlayback )
{
XMAPlaybackDestroy( m_pXMAPlayback );
g_XMAMemoryPool.Free( m_pXMABuffers[0] );
if ( m_pXMABuffers[1] )
{
g_XMAMemoryPool.Free( m_pXMABuffers[1] );
}
}
if ( m_pPCMSamples )
{
FreeCircularBuffer( m_pPCMSamples );
}
g_XMAMixerList.Remove( m_hMixerList );
if ( snd_xma_spew_mixers.GetBool() )
{
Msg( "XMA: 0x%8.8x (%2d), Mixer Freed, '%s'\n", (unsigned int)this, g_XMAMixerList.Count(), m_pData->Source().GetFileName() );
}
}
void CAudioMixerWaveXMA::Mix( IAudioDevice *pDevice, channel_t *pChannel, void *pData, int outputOffset, int inputOffset, fixedint fracRate, int outCount, int timecompress )
{
if ( m_NumChannels == 1 )
{
pDevice->Mix16Mono( pChannel, (short *)pData, outputOffset, inputOffset, fracRate, outCount, timecompress );
}
else
{
pDevice->Mix16Stereo( pChannel, (short *)pData, outputOffset, inputOffset, fracRate, outCount, timecompress );
}
}
//-----------------------------------------------------------------------------
// Looping is achieved in two passes to provide a circular view of the linear data.
// Pass1: Clamps a sample request to the end of data.
// Pass2: Snaps to the loop start, and returns the number of samples to discard, could be 0,
// up to the expected loop sample position.
// Returns the number of samples to discard, or 0.
//-----------------------------------------------------------------------------
int CAudioMixerWaveXMA::UpdatePositionForLooping( int *pNumRequestedSamples )
{
if ( !m_bLooped )
{
// not looping, no fixups
return 0;
}
int numLeadingSamples;
int numTrailingSamples;
CAudioSourceWave &source = reinterpret_cast<CAudioSourceWave &>(m_pData->Source());
int loopSampleStart = source.GetLoopingInfo( NULL, &numLeadingSamples, &numTrailingSamples );
int numRemainingSamples = ( m_SampleCount - numTrailingSamples ) - m_SamplePosition;
// possibly straddling the end of data (and thus about to loop)
// want to split the straddle into two regions, due to loops possibly requiring a trailer and leader of discarded samples
if ( numRemainingSamples > 0 )
{
// first region, all the remaining samples, clamped until end of desired data
*pNumRequestedSamples = min( *pNumRequestedSamples, numRemainingSamples );
// nothing to discard
return 0;
}
else if ( numRemainingSamples == 0 )
{
// at exact end of desired data, snap the sample position back
// the position will be correct AFTER discarding decoded trailing and leading samples
m_SamplePosition = loopSampleStart;
// clamp the request
numRemainingSamples = ( m_SampleCount - numTrailingSamples ) - m_SamplePosition;
*pNumRequestedSamples = min( *pNumRequestedSamples, numRemainingSamples );
// flush these samples so the sample position is the real loop sample starting position
return numTrailingSamples + numLeadingSamples;
}
return 0;
}
//-----------------------------------------------------------------------------
// Get and submit XMA block(s). The decoder must stay blocks ahead of mixer
// so the decoded samples are available for peeling.
// An XMA file is thus treated as a series of fixed size large buffers (multiple xma blocks),
// which are streamed in sequentially. The XMA buffers may be delayed from the
// audio data cache due to async i/o latency.
// Returns < 0 if error, 0 if no decode started, 1 if decode submitted.
//-----------------------------------------------------------------------------
int CAudioMixerWaveXMA::GetXMABlocksAndSubmitToDecoder( bool bDecoderIsLocked )
{
int status = 0;
if ( m_DataOffset >= m_TotalBytes )
{
if ( !m_bLooped )
{
// end of file, no more data to decode
// not an error, because decoder finishes long before samples drained
return 0;
}
// start from beginning of loop
CAudioSourceWave &source = reinterpret_cast<CAudioSourceWave &>(m_pData->Source());
source.GetLoopingInfo( &m_DataOffset, NULL, NULL );
m_DataOffset *= XMA_BLOCK_SIZE;
}
HRESULT hr;
bool bLocked = false;
if ( !bDecoderIsLocked )
{
// decoder must be locked before any access
hr = XMAPlaybackRequestModifyLock( m_pXMAPlayback );
if ( FAILED( hr ) )
{
status = ERROR_XMA_CANTLOCK;
goto cleanUp;
}
hr = XMAPlaybackWaitUntilModifyLockObtained( m_pXMAPlayback );
if ( FAILED( hr ) )
{
status = ERROR_XMA_CANTLOCK;
goto cleanUp;
}
bLocked = true;
}
// the input buffer can never be less than a single xma block (buffer size is multiple blocks)
int bufferSize = min( m_TotalBytes - m_DataOffset, XMA_INPUT_BUFFER_SIZE );
if ( !bufferSize )
{
// EOF
goto cleanUp;
}
Assert( !( bufferSize % XMA_BLOCK_SIZE ) );
byte *pXMABuffer = m_pXMABuffers[m_XMABufferIndex & 0x01];
if ( !pXMABuffer )
{
// shouldn't happen, buffer should have been allocated
Assert( 0 );
status = ERROR_NULL_BUFFER;
goto cleanUp;
}
if ( !XMAPlaybackQueryReadyForMoreData( m_pXMAPlayback, 0 ) || XMAPlaybackQueryInputDataPending( m_pXMAPlayback, 0, pXMABuffer ) )
{
// decoder too saturated for more data or
// decoder still decoding from input hw buffer
goto cleanUp;
}
// get xma block(s)
// pump to get all of requested data
char *pData;
int total = 0;
while ( total < bufferSize )
{
int available = m_pData->ReadSourceData( (void **)&pData, m_DataOffset, bufferSize - total, NULL );
if ( !available )
break;
// aggregate into hw buffer
V_memcpy( pXMABuffer + total, pData, available );
m_DataOffset += available;
total += available;
}
if ( total != bufferSize )
{
if ( !total )
{
// failed to get any data, could be async latency or file error
status = ERROR_IO_NO_XMA_DATA;
}
else
{
// failed to get complete xma block(s)
status = ERROR_IO_TRUNCATED_BLOCK;
}
goto cleanUp;
}
// track the currently submitted offset
// this is used as a cheap method for save/restore because an XMA seek table is not available
m_LastDataOffset = m_DataOffset - total;
// start decoding the block(s) in the hw buffer
hr = XMAPlaybackSubmitData( m_pXMAPlayback, 0, pXMABuffer, bufferSize );
if ( FAILED( hr ) )
{
// failed to start decoder
status = ERROR_XMA_CANTSUBMIT;
goto cleanUp;
}
// decode submitted
status = 1;
// advance to next buffer
m_XMABufferIndex++;
if ( snd_xma_spew_decode.GetBool() )
{
Msg( "XMA: 0x%8.8x, XMABuffer: 0x%8.8x, BufferSize: %d, NextDataOffset: %d, %s\n", (unsigned int)this, pXMABuffer, bufferSize, m_DataOffset, m_pData->Source().GetFileName() );
}
cleanUp:
if ( bLocked )
{
// release the lock and let the decoder run
hr = XMAPlaybackResumePlayback( m_pXMAPlayback );
if ( FAILED( hr ) )
{
status = ERROR_XMA_CANTRESUME;
}
}
return status;
}
//-----------------------------------------------------------------------------
// Drain the XMA Decoder into the staging circular buffer of PCM for mixer.
// Fetch new XMA samples for the decoder.
//-----------------------------------------------------------------------------
int CAudioMixerWaveXMA::ServiceXMADecoder( bool bForceUpdate )
{
// allow decoder to work without being polled (lock causes a decoding stall)
// decoder must be allowed minimum operating latency
// the buffers are sized to compensate for the operating latency
if ( !bForceUpdate && ( Plat_MSTime() - m_LastPollTime <= MIX_DECODER_POLLING_LATENCY ) )
{
return 0;
}
m_LastPollTime = Plat_MSTime();
// lock and pause the decoder to gain access
HRESULT hr = XMAPlaybackRequestModifyLock( m_pXMAPlayback );
if ( FAILED( hr ) )
{
m_Error = ERROR_XMA_CANTLOCK;
return -1;
}
hr = XMAPlaybackWaitUntilModifyLockObtained( m_pXMAPlayback );
if ( FAILED( hr ) )
{
m_Error = ERROR_XMA_CANTLOCK;
return -1;
}
DWORD dwParseError = XMAPlaybackGetParseError( m_pXMAPlayback, 0 );
if ( dwParseError )
{
if ( snd_xma_spew_warnings.GetBool() )
{
Warning( "XMA: 0x%8.8x, Decoder Error, Parse: %d, '%s'\n", (unsigned int)this, dwParseError, m_pData->Source().GetFileName() );
}
m_Error = ERROR_XMA_PARSE;
return -1;
}
#ifdef DEBUG_XMA
if ( snd_xma_spew_errors.GetBool() )
{
DWORD dwError = XMAPlaybackGetErrorBits( m_pXMAPlayback, 0 );
if ( dwError )
{
Warning( "XMA: 0x%8.8x, Playback Error: %d, '%s'\n", (unsigned int)this, dwError, m_pData->Source().GetFileName() );
}
}
#endif
int numNewSamples = XMAPlaybackQueryAvailableData( m_pXMAPlayback, 0 );
int numMaxSamples = m_pPCMSamples->GetWriteAvailable()/( m_NumChannels*sizeof( short ) );
int numSamples = min( numNewSamples, numMaxSamples );
while ( numSamples )
{
char *pPCMData = NULL;
int numSamplesDecoded = XMAPlaybackConsumeDecodedData( m_pXMAPlayback, 0, numSamples, (void**)&pPCMData );
// put into staging buffer, ready for mixer to drain
m_pPCMSamples->Write( pPCMData, numSamplesDecoded*m_NumChannels*sizeof( short ) );
numSamples -= numSamplesDecoded;
numNewSamples -= numSamplesDecoded;
}
// queue up more blocks for the decoder
// the decoder will always finish ahead of the mixer, submit nothing, and the mixer will still be draining
int decodeStatus = GetXMABlocksAndSubmitToDecoder( true );
if ( decodeStatus < 0 )
{
m_Error = decodeStatus;
return -1;
}
m_bFinished = ( numNewSamples == 0 ) && ( decodeStatus == 0 ) && XMAPlaybackIsIdle( m_pXMAPlayback, 0 );
// decoder was paused for access, let the decoder run
hr = XMAPlaybackResumePlayback( m_pXMAPlayback );
if ( FAILED( hr ) )
{
m_Error = ERROR_XMA_CANTRESUME;
return -1;
}
return 1;
}
//-----------------------------------------------------------------------------
// Drain the PCM staging buffer.
// Copy samples (numSamplesToCopy && pData). Return actual copied.
// Flush Samples (numSamplesToCopy && !pData). Return actual flushed.
// Query available number of samples (!numSamplesToCopy && !pData). Returns available.
//-----------------------------------------------------------------------------
int CAudioMixerWaveXMA::GetPCMSamples( int numSamplesToCopy, char *pData )
{
int numReadySamples = m_pPCMSamples->GetReadAvailable()/( m_NumChannels*sizeof( short ) );
// peel sequential samples from the stream's staging buffer
int numCopiedSamples = 0;
int numRequestedSamples = min( numSamplesToCopy, numReadySamples );
if ( numRequestedSamples )
{
if ( pData )
{
// copy to caller
m_pPCMSamples->Read( pData, numRequestedSamples*m_NumChannels*sizeof( short ) );
pData += numRequestedSamples*m_NumChannels*sizeof( short );
}
else
{
// flush
m_pPCMSamples->Advance( numRequestedSamples*m_NumChannels*sizeof( short ) );
}
numCopiedSamples += numRequestedSamples;
}
if ( snd_xma_spew_drain.GetBool() )
{
char *pOperation = ( numSamplesToCopy && !pData ) ? "Flushed" : "Copied";
Msg( "XMA: 0x%8.8x, SamplePosition: %d, Ready: %d, Requested: %d, %s: %d, Elapsed: %d ms '%s'\n",
(unsigned int)this, m_SamplePosition, numReadySamples, numSamplesToCopy, pOperation, numCopiedSamples, Plat_MSTime() - m_LastDrainTime, m_pData->Source().GetFileName() );
}
m_LastDrainTime = Plat_MSTime();
if ( numSamplesToCopy )
{
// could be actual flushed or actual copied
return numCopiedSamples;
}
if ( !pData )
{
// satify query for available
return numReadySamples;
}
return 0;
}
//-----------------------------------------------------------------------------
// Stall mixing until initial buffer of decoded samples are available.
//-----------------------------------------------------------------------------
bool CAudioMixerWaveXMA::IsReadyToMix()
{
// XMA mixing cannot be driven from the main thread
Assert( ThreadInMainThread() == false );
if ( m_Error )
{
// error has been set
// let mixer try to get unavailable samples, which casues the real abort
return true;
}
if ( m_bStartedMixing )
{
// decoding process has started
return true;
}
if ( !m_pXMAPlayback )
{
// first time, finish setup
int numBuffers;
if ( m_bLooped || m_TotalBytes > XMA_INPUT_BUFFER_SIZE )
{
// data will cascade through multiple buffers
numBuffers = 2;
}
else
{
// data can fit into a single buffer
numBuffers = 1;
}
// xma data must be decoded from a hw friendly buffer
// pool should have buffers available
if ( g_XMAMemoryPool.BytesAllocated() != numBuffers * g_XMAMemoryPool.ChunkSize() )
{
for ( int i = 0; i < numBuffers; i++ )
{
m_pXMABuffers[i] = (byte*)g_XMAMemoryPool.Alloc();
}
XMA_PLAYBACK_INIT xmaPlaybackInit = { 0 };
xmaPlaybackInit.sampleRate = m_SampleRate;
xmaPlaybackInit.channelCount = m_NumChannels;
xmaPlaybackInit.subframesToDecode = 4;
xmaPlaybackInit.outputBufferSizeInSamples = ( m_NumChannels == 2 ) ? XMA_STEREO_OUTPUT_BUFFER_SAMPLES : XMA_MONO_OUTPUT_BUFFER_SAMPLES;
XMAPlaybackCreate( 1, &xmaPlaybackInit, 0, &m_pXMAPlayback );
int stagingSize = PCM_STAGING_BUFFER_TIME * m_SampleRate * m_NumChannels * sizeof( short ) * 0.001f;
m_pPCMSamples = AllocateCircularBuffer( AlignValue( stagingSize, 4 ) );
}
else
{
// too many sounds playing, no xma buffers free
m_Error = ERROR_OUT_OF_MEMORY;
return true;
}
m_StartTime = Plat_MSTime();
}
// waiting for samples
// allow decoder to work without being polled (lock causes a decoding stall)
if ( Plat_MSTime() - m_LastPollTime <= MIX_DECODER_POLLING_LATENCY )
{
return false;
}
m_LastPollTime = Plat_MSTime();
// must have buffers in flight before mixing can begin
if ( m_DataOffset == m_LastDataOffset )
{
// keep trying to get data, async i/o has some allowable latency
int decodeStatus = GetXMABlocksAndSubmitToDecoder( false );
if ( decodeStatus < 0 && decodeStatus != ERROR_IO_NO_XMA_DATA )
{
m_Error = decodeStatus;
return true;
}
else if ( !decodeStatus || decodeStatus == ERROR_IO_NO_XMA_DATA )
{
// async streaming latency could be to blame, check watchdog
if ( Plat_MSTime() - m_StartTime >= MIX_IO_DATA_TIMEOUT )
{
m_Error = ERROR_IO_DATA_TIMEOUT;
}
return false;
}
}
// get the available samples ready for immediate mixing
if ( ServiceXMADecoder( true ) < 0 )
{
return true;
}
// can't mix until we have a minimum threshold of data or the decoder is finished
int minSamplesNeeded = m_bFinished ? 0 : MIN_READYTOMIX * m_SampleRate;
#if defined( ALLOW_SKIP_SAMPLES )
minSamplesNeeded += m_bFinished ? 0 : m_SkipSamples;
#endif
int numReadySamples = GetPCMSamples( 0, NULL );
if ( numReadySamples > minSamplesNeeded )
{
// decoder has samples ready for draining
m_bStartedMixing = true;
if ( snd_xma_spew_startup.GetBool() )
{
Msg( "XMA: 0x%8.8x, Startup Latency: %d ms, Samples Ready: %d, '%s'\n", (unsigned int)this, Plat_MSTime() - m_StartTime, numReadySamples, m_pData->Source().GetFileName() );
}
return true;
}
if ( Plat_MSTime() - m_StartTime >= MIX_DECODER_TIMEOUT )
{
m_Error = ERROR_DECODER_TIMEOUT;
}
// on startup error, let mixer start and get unavailable samples, and abort
// otherwise hold off mixing until samples arrive
return ( m_Error != 0 );
}
//-----------------------------------------------------------------------------
// Returns true to mix, false to stop mixer completely. Called after
// mixer requests samples.
//-----------------------------------------------------------------------------
bool CAudioMixerWaveXMA::ShouldContinueMixing()
{
if ( !IsRetail() && m_Error && snd_xma_spew_warnings.GetBool() )
{
const char *pErrorString;
if ( m_Error < 0 && -m_Error < ARRAYSIZE( g_XMAErrorStrings ) )
{
pErrorString = g_XMAErrorStrings[-m_Error];
}
else
{
pErrorString = g_XMAErrorStrings[0];
}
Warning( "XMA: 0x%8.8x, Mixer Aborted: %s, SamplePosition: %d/%d, DataOffset: %d/%d, '%s'\n",
(unsigned int)this, pErrorString, m_SamplePosition, m_SampleCount, m_DataOffset, m_TotalBytes, m_pData->Source().GetFileName() );
}
// an error condition is fatal to mixer
return ( m_Error == 0 && BaseClass::ShouldContinueMixing() );
}
//-----------------------------------------------------------------------------
// Read existing buffer or decompress a new block when necessary.
// If no samples can be fetched, returns 0, which hints the mixer to a pending shutdown state.
// This routines operates in large buffer quantums, and nothing smaller.
// XMA decode performance severly degrades if the lock is too frequent.
//-----------------------------------------------------------------------------
int CAudioMixerWaveXMA::GetOutputData( void **pData, int numSamplesToCopy, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] )
{
if ( m_Error )
{
// mixer will eventually shutdown
return 0;
}
if ( !m_bStartedMixing )
{
#if defined( ALLOW_SKIP_SAMPLES )
int numMaxSamples = AUDIOSOURCE_COPYBUF_SIZE/( m_NumChannels * sizeof( short ) );
numSamplesToCopy = min( numSamplesToCopy, numMaxSamples );
m_SkipSamples += numSamplesToCopy;
// caller requesting data before mixing has commenced
V_memset( copyBuf, 0, numSamplesToCopy );
*pData = (void*)copyBuf;
return numSamplesToCopy;
#else
// not allowed, GetOutputData() should only be called by the mixing loop
Assert( 0 );
return 0;
#endif
}
// XMA mixing cannot be driven from the main thread
Assert( ThreadInMainThread() == false );
// needs to be clocked at regular intervals
if ( ServiceXMADecoder( false ) < 0 )
{
return 0;
}
#if defined( ALLOW_SKIP_SAMPLES )
if ( m_SkipSamples > 0 )
{
// flush whatever is available
// ignore
m_SkipSamples -= GetPCMSamples( m_SkipSamples, NULL );
if ( m_SkipSamples != 0 )
{
// not enough decoded data ready to flush
// must flush these samples to maintain proper position
m_Error = ERROR_XMA_NO_PCM_DATA;
return 0;
}
}
#endif
// loopback may require flushing some decoded samples
int numRequestedSamples = numSamplesToCopy;
int numDiscardSamples = UpdatePositionForLooping( &numRequestedSamples );
if ( numDiscardSamples > 0 )
{
// loopback requires discarding samples to converge to expected looppoint
numDiscardSamples -= GetPCMSamples( numDiscardSamples, NULL );
if ( numDiscardSamples != 0 )
{
// not enough decoded data ready to flush
// must flush these samples to achieve looping
m_Error = ERROR_XMA_NO_PCM_DATA;
return 0;
}
}
// can only drain as much as can be copied to caller
int numMaxSamples = AUDIOSOURCE_COPYBUF_SIZE/( m_NumChannels * sizeof( short ) );
numRequestedSamples = min( numRequestedSamples, numMaxSamples );
int numCopiedSamples = GetPCMSamples( numRequestedSamples, copyBuf );
if ( numCopiedSamples )
{
CAudioMixerWave::m_sample_max_loaded += numCopiedSamples;
CAudioMixerWave::m_sample_loaded_index += numCopiedSamples;
// advance position by valid samples
m_SamplePosition += numCopiedSamples;
*pData = (void*)copyBuf;
#ifdef DEBUG_XMA
if ( snd_xma_record.GetBool() )
{
WaveAppendTmpFile( "debug.wav", copyBuf, 16, numCopiedSamples * m_NumChannels );
WaveFixupTmpFile( "debug.wav" );
}
#endif
}
else
{
// no samples copied
if ( !m_bFinished && numRequestedSamples )
{
// XMA latency error occurs when decoder not finished (not at EOF) and caller wanted samples but can't get any
if ( snd_xma_spew_warnings.GetInt() )
{
Warning( "XMA: 0x%8.8x, No Decoded Data Ready: %d samples needed, '%s'\n", (unsigned int)this, numSamplesToCopy, m_pData->Source().GetFileName() );
}
m_Error = ERROR_XMA_NO_PCM_DATA;
}
}
return numCopiedSamples;
}
//-----------------------------------------------------------------------------
// Purpose: Seek to a new position in the file
// NOTE: In most cases, only call this once, and call it before playing
// any data.
// Input : newPosition - new position in the sample clocks of this sample
//-----------------------------------------------------------------------------
void CAudioMixerWaveXMA::SetSampleStart( int newPosition )
{
// cannot support this
// this should be unused and thus not supporting
Assert( 0 );
}
int CAudioMixerWaveXMA::GetPositionForSave()
{
if ( m_bLooped )
{
// A looped sample cannot be saved/restored because the decoded sample position,
// which is needed for loop calc, cannot ever be correctly restored without
// the XMA seek table.
return 0;
}
// This is silly and totally wrong, but doing it anyways.
// The correct thing was to have the XMA seek table and use
// that to determine the correct packet. This is just a hopeful
// nearby approximation. Music did not have the seek table at
// the time of this code. The Seek table was added for vo
// restoration later.
return m_LastDataOffset;
}
void CAudioMixerWaveXMA::SetPositionFromSaved( int savedPosition )
{
// Not used here. The Mixer creation will be given the initial startup offset.
}
//-----------------------------------------------------------------------------
// Purpose: Abstract factory function for XMA mixers
//-----------------------------------------------------------------------------
CAudioMixer *CreateXMAMixer( IWaveData *data, int initialStreamPosition )
{
return new CAudioMixerWaveXMA( data, initialStreamPosition );
}