tf2/tf2_src/engine/audio/private/snd_dev_common.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Device Common Base Class.
//
//=====================================================================================//

#include "audio_pch.h"

#define ISPEAKER_RIGHT_FRONT	0
#define ISPEAKER_LEFT_FRONT		1
#define ISPEAKER_RIGHT_REAR		2
#define ISPEAKER_LEFT_REAR		3
#define ISPEAKER_CENTER_FRONT	4

extern Vector		listener_right;

extern void DEBUG_StartSoundMeasure(int type, int samplecount );
extern void DEBUG_StopSoundMeasure(int type, int samplecount );
extern bool MIX_ScaleChannelVolume( paintbuffer_t *pPaint, channel_t *pChannel, int volume[CCHANVOLUMES], int mixchans );

inline bool FVolumeFrontNonZero( int *pvol )
{
	return (pvol[IFRONT_RIGHT] || pvol[IFRONT_LEFT]);
}

inline bool FVolumeRearNonZero( int *pvol )
{
	return (pvol[IREAR_RIGHT] || pvol[IREAR_LEFT]);
}

inline bool FVolumeCenterNonZero( int *pvol )
{
	return (pvol[IFRONT_CENTER] != 0);
}

// fade speaker volumes to mono, based on xfade value.
// ie: xfade 1.0 is full mono.
// ispeaker is speaker index, cspeaker is total # of speakers
// fmix2channels causes mono mix for 4 channel mix to mix down to 2 channels
//    this is used for the 2 speaker outpu case, which uses recombined 4 channel front/rear mixing

static float XfadeSpeakerVolToMono( float scale, float xfade, float ispeaker, float cspeaker, bool fmix2channels )
{
	float scale_out;
	float scale_target;

	if (cspeaker == 4 )
	{
		// mono sound distribution:
		float scale_targets[]    = {0.9, 0.9, 0.9, 0.9};	// RF, LF, RR, LR
		float scale_targets2ch[] = {0.9, 0.9, 0.0, 0.0};	// RF, LF, RR, LR

		if ( fmix2channels )
			scale_target = scale_targets2ch[clamp(FastFloatToSmallInt(ispeaker), 0, 3)];
		else
			scale_target = scale_targets[clamp(FastFloatToSmallInt(ispeaker), 0, 3)];

		goto XfadeExit;
	}

	if (cspeaker == 5 )
	{
		// mono sound distribution:
		float scale_targets[] = {0.9, 0.9, 0.5, 0.5, 0.9};	// RF, LF, RR, LR, FC
		scale_target = scale_targets[(int)clamp(FastFloatToSmallInt(ispeaker), 0, 4)];
		goto XfadeExit;
	}

	// if (cspeaker == 2 )
	scale_target = 0.9; // front 2 speakers in stereo each get 50% of total volume in mono case
	
XfadeExit:
	scale_out = scale + (scale_target - scale) * xfade;
	return scale_out;
}

// given:
//  2d yaw angle to sound source (0-360), where 0 is listener_right
//  pitch angle to source
//  angle to speaker position (0-360), where 0 is listener_right
//  speaker index
//  speaker total count,
// return: scale from 0-1.0 for speaker volume.
// NOTE: as pitch angle goes to +/- 90, sound goes to mono, all speakers.

#define PITCH_ANGLE_THRESHOLD	45.0
#define REAR_VOL_DROP			0.5
#define VOLCURVEPOWER			1.5		// 1.0 is a linear crossfade of volume between speakers.
										// 1.5 provides a smoother, nonlinear volume transition - this is done
										// because a volume of 255 played in a single speaker is
										// percieved as louder than 128 + 128 in two speakers
										// separated by at least 45 degrees.  The nonlinear curve
										// gives the volume boost needed.

static float GetSpeakerVol( float yaw_source, float pitch_source, float mono, float yaw_speaker, int ispeaker, int cspeaker, bool fmix2channels )
{
	float adif = fabs(yaw_source - yaw_speaker);
	float pitch_angle = pitch_source;
	float scale = 0.0; 
	float xfade = 0.0;

	if ( adif > 180 )
		adif = 360 - adif;

	// mono goes from 0.0 to 1.0 as listener moves into 'mono' radius of sound source.
	// Also, as pitch_angle to sound source approaches 90 (sound above/below listener), sounds become mono.
	
	// convert pitch angle to 0-90 absolute pitch
	if ( pitch_angle < 0)
		pitch_angle += 360;

	if ( pitch_angle > 180)
		pitch_angle = 360 - pitch_angle;
	
	if ( pitch_angle > 90)
		pitch_angle = 90 - (pitch_angle - 90);
		
	// calculate additional mono crossfade due to pitch angle
	if ( pitch_angle > PITCH_ANGLE_THRESHOLD )	
	{
		xfade  = ( pitch_angle - PITCH_ANGLE_THRESHOLD ) / ( 90.0 - PITCH_ANGLE_THRESHOLD );	// 0.0 -> 1.0 as angle 45->90	

		mono += xfade;
		mono = clamp(mono, 0.0f, 1.0f);
	}
	
	if ( cspeaker == 2 )
	{
		// 2 speaker (headphone) mix: speakers opposing, at 0 & 180 degrees

		scale = (1.0 - powf(adif/180.0, VOLCURVEPOWER));

		goto GetVolExit;
	}
	
	if ( adif >= 90.0 )
		goto GetVolExit;	// 0.0 scale
	
	if ( cspeaker == 4 )
	{
		// 4 ch surround: all speakers on 90 degree angles, 
		// scale ranges from 0.0 (at 90 degree difference between source and speaker)
		// to 1.0 (0 degree difference between source and speaker)

		scale = (1.0 - powf(adif/90.0, VOLCURVEPOWER));
	
		goto GetVolExit;
	}

	// 5 ch surround: 

	// rear speakers are on 90 degree angles and return 0.0->1.0 range over +/- 90 degrees each
	// center speaker is on 45 degree angle to left/right front speaker
	// center speaker has 0.0->1.0 range over 45 degrees

	switch (ispeaker)
	{
	default:
 	case ISPEAKER_RIGHT_REAR:
	case ISPEAKER_LEFT_REAR:
		{
			// rear speakers get +/- 90 degrees of linear scaling...
			scale = (1.0 - powf(adif/90.0, VOLCURVEPOWER));
			break;
		}

	case ISPEAKER_CENTER_FRONT:
		{
			// center speaker gets +/- 45 degrees of linear scaling...
			if (adif > 45.0)
				goto GetVolExit;	// 0.0 scale

			scale = (1.0 - powf(adif/45.0, VOLCURVEPOWER));
			break;
		}
	case ISPEAKER_RIGHT_FRONT:
		{
			if (yaw_source > yaw_speaker)
			{
				// if sound source is between right front speaker and center speaker, 
				// apply scaling over 75 degrees...

					if (adif > 75.0)
						goto GetVolExit;	// 0.0 scale

					scale = (1.0 - powf(adif/75.0, VOLCURVEPOWER));
			}
/*
			if (yaw_source > yaw_speaker && yaw_source < (yaw_speaker + 90.0))
			{
				// if sound source is between right front speaker and center speaker, 
				// apply scaling over 45 degrees...
				if (adif > 45.0)
					goto GetVolExit;	// 0.0 scale

					scale = (1.0 - powf(adif/45.0, VOLCURVEPOWER));
			}
*/
			else
			{
				// sound source is CW from right speaker, apply scaling over 90 degrees...
				scale = (1.0 - powf(adif/90.0, VOLCURVEPOWER));
			}

			break;
		}

	case ISPEAKER_LEFT_FRONT:
		{
			if (yaw_source < yaw_speaker )
			{
				// if sound source is between left front speaker and center speaker, 
				// apply scaling over 75 degrees...

				if (adif > 75.0)
					goto GetVolExit;	// 0.0 scale

				scale = (1.0 - powf(adif/75.0, VOLCURVEPOWER));

			}
/*
			if (yaw_source < yaw_speaker && yaw_source > (yaw_speaker - 90.0))
			{
				// if sound source is between left front speaker and center speaker, 
				// apply scaling over 45 degrees...
				if (adif > 45.0)
					goto GetVolExit;	// 0.0 scale

				scale = (1.0 - powf(adif/45.0, VOLCURVEPOWER));

			}
*/
			else
			{
				// sound source is CW from right speaker, apply scaling over 90 degrees...
				scale = (1.0 - powf(adif/90.0, VOLCURVEPOWER));
			}
			break;
		}
	}

GetVolExit:
	Assert(mono <= 1.0 && mono >= 0.0);
	Assert(scale <= 1.0 && scale >= 0.0);
	
	// crossfade speaker volumes towards mono with increased pitch angle of sound source

	scale = XfadeSpeakerVolToMono( scale, mono, ispeaker, cspeaker, fmix2channels ); 

	Assert(scale <= 1.0 && scale >= 0.0);

	return scale;
}

// given unit vector from listener to sound source,
// determine proportion of volume for sound in FL, FC, FR, RL, RR quadrants
// Scale this proportion by the distance scalar 'gain'
// If sound has 'mono' radius, blend sound to mono over 50% of radius.
void CAudioDeviceBase::SpatializeChannel( int volume[CCHANVOLUMES/2], int master_vol, const Vector& sourceDir, float gain, float mono )
{
	VPROF("CAudioDeviceBase::SpatializeChannel");
	float rfscale, rrscale, lfscale, lrscale, fcscale;

	fcscale = rfscale = lfscale = rrscale = lrscale = 0.0;	

	// clear volumes

	for (int i = 0; i < CCHANVOLUMES/2; i++)
		volume[i] = 0;

	// linear crossfader for 2, 4 or 5 speakers, using polar coord. separation angle as linear basis

	// get pitch & yaw angle from listener origin to sound source

	QAngle angles;
	float pitch;
	float source_yaw;
	float yaw;

	VectorAngles(sourceDir, angles);

	pitch		= angles[PITCH];
	source_yaw	= angles[YAW];

	// get 2d listener yaw angle from listener right

	QAngle angles2d;
	Vector source2d;
	float listener_yaw;

	source2d.x = listener_right.x;
	source2d.y = listener_right.y;
	source2d.z = 0.0;

	VectorNormalize(source2d);

	// convert right vector to euler angles (yaw & pitch)

	VectorAngles(source2d, angles2d);

	listener_yaw = angles2d[YAW];
	
	// get yaw of sound source, with listener_yaw as reference 0.

	yaw = source_yaw - listener_yaw;

	if (yaw < 0)
		yaw += 360;

	if ( !m_bSurround )
	{
		// 2 ch stereo mixing

		if ( m_bHeadphone )
		{
			// headphone mix: (NO HRTF)

			rfscale = GetSpeakerVol( yaw, pitch, mono, 0.0,  ISPEAKER_RIGHT_FRONT, 2, false);
			lfscale = GetSpeakerVol( yaw, pitch, mono, 180.0, ISPEAKER_LEFT_FRONT, 2, false );
		}
		else
		{
			// stereo speakers at 45 & 135 degrees: (mono sounds mix down to 2 channels)
		
			rfscale = GetSpeakerVol( yaw, pitch, mono, 45.0,  ISPEAKER_RIGHT_FRONT, 4, true );
			lfscale = GetSpeakerVol( yaw, pitch, mono, 135.0, ISPEAKER_LEFT_FRONT, 4, true );
			rrscale = GetSpeakerVol( yaw, pitch, mono, 315.0, ISPEAKER_RIGHT_REAR, 4, true );
			lrscale = GetSpeakerVol( yaw, pitch, mono, 225.0, ISPEAKER_LEFT_REAR, 4, true );

			// add sounds coming from rear (quieter)

			rfscale = clamp((rfscale + rrscale * 0.75), 0.0, 1.0); 
			lfscale = clamp((lfscale + lrscale * 0.75), 0.0, 1.0);		
			
			rrscale = 0;
			lrscale = 0;

			//DevMsg("lfscale=%f rfscale=%f lrscale=%f rrscale=%f\n",lfscale,rfscale,lrscale,rrscale);
			//DevMsg("pitch=%f yaw=%f \n",pitch, yaw);
		}
		goto SpatialExit;
	}

	if ( m_bSurround && !m_bSurroundCenter )
	{
		// 4 ch surround

		// linearly scale with radial distance from asource to FR, FL, RR, RL
		// where FR = 45 degrees, FL = 135, RR = 315 (-45), RL = 225 (-135)

		rfscale = GetSpeakerVol( yaw, pitch, mono, 45.0,  ISPEAKER_RIGHT_FRONT, 4, false );
		lfscale = GetSpeakerVol( yaw, pitch, mono, 135.0, ISPEAKER_LEFT_FRONT, 4, false );
		rrscale = GetSpeakerVol( yaw, pitch, mono, 315.0, ISPEAKER_RIGHT_REAR, 4, false );
		lrscale = GetSpeakerVol( yaw, pitch, mono, 225.0, ISPEAKER_LEFT_REAR, 4, false );

		// DevMsg("lfscale=%f rfscale=%f lrscale=%f rrscale=%f\n",lfscale,rfscale,lrscale,rrscale);
		// DevMsg("pitch=%f yaw=%f \n",pitch, yaw);

		goto SpatialExit;
	}

	if ( m_bSurround && m_bSurroundCenter )
	{
		// 5 ch surround

		// linearly scale with radial distance from asource to FR, FC, FL, RR, RL
		// where FR = 45 degrees, FC = 90, FL = 135, RR = 315 (-45), RL = 225 (-135)

		rfscale = GetSpeakerVol( yaw, pitch, mono, 45.0, ISPEAKER_RIGHT_FRONT, 5, false );
		fcscale = GetSpeakerVol( yaw, pitch, mono, 90.0, ISPEAKER_CENTER_FRONT, 5, false );
		lfscale = GetSpeakerVol( yaw, pitch, mono, 135.0, ISPEAKER_LEFT_FRONT, 5, false );
		rrscale = GetSpeakerVol( yaw, pitch, mono, 315.0, ISPEAKER_RIGHT_REAR, 5, false );
		lrscale = GetSpeakerVol( yaw, pitch, mono, 225.0, ISPEAKER_LEFT_REAR, 5, false );
		
		//DevMsg("lfscale=%f center= %f rfscale=%f lrscale=%f rrscale=%f\n",lfscale,fcscale, rfscale,lrscale,rrscale);
		//DevMsg("pitch=%f yaw=%f \n",pitch, yaw);

		goto SpatialExit;
	}

SpatialExit:

	// scale volumes in each quadrant by distance attenuation.

	// volumes are 0-255:
	// gain is 0.0->1.0, rscale is 0.0->1.0, so scale is 0.0->1.0
	// master_vol is 0->255, so rightvol is 0->255

	volume[IFRONT_RIGHT] = (int) (master_vol * gain * rfscale);
	volume[IFRONT_LEFT] =  (int) (master_vol * gain * lfscale);
	
	volume[IFRONT_RIGHT] = clamp( volume[IFRONT_RIGHT], 0, 255 );
	volume[IFRONT_LEFT]  = clamp( volume[IFRONT_LEFT], 0, 255 );

	if ( m_bSurround )
	{
		volume[IREAR_RIGHT] = (int) (master_vol * gain * rrscale);
		volume[IREAR_LEFT] =  (int) (master_vol * gain * lrscale);

		volume[IREAR_RIGHT] = clamp( volume[IREAR_RIGHT], 0, 255 );
		volume[IREAR_LEFT] = clamp( volume[IREAR_LEFT], 0, 255 );

		if ( m_bSurroundCenter )
		{
			volume[IFRONT_CENTER] = (int) (master_vol * gain * fcscale);
			volume[IFRONT_CENTER0] = 0.0;

			volume[IFRONT_CENTER] = clamp( volume[IFRONT_CENTER], 0, 255);
		}
	}
}

void CAudioDeviceBase::ApplyDSPEffects( int idsp, portable_samplepair_t *pbuffront, portable_samplepair_t *pbufrear, portable_samplepair_t *pbufcenter, int samplecount)
{
	VPROF("CAudioDeviceBase::ApplyDSPEffects");
	DEBUG_StartSoundMeasure( 1, samplecount );

	DSP_Process( idsp, pbuffront, pbufrear, pbufcenter, samplecount );

	DEBUG_StopSoundMeasure( 1, samplecount );
}

void CAudioDeviceBase::MixBegin( int sampleCount )
{
	MIX_ClearAllPaintBuffers( sampleCount, false );
}

void CAudioDeviceBase::MixUpsample( int sampleCount, int filtertype )
{
	paintbuffer_t *pPaint = MIX_GetCurrentPaintbufferPtr();
	int ifilter = pPaint->ifilter;

	Assert (ifilter < CPAINTFILTERS);

	S_MixBufferUpsample2x( sampleCount, pPaint->pbuf, &(pPaint->fltmem[ifilter][0]), CPAINTFILTERMEM, filtertype );

	if ( pPaint->fsurround )
	{
		Assert( pPaint->pbufrear );
		S_MixBufferUpsample2x( sampleCount, pPaint->pbufrear, &(pPaint->fltmemrear[ifilter][0]), CPAINTFILTERMEM, filtertype );

		if ( pPaint->fsurround_center )
		{
			Assert( pPaint->pbufcenter );
			S_MixBufferUpsample2x( sampleCount, pPaint->pbufcenter, &(pPaint->fltmemcenter[ifilter][0]), CPAINTFILTERMEM, filtertype );
		}
	}

	// make sure on next upsample pass for this paintbuffer, new filter memory is used
	pPaint->ifilter++;
}

void CAudioDeviceBase::Mix8Mono( channel_t *pChannel, char *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress )
{
	int volume[CCHANVOLUMES];

	paintbuffer_t *pPaint = MIX_GetCurrentPaintbufferPtr();

	if ( !MIX_ScaleChannelVolume( pPaint, pChannel, volume, 1) )
		return;

	if ( FVolumeFrontNonZero(volume) )
	{
		Mix8MonoWavtype( pChannel, pPaint->pbuf + outputOffset, volume, (byte *)pData, inputOffset, rateScaleFix, outCount);
	}

	if ( pPaint->fsurround )
	{
		if ( FVolumeRearNonZero(volume) )
		{
			Assert( pPaint->pbufrear );
			Mix8MonoWavtype( pChannel, pPaint->pbufrear + outputOffset, &volume[IREAR_LEFT], (byte *)pData, inputOffset, rateScaleFix, outCount  );
		}

		if ( pPaint->fsurround_center && FVolumeCenterNonZero(volume) )
		{
			Assert( pPaint->pbufcenter );
			Mix8MonoWavtype( pChannel, pPaint->pbufcenter + outputOffset, &volume[IFRONT_CENTER], (byte *)pData, inputOffset, rateScaleFix, outCount  );
		}
	}
}

void CAudioDeviceBase::Mix8Stereo( channel_t *pChannel, char *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress )
{
	int volume[CCHANVOLUMES];

	paintbuffer_t *pPaint = MIX_GetCurrentPaintbufferPtr();

	if ( !MIX_ScaleChannelVolume( pPaint, pChannel, volume, 2 ) )
		return;

	if ( FVolumeFrontNonZero(volume) )
	{
		Mix8StereoWavtype( pChannel, pPaint->pbuf + outputOffset, volume, (byte *)pData, inputOffset, rateScaleFix, outCount );
	}

	if ( pPaint->fsurround )
	{
		if ( FVolumeRearNonZero(volume) )
		{
			Assert( pPaint->pbufrear );
			Mix8StereoWavtype( pChannel, pPaint->pbufrear + outputOffset, &volume[IREAR_LEFT], (byte *)pData, inputOffset, rateScaleFix, outCount );
		}

		if ( pPaint->fsurround_center && FVolumeCenterNonZero(volume) )
		{
			Assert( pPaint->pbufcenter );
			Mix8StereoWavtype( pChannel, pPaint->pbufcenter + outputOffset, &volume[IFRONT_CENTER], (byte *)pData, inputOffset, rateScaleFix, outCount );
		}
	}
}

void CAudioDeviceBase::Mix16Mono( channel_t *pChannel, short *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress )
{
	int volume[CCHANVOLUMES];

	paintbuffer_t *pPaint = MIX_GetCurrentPaintbufferPtr();

	if ( !MIX_ScaleChannelVolume( pPaint, pChannel, volume, 1 ) )
		return;
	
	if ( FVolumeFrontNonZero(volume) )
	{
		Mix16MonoWavtype( pChannel, pPaint->pbuf + outputOffset, volume, pData, inputOffset, rateScaleFix, outCount );
	}

	if ( pPaint->fsurround )
	{		
		if ( FVolumeRearNonZero(volume) )
		{
			Assert( pPaint->pbufrear );
			Mix16MonoWavtype( pChannel, pPaint->pbufrear + outputOffset, &volume[IREAR_LEFT], pData, inputOffset, rateScaleFix, outCount );
		}

		if ( pPaint->fsurround_center && FVolumeCenterNonZero(volume) )
		{
			Assert( pPaint->pbufcenter );
			Mix16MonoWavtype( pChannel, pPaint->pbufcenter + outputOffset, &volume[IFRONT_CENTER], pData, inputOffset, rateScaleFix, outCount );
		}
	}
}

void CAudioDeviceBase::Mix16Stereo( channel_t *pChannel, short *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress )
{
	int volume[CCHANVOLUMES];

	paintbuffer_t *pPaint = MIX_GetCurrentPaintbufferPtr();

	if ( !MIX_ScaleChannelVolume( pPaint, pChannel, volume, 2 ) )
		return;

	if ( FVolumeFrontNonZero(volume) )
	{
		Mix16StereoWavtype( pChannel, pPaint->pbuf + outputOffset, volume, pData, inputOffset, rateScaleFix, outCount );
	}

	if ( pPaint->fsurround )
	{
		if ( FVolumeRearNonZero(volume) )
		{
			Assert( pPaint->pbufrear );
			Mix16StereoWavtype( pChannel, pPaint->pbufrear  + outputOffset, &volume[IREAR_LEFT], pData, inputOffset, rateScaleFix, outCount );
		}

		if ( pPaint->fsurround_center && FVolumeCenterNonZero(volume) )
		{
			Assert( pPaint->pbufcenter );
			Mix16StereoWavtype( pChannel, pPaint->pbufcenter  + outputOffset, &volume[IFRONT_CENTER], pData, inputOffset, rateScaleFix, outCount );
		}
	}
}

// Null Audio Device
class CAudioDeviceNull : public CAudioDeviceBase
{
public:
	bool		IsActive( void ) { return false; }
	bool		Init( void ) { return true; }
	void		Shutdown( void ) {}
	void		Pause( void ) {} 
	void		UnPause( void ) {}
	float		MixDryVolume( void ) { return 0; }
	bool		Should3DMix( void ) { return false; }
	void		StopAllSounds( void ) {}
	
	int			PaintBegin( float, int, int ) { return 0; }
	void		PaintEnd( void ) {}

	void		SpatializeChannel( int volume[CCHANVOLUMES/2], int master_vol, const Vector& sourceDir, float gain, float mono ) {}
	void		ApplyDSPEffects( int idsp, portable_samplepair_t *pbuffront, portable_samplepair_t *pbufrear, portable_samplepair_t *pbufcenter, int samplecount ) {}
	int			GetOutputPosition( void ) { return 0; }
	void		ClearBuffer( void ) {}
	void		UpdateListener( const Vector&, const Vector&, const Vector&, const Vector& ) {}

	void		MixBegin( int ) {}
	void		MixUpsample( int sampleCount, int filtertype ) {}

	void		Mix8Mono( channel_t *pChannel, char *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress ) {}
	void		Mix8Stereo( channel_t *pChannel, char *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress ) {}
	void		Mix16Mono( channel_t *pChannel, short *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress ) {}
	void		Mix16Stereo( channel_t *pChannel, short *pData, int outputOffset, int inputOffset, fixedint rateScaleFix, int outCount, int timecompress ) {}

	void		ChannelReset( int, int, float ) {}
	void		TransferSamples( int end ) {}
	
	const char *DeviceName( void )			{ return "Audio Disabled"; }
	int			DeviceChannels( void )		{ return 2; }
	int			DeviceSampleBits( void )	{ return 16; }
	int			DeviceSampleBytes( void )	{ return 2; }
	int			DeviceDmaSpeed( void )		{ return SOUND_DMA_SPEED; }
	int			DeviceSampleCount( void )	{ return 0; }

	bool		IsSurround( void )			{ return false; }
	bool		IsSurroundCenter( void )	{ return false; }
	bool		IsHeadphone( void )			{ return false; }
};

IAudioDevice *Audio_GetNullDevice( void )
{
	// singeton device here
	static CAudioDeviceNull nullDevice;
	return &nullDevice;
}