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.
 
 
 
 
 
 

623 lines
19 KiB

//========= 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;
}