mirror of
https://github.com/w23/xash3d-fwgs
synced 2024-12-15 21:50:59 +01:00
907 lines
20 KiB
C
907 lines
20 KiB
C
/*
|
|
s_dsp.c - digital signal processing algorithms for audio FX
|
|
Copyright (C) 2009 Uncle Mike
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include "client.h"
|
|
#include "sound.h"
|
|
|
|
#define MAX_DELAY 0.4f
|
|
#define MAX_ROOM_TYPES ARRAYSIZE( rgsxpre )
|
|
|
|
#define MONODLY 0
|
|
#define MAX_MONO_DELAY 0.4f
|
|
|
|
#define REVERBPOS 1
|
|
#define MAX_REVERB_DELAY 0.1f
|
|
|
|
#define STEREODLY 3
|
|
#define MAX_STEREO_DELAY 0.1f
|
|
|
|
#define REVERB_XFADE 32
|
|
|
|
#define MAXDLY (STEREODLY + 1)
|
|
#define MAXLP 10
|
|
#define MAXPRESETS 29
|
|
|
|
typedef struct sx_preset_s
|
|
{
|
|
float room_lp; // lowpass
|
|
float room_mod; // modulation
|
|
|
|
// reverb
|
|
float room_size;
|
|
float room_refl;
|
|
float room_rvblp;
|
|
|
|
// delay
|
|
float room_delay;
|
|
float room_feedback;
|
|
float room_dlylp;
|
|
float room_left;
|
|
} sx_preset_t;
|
|
|
|
typedef struct dly_s
|
|
{
|
|
size_t cdelaysamplesmax; // delay line array size
|
|
|
|
// delay line pointers
|
|
size_t idelayinput;
|
|
size_t idelayoutput;
|
|
|
|
// crossfade
|
|
size_t idelayoutputxf; // output pointer
|
|
int xfade; // value
|
|
|
|
int delaysamples; // delay setting
|
|
int delayfeedback; // feedback setting
|
|
|
|
// lowpass
|
|
int lp; // is lowpass enabled
|
|
int lp0, lp1, lp2; // lowpass buffer
|
|
|
|
// modulation
|
|
int mod;
|
|
int modcur;
|
|
|
|
// delay line
|
|
int *lpdelayline;
|
|
} dly_t;
|
|
|
|
const sx_preset_t rgsxpre[MAXPRESETS] =
|
|
{
|
|
// -------reverb-------- -------delay--------
|
|
// lp mod size refl rvblp delay feedback dlylp left
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 2.0, 0.0 }, // 0 off
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.065, 0.1, 0.0, 0.01 }, // 1 generic
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.02, 0.75, 0.0, 0.01 }, // 2 metalic
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.03, 0.78, 0.0, 0.02 }, // 3
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.06, 0.77, 0.0, 0.03 }, // 4
|
|
{ 0.0, 0.0, 0.05, 0.85, 1.0, 0.008, 0.96, 2.0, 0.01 }, // 5 tunnel
|
|
{ 0.0, 0.0, 0.05, 0.88, 1.0, 0.01, 0.98, 2.0, 0.02 }, // 6
|
|
{ 0.0, 0.0, 0.05, 0.92, 1.0, 0.015, 0.995, 2.0, 0.04 }, // 7
|
|
{ 0.0, 0.0, 0.05, 0.84, 1.0, 0.0, 0.0, 2.0, 0.012 }, // 8 chamber
|
|
{ 0.0, 0.0, 0.05, 0.9, 1.0, 0.0, 0.0, 2.0, 0.008 }, // 9
|
|
{ 0.0, 0.0, 0.05, 0.95, 1.0, 0.0, 0.0, 2.0, 0.004 }, // 10
|
|
{ 0.0, 0.0, 0.05, 0.7, 0.0, 0.0, 0.0, 2.0, 0.012 }, // 11 brite
|
|
{ 0.0, 0.0, 0.055, 0.78, 0.0, 0.0, 0.0, 2.0, 0.008 }, // 12
|
|
{ 0.0, 0.0, 0.05, 0.86, 0.0, 0.0, 0.0, 2.0, 0.002 }, // 13
|
|
{ 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 2.0, 0.01 }, // 14 water
|
|
{ 1.0, 0.0, 0.0, 0.0, 1.0, 0.06, 0.85, 2.0, 0.02 }, // 15
|
|
{ 1.0, 0.0, 0.0, 0.0, 1.0, 0.2, 0.6, 2.0, 0.05 }, // 16
|
|
{ 0.0, 0.0, 0.05, 0.8, 1.0, 0.0, 0.48, 2.0, 0.016 }, // 17 concrete
|
|
{ 0.0, 0.0, 0.06, 0.9, 1.0, 0.0, 0.52, 2.0, 0.01 }, // 18
|
|
{ 0.0, 0.0, 0.07, 0.94, 1.0, 0.3, 0.6, 2.0, 0.008 }, // 19
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.3, 0.42, 2.0, 0.0 }, // 20 outside
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.35, 0.48, 2.0, 0.0 }, // 21
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.38, 0.6, 2.0, 0.0 }, // 22
|
|
{ 0.0, 0.0, 0.05, 0.9, 1.0, 0.2, 0.28, 0.0, 0.0 }, // 23 cavern
|
|
{ 0.0, 0.0, 0.07, 0.9, 1.0, 0.3, 0.4, 0.0, 0.0 }, // 24
|
|
{ 0.0, 0.0, 0.09, 0.9, 1.0, 0.35, 0.5, 0.0, 0.0 }, // 25
|
|
{ 0.0, 1.0, 0.01, 0.9, 0.0, 0.0, 0.0, 2.0, 0.05 }, // 26 weirdo
|
|
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.009, 0.999, 2.0, 0.04 }, // 27
|
|
{ 0.0, 0.0, 0.001, 0.999, 0.0, 0.2, 0.8, 2.0, 0.05 } // 28
|
|
};
|
|
|
|
// cvars
|
|
convar_t *dsp_off; // disable dsp
|
|
convar_t *roomwater_type; // water room_type
|
|
convar_t *room_type; // current room type
|
|
convar_t *hisound; // DSP quality
|
|
|
|
// underwater/special fx modulations
|
|
convar_t *sxmod_mod;
|
|
convar_t *sxmod_lowpass;
|
|
|
|
// stereo delay(no feedback)
|
|
convar_t *sxste_delay; // straight left delay
|
|
|
|
// mono reverb
|
|
convar_t *sxrvb_lp; // lowpass
|
|
convar_t *sxrvb_feedback; // reverb decay. Higher -- longer
|
|
convar_t *sxrvb_size; // room size. Higher -- larger
|
|
|
|
// mono delay
|
|
convar_t *sxdly_lp; // lowpass
|
|
convar_t *sxdly_feedback; // cycles
|
|
convar_t *sxdly_delay; // current delay in seconds
|
|
|
|
convar_t *dsp_room; // for compability
|
|
int idsp_dma_speed;
|
|
int idsp_room;
|
|
int room_typeprev;
|
|
|
|
// routines
|
|
int sxamodl, sxamodr; // amplitude modulation values
|
|
int sxamodlt, sxamodrt; // modulation targets
|
|
int sxmod1cur, sxmod2cur;
|
|
int sxmod1, sxmod2;
|
|
int sxhires;
|
|
|
|
portable_samplepair_t *paintto = NULL;
|
|
|
|
dly_t rgsxdly[MAXDLY]; // stereo is last
|
|
int rgsxlp[MAXLP];
|
|
|
|
void SX_Profiling_f( void );
|
|
|
|
/*
|
|
============
|
|
SX_ReloadRoomFX
|
|
|
|
============
|
|
*/
|
|
void SX_ReloadRoomFX( void )
|
|
{
|
|
if( !dsp_room ) return; // not initialized
|
|
|
|
SetBits( sxste_delay->flags, FCVAR_CHANGED );
|
|
SetBits( sxrvb_feedback->flags, FCVAR_CHANGED );
|
|
SetBits( sxdly_delay->flags, FCVAR_CHANGED );
|
|
SetBits( room_type->flags, FCVAR_CHANGED );
|
|
}
|
|
|
|
/*
|
|
============
|
|
SX_Init()
|
|
|
|
Starts sound crackling system
|
|
============
|
|
*/
|
|
void SX_Init( void )
|
|
{
|
|
memset( rgsxdly, 0, sizeof( rgsxdly ));
|
|
memset( rgsxlp, 0, sizeof( rgsxlp ));
|
|
|
|
sxamodr = sxamodl = sxamodrt = sxamodlt = 255;
|
|
idsp_dma_speed = SOUND_11k;
|
|
|
|
hisound = Cvar_Get( "room_hires", "2", FCVAR_ARCHIVE, "dsp quality. 1 for 22k, 2 for 44k(recommended) and 3 for 96k" );
|
|
sxhires = 2;
|
|
|
|
sxmod1cur = sxmod1 = 350 * ( idsp_dma_speed / SOUND_11k );
|
|
sxmod2cur = sxmod2 = 450 * ( idsp_dma_speed / SOUND_11k );
|
|
|
|
dsp_off = Cvar_Get( "dsp_off", "0", FCVAR_ARCHIVE, "disable DSP processing" );
|
|
roomwater_type = Cvar_Get( "waterroom_type", "14", 0, "water room type" );
|
|
room_type = Cvar_Get( "room_type", "0", 0, "current room type preset" );
|
|
|
|
sxmod_lowpass = Cvar_Get( "room_lp", "0", 0, "for water fx, lowpass for entire room" );
|
|
sxmod_mod = Cvar_Get( "room_mod", "0", 0, "stereo amptitude modulation for room" );
|
|
|
|
sxrvb_size = Cvar_Get( "room_size", "0", 0, "reverb: initial reflection size" );
|
|
sxrvb_feedback = Cvar_Get( "room_refl", "0", 0, "reverb: decay time" );
|
|
sxrvb_lp = Cvar_Get( "room_rvblp", "1", 0, "reverb: low pass filtering level" );
|
|
|
|
sxdly_delay = Cvar_Get( "room_delay", "0.8", 0, "mono delay: delay time" );
|
|
sxdly_feedback = Cvar_Get( "room_feedback", "0.2", 0, "mono delay: decay time" );
|
|
sxdly_lp = Cvar_Get( "room_dlylp", "1", 0, "mono delay: low pass filtering level" );
|
|
|
|
sxste_delay = Cvar_Get( "room_left", "0", 0, "left channel delay time" );
|
|
|
|
Cmd_AddCommand( "dsp_profile", SX_Profiling_f, "dsp stress-test, first argument is room_type" );
|
|
|
|
// for compability
|
|
dsp_room = room_type;
|
|
|
|
SX_ReloadRoomFX();
|
|
}
|
|
|
|
/*
|
|
===========
|
|
DLY_Free
|
|
|
|
Free memory allocated for DSP
|
|
===========
|
|
*/
|
|
void DLY_Free( int idelay )
|
|
{
|
|
Assert( idelay >= 0 && idelay < MAXDLY );
|
|
|
|
if( rgsxdly[idelay].lpdelayline )
|
|
{
|
|
Z_Free( rgsxdly[idelay].lpdelayline );
|
|
rgsxdly[idelay].lpdelayline = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==========
|
|
SX_Shutdown
|
|
|
|
Stop DSP processor
|
|
==========
|
|
*/
|
|
void SX_Free( void )
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i <= 3; i++ )
|
|
DLY_Free( i );
|
|
|
|
Cmd_RemoveCommand( "dsp_profile" );
|
|
}
|
|
|
|
|
|
/*
|
|
===========
|
|
DLY_Init
|
|
|
|
Initialize dly
|
|
===========
|
|
*/
|
|
int DLY_Init( int idelay, float delay )
|
|
{
|
|
dly_t *cur;
|
|
|
|
// DLY_Init called anytime with constants. So valid it in debug builds only.
|
|
Assert( idelay >= 0 && idelay < MAXDLY );
|
|
Assert( delay > 0.0f && delay <= MAX_DELAY );
|
|
|
|
DLY_Free( idelay ); // free dly if it's allocated
|
|
|
|
cur = &rgsxdly[idelay];
|
|
cur->cdelaysamplesmax = ((int)(delay * idsp_dma_speed) << sxhires) + 1;
|
|
cur->lpdelayline = (int *)Z_Calloc( cur->cdelaysamplesmax * sizeof( int ));
|
|
cur->xfade = 0;
|
|
|
|
// init modulation
|
|
cur->mod = cur->modcur = 0;
|
|
|
|
// init lowpass
|
|
cur->lp = 1;
|
|
cur->lp0 = cur->lp1 = cur->lp2 = 0;
|
|
|
|
cur->idelayinput = 0;
|
|
cur->idelayoutput = cur->cdelaysamplesmax - cur->delaysamples; // NOTE: delaysamples must be set!!!
|
|
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
============
|
|
DLY_MovePointer
|
|
|
|
Checks overflow and moves pointer
|
|
============
|
|
*/
|
|
_inline void DLY_MovePointer( dly_t *dly )
|
|
{
|
|
if( ++dly->idelayinput >= dly->cdelaysamplesmax )
|
|
dly->idelayinput = 0;
|
|
|
|
if( ++dly->idelayoutput >= dly->cdelaysamplesmax )
|
|
dly->idelayoutput = 0;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
DLY_CheckNewStereoDelayVal
|
|
|
|
Update stereo processor settings if we are in new room
|
|
=============
|
|
*/
|
|
void DLY_CheckNewStereoDelayVal( void )
|
|
{
|
|
dly_t *const dly = &rgsxdly[STEREODLY];
|
|
float delay = sxste_delay->value;
|
|
|
|
if( !FBitSet( sxste_delay->flags, FCVAR_CHANGED ))
|
|
return;
|
|
|
|
if( delay == 0 )
|
|
{
|
|
DLY_Free( STEREODLY );
|
|
}
|
|
else
|
|
{
|
|
int samples;
|
|
|
|
delay = Q_min( delay, MAX_STEREO_DELAY );
|
|
samples = (int)(delay * idsp_dma_speed) << sxhires;
|
|
|
|
// re-init dly
|
|
if( !dly->lpdelayline )
|
|
{
|
|
dly->delaysamples = samples;
|
|
DLY_Init( STEREODLY, MAX_STEREO_DELAY );
|
|
}
|
|
|
|
if( dly->delaysamples != samples )
|
|
{
|
|
dly->xfade = 128;
|
|
dly->idelayoutputxf = dly->idelayinput - samples;
|
|
if( dly->idelayoutputxf < 0 )
|
|
dly->idelayoutputxf += dly->cdelaysamplesmax;
|
|
}
|
|
|
|
dly->modcur = dly->mod = 0;
|
|
|
|
if( dly->delaysamples == 0 )
|
|
DLY_Free( STEREODLY );
|
|
}
|
|
|
|
ClearBits( sxste_delay->flags, FCVAR_CHANGED );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
DLY_DoStereoDelay
|
|
|
|
Do stereo processing
|
|
=============
|
|
*/
|
|
void DLY_DoStereoDelay( int count )
|
|
{
|
|
int delay, samplexf;
|
|
dly_t *const dly = &rgsxdly[STEREODLY];
|
|
portable_samplepair_t *paint = paintto;
|
|
|
|
if( !dly->lpdelayline )
|
|
return; // inactive
|
|
|
|
for( ; count; count--, paint++ )
|
|
{
|
|
if( dly->mod && --dly->modcur < 0 )
|
|
dly->modcur = dly->mod;
|
|
|
|
delay = dly->lpdelayline[dly->idelayoutput];
|
|
|
|
// process only if crossfading, active left value or delayline
|
|
if( delay || paint->left || dly->xfade )
|
|
{
|
|
// set up new crossfade, if not crossfading, not modulating, but going to
|
|
if( !dly->xfade && !dly->modcur && dly->mod )
|
|
{
|
|
dly->idelayoutputxf = dly->idelayoutput + ((COM_RandomLong( 0, 255 ) * dly->delaysamples ) >> 9 );
|
|
|
|
dly->xfade = 128;
|
|
}
|
|
|
|
dly->idelayoutputxf %= dly->cdelaysamplesmax;
|
|
|
|
// modify delay, if crossfading
|
|
if( dly->xfade )
|
|
{
|
|
samplexf = dly->lpdelayline[dly->idelayoutputxf] * (128 - dly->xfade) >> 7;
|
|
delay = samplexf + ((delay * dly->xfade) >> 7);
|
|
|
|
if( ++dly->idelayoutputxf >= dly->cdelaysamplesmax )
|
|
dly->idelayoutputxf = 0;
|
|
|
|
if( --dly->xfade == 0 )
|
|
dly->idelayoutput = dly->idelayoutputxf;
|
|
}
|
|
|
|
// save left value to delay line
|
|
dly->lpdelayline[dly->idelayinput] = CLIP( paint->left );
|
|
|
|
// paint new delay value
|
|
paint->left = delay;
|
|
}
|
|
else
|
|
{
|
|
// clear delay line
|
|
dly->lpdelayline[dly->idelayinput] = 0;
|
|
}
|
|
|
|
DLY_MovePointer( dly );
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
DLY_CheckNewDelayVal
|
|
|
|
Update delay processor settings if we are in new room
|
|
=============
|
|
*/
|
|
void DLY_CheckNewDelayVal( void )
|
|
{
|
|
float delay = sxdly_delay->value;
|
|
dly_t *const dly = &rgsxdly[MONODLY];
|
|
|
|
if( FBitSet( sxdly_delay->flags, FCVAR_CHANGED ))
|
|
{
|
|
if( delay == 0 )
|
|
{
|
|
DLY_Free( MONODLY );
|
|
}
|
|
else
|
|
{
|
|
delay = min( delay, MAX_MONO_DELAY );
|
|
dly->delaysamples = (int)(delay * idsp_dma_speed) << sxhires;
|
|
|
|
// init dly
|
|
if( !dly->lpdelayline )
|
|
DLY_Init( MONODLY, MAX_MONO_DELAY );
|
|
|
|
if( dly->lpdelayline )
|
|
{
|
|
memset( dly->lpdelayline, 0, dly->cdelaysamplesmax * sizeof( int ) );
|
|
dly->lp0 = dly->lp1 = dly->lp2 = 0;
|
|
}
|
|
|
|
dly->idelayinput = 0;
|
|
dly->idelayoutput = dly->cdelaysamplesmax - dly->delaysamples;
|
|
|
|
if( !dly->delaysamples )
|
|
DLY_Free( MONODLY );
|
|
|
|
}
|
|
}
|
|
|
|
ClearBits( sxdly_delay->flags, FCVAR_CHANGED );
|
|
dly->lp = sxdly_lp->value;
|
|
dly->delayfeedback = 255 * sxdly_feedback->value;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
DLY_DoDelay
|
|
|
|
Do delay processing
|
|
=============
|
|
*/
|
|
void DLY_DoDelay( int count )
|
|
{
|
|
dly_t *const dly = &rgsxdly[MONODLY];
|
|
portable_samplepair_t *paint = paintto;
|
|
int delay;
|
|
|
|
if( !dly->lpdelayline || !count )
|
|
return; // inactive
|
|
|
|
for( ; count; count--, paint++ )
|
|
{
|
|
delay = dly->lpdelayline[dly->idelayoutput];
|
|
|
|
// don't process if delay line and left/right samples are zero
|
|
if( delay || paint->left || paint->right )
|
|
{
|
|
// calculate delayed value from average
|
|
int val = (( paint->left + paint->right ) >> 1 ) + (( dly->delayfeedback * delay ) >> 8);
|
|
val = CLIP( val );
|
|
|
|
if( dly->lp ) // lowpass
|
|
{
|
|
dly->lp0 = dly->lp1;
|
|
dly->lp1 = val;
|
|
val = ( dly->lp0 + dly->lp1 + (val << 1) ) >> 2;
|
|
}
|
|
|
|
dly->lpdelayline[dly->idelayinput] = val;
|
|
|
|
val >>= 2;
|
|
|
|
paint->left = CLIP( paint->left + val );
|
|
paint->right = CLIP( paint->right + val );
|
|
}
|
|
else
|
|
{
|
|
dly->lpdelayline[dly->idelayinput] = 0;
|
|
dly->lp0 = dly->lp1 = 0;
|
|
}
|
|
|
|
DLY_MovePointer( dly );
|
|
}
|
|
}
|
|
|
|
/*
|
|
===========
|
|
RVB_SetUpDly
|
|
|
|
Set up dly for reverb
|
|
===========
|
|
*/
|
|
void RVB_SetUpDly( int pos, float delay, int kmod )
|
|
{
|
|
int samples;
|
|
|
|
delay = Q_min( delay, MAX_REVERB_DELAY );
|
|
samples = (int)(delay * idsp_dma_speed) << sxhires;
|
|
|
|
if( !rgsxdly[pos].lpdelayline )
|
|
{
|
|
rgsxdly[pos].delaysamples = samples;
|
|
DLY_Init( pos, MAX_REVERB_DELAY );
|
|
}
|
|
|
|
rgsxdly[pos].modcur = rgsxdly[pos].mod = (int)(kmod * idsp_dma_speed / SOUND_11k) << sxhires;
|
|
|
|
// set up crossfade, if delay has changed
|
|
if( rgsxdly[pos].delaysamples != samples )
|
|
{
|
|
rgsxdly[pos].idelayoutputxf = rgsxdly[pos].idelayinput - samples;
|
|
if( rgsxdly[pos].idelayoutputxf < 0 )
|
|
rgsxdly[pos].idelayoutputxf += rgsxdly[pos].cdelaysamplesmax;
|
|
rgsxdly[pos].xfade = 32;
|
|
}
|
|
|
|
if( !rgsxdly[pos].delaysamples )
|
|
DLY_Free( pos );
|
|
|
|
}
|
|
|
|
/*
|
|
===========
|
|
RVB_CheckNewReverbVal
|
|
|
|
Update reverb settings if we are in new room
|
|
===========
|
|
*/
|
|
void RVB_CheckNewReverbVal( void )
|
|
{
|
|
dly_t *const dly1 = &rgsxdly[REVERBPOS];
|
|
dly_t *const dly2 = &rgsxdly[REVERBPOS + 1];
|
|
float delay = sxrvb_size->value;
|
|
|
|
if( FBitSet( sxrvb_size->flags, FCVAR_CHANGED ))
|
|
{
|
|
if( delay == 0.0f )
|
|
{
|
|
DLY_Free( REVERBPOS );
|
|
DLY_Free( REVERBPOS + 1 );
|
|
}
|
|
else
|
|
{
|
|
RVB_SetUpDly( REVERBPOS, sxrvb_size->value, 500 );
|
|
RVB_SetUpDly( REVERBPOS+1, sxrvb_size->value * 0.71f, 700 );
|
|
}
|
|
}
|
|
|
|
ClearBits( sxrvb_size->flags, FCVAR_CHANGED );
|
|
dly1->lp = dly2->lp = sxrvb_lp->value;
|
|
dly1->delayfeedback = dly2->delayfeedback = (int)(255 * sxrvb_feedback->value);
|
|
}
|
|
|
|
/*
|
|
===========
|
|
RVB_DoReverbForOneDly
|
|
|
|
Do reverberation for one dly
|
|
===========
|
|
*/
|
|
int RVB_DoReverbForOneDly( dly_t *dly, const int vlr, const portable_samplepair_t *samplepair )
|
|
{
|
|
int delay;
|
|
int samplexf;
|
|
int val, valt;
|
|
int voutm = 0;
|
|
|
|
if( --dly->modcur < 0 )
|
|
dly->modcur = dly->mod;
|
|
|
|
delay = dly->lpdelayline[dly->idelayoutput];
|
|
|
|
if( dly->xfade || delay || samplepair->left || samplepair->right )
|
|
{
|
|
// modulate delay rate
|
|
if( !dly->xfade && !dly->modcur && dly->mod )
|
|
{
|
|
dly->idelayoutputxf = dly->idelayoutput + ((COM_RandomLong( 0, 255 ) * delay) >> 9 );
|
|
|
|
//dly->xfade = 32;
|
|
}
|
|
|
|
dly->idelayoutputxf %= dly->cdelaysamplesmax;
|
|
|
|
if( dly->xfade )
|
|
{
|
|
samplexf = (dly->lpdelayline[dly->idelayoutputxf] * (REVERB_XFADE - dly->xfade)) / REVERB_XFADE;
|
|
delay = ((delay * dly->xfade) / REVERB_XFADE) + samplexf;
|
|
|
|
if( ++dly->idelayoutputxf >= dly->cdelaysamplesmax )
|
|
dly->idelayoutputxf = 0;
|
|
|
|
if( --dly->xfade == 0 )
|
|
dly->idelayoutput = dly->idelayoutputxf;
|
|
}
|
|
|
|
|
|
if( delay )
|
|
{
|
|
val = vlr + ( ( dly->delayfeedback * delay ) >> 8 );
|
|
val = CLIP( val );
|
|
}
|
|
else
|
|
val = vlr;
|
|
|
|
if( dly->lp )
|
|
{
|
|
valt = (dly->lp0 + val) >> 1;
|
|
dly->lp0 = val;
|
|
}
|
|
else
|
|
valt = val;
|
|
|
|
voutm = dly->lpdelayline[dly->idelayinput] = valt;
|
|
}
|
|
else
|
|
{
|
|
voutm = dly->lpdelayline[dly->idelayinput] = 0;
|
|
dly->lp0 = 0;
|
|
}
|
|
|
|
DLY_MovePointer( dly );
|
|
|
|
return voutm;
|
|
|
|
}
|
|
|
|
/*
|
|
===========
|
|
RVB_DoReverb
|
|
|
|
Do reverberation processing
|
|
===========
|
|
*/
|
|
void RVB_DoReverb( int count )
|
|
{
|
|
dly_t *const dly1 = &rgsxdly[REVERBPOS];
|
|
dly_t *const dly2 = &rgsxdly[REVERBPOS+1];
|
|
portable_samplepair_t *paint = paintto;
|
|
int vlr, voutm;
|
|
|
|
if( !dly1->lpdelayline )
|
|
return;
|
|
|
|
for( ; count; count--, paint++ )
|
|
{
|
|
vlr = ( paint->left + paint->right ) >> 1;
|
|
|
|
voutm = RVB_DoReverbForOneDly( dly1, vlr, paint );
|
|
voutm += RVB_DoReverbForOneDly( dly2, vlr, paint );
|
|
|
|
voutm = (11 * voutm) >> 6;
|
|
|
|
paint->left = CLIP( paint->left + voutm );
|
|
paint->right = CLIP( paint->right + voutm );
|
|
}
|
|
}
|
|
|
|
/*
|
|
===========
|
|
RVB_DoAMod
|
|
|
|
Do amplification modulation processing
|
|
===========
|
|
*/
|
|
void RVB_DoAMod( int count )
|
|
{
|
|
portable_samplepair_t *paint = paintto;
|
|
|
|
if( !sxmod_lowpass->value && !sxmod_mod->value )
|
|
return;
|
|
|
|
for( ; count; count--, paint++ )
|
|
{
|
|
portable_samplepair_t res = *paint;
|
|
|
|
if( sxmod_lowpass->value )
|
|
{
|
|
res.left = rgsxlp[0] + rgsxlp[1] + rgsxlp[2] + rgsxlp[3] + rgsxlp[4] + res.left;
|
|
res.right = rgsxlp[5] + rgsxlp[6] + rgsxlp[7] + rgsxlp[8] + rgsxlp[9] + res.right;
|
|
|
|
res.left >>= 2;
|
|
res.right >>= 2;
|
|
|
|
rgsxlp[0] = rgsxlp[1];
|
|
rgsxlp[1] = rgsxlp[2];
|
|
rgsxlp[2] = rgsxlp[3];
|
|
rgsxlp[3] = rgsxlp[4];
|
|
rgsxlp[4] = paint->left;
|
|
|
|
rgsxlp[5] = rgsxlp[6];
|
|
rgsxlp[6] = rgsxlp[7];
|
|
rgsxlp[7] = rgsxlp[8];
|
|
rgsxlp[8] = rgsxlp[9];
|
|
rgsxlp[9] = paint->right;
|
|
}
|
|
|
|
if( sxmod_mod->value )
|
|
{
|
|
if( --sxmod1cur < 0 )
|
|
sxmod1cur = sxmod1;
|
|
|
|
if( !sxmod1 )
|
|
sxamodlt = COM_RandomLong( 32, 255 );
|
|
|
|
if( --sxmod2cur < 0 )
|
|
sxmod2cur = sxmod2;
|
|
|
|
if( !sxmod2 )
|
|
sxamodrt = COM_RandomLong( 32, 255 );
|
|
|
|
res.left = (sxamodl * res.left) >> 8;
|
|
res.right = (sxamodr * res.right) >> 8;
|
|
|
|
if( sxamodl < sxamodlt )
|
|
sxamodl++;
|
|
else if( sxamodl > sxamodlt )
|
|
sxamodl--;
|
|
|
|
if( sxamodr < sxamodrt )
|
|
sxamodr++;
|
|
else if( sxamodr > sxamodrt )
|
|
sxamodr--;
|
|
}
|
|
|
|
paint->left = CLIP(res.left);
|
|
paint->right = CLIP(res.right);
|
|
}
|
|
}
|
|
|
|
/*
|
|
===========
|
|
DSP_Process
|
|
|
|
(xash dsp interface)
|
|
===========
|
|
*/
|
|
void DSP_Process( int idsp, portable_samplepair_t *pbfront, int sampleCount )
|
|
{
|
|
if( dsp_off->value )
|
|
return;
|
|
|
|
// don't process DSP while in menu
|
|
if( cls.key_dest == key_menu || !sampleCount )
|
|
return;
|
|
|
|
// preset is already installed by CheckNewDspPresets
|
|
paintto = pbfront;
|
|
|
|
RVB_DoAMod( sampleCount );
|
|
RVB_DoReverb( sampleCount );
|
|
DLY_DoDelay( sampleCount );
|
|
DLY_DoStereoDelay( sampleCount );
|
|
}
|
|
|
|
/*
|
|
===========
|
|
DSP_ClearState
|
|
|
|
(xash dsp interface)
|
|
===========
|
|
*/
|
|
void DSP_ClearState( void )
|
|
{
|
|
Cvar_SetValue( "room_type", 0.0f );
|
|
SX_ReloadRoomFX();
|
|
}
|
|
|
|
/*
|
|
===========
|
|
CheckNewDspPresets
|
|
|
|
(xash dsp interface)
|
|
===========
|
|
*/
|
|
void CheckNewDspPresets( void )
|
|
{
|
|
if( dsp_off->value != 0.0f )
|
|
return;
|
|
|
|
if( s_listener.waterlevel > 2 )
|
|
idsp_room = roomwater_type->value;
|
|
else idsp_room = room_type->value;
|
|
|
|
// don't pass invalid presets
|
|
idsp_room = bound( 0, idsp_room, MAXPRESETS - 1 );
|
|
|
|
if( FBitSet( hisound->flags, FCVAR_CHANGED ))
|
|
{
|
|
sxhires = hisound->value;
|
|
ClearBits( hisound->flags, FCVAR_CHANGED );
|
|
}
|
|
|
|
if( idsp_room == room_typeprev && idsp_room == 0 )
|
|
return;
|
|
|
|
if( idsp_room > MAX_ROOM_TYPES )
|
|
return;
|
|
|
|
if( idsp_room != room_typeprev )
|
|
{
|
|
const sx_preset_t *cur = rgsxpre + idsp_room;
|
|
|
|
Cvar_SetValue( "room_lp", cur->room_lp );
|
|
Cvar_SetValue( "room_mod", cur->room_mod );
|
|
Cvar_SetValue( "room_size", cur->room_size );
|
|
Cvar_SetValue( "room_refl", cur->room_refl );
|
|
Cvar_SetValue( "room_rvblp", cur->room_rvblp );
|
|
Cvar_SetValue( "room_delay", cur->room_delay );
|
|
Cvar_SetValue( "room_feedback", cur->room_feedback );
|
|
Cvar_SetValue( "room_dlylp", cur->room_dlylp );
|
|
Cvar_SetValue( "room_left", cur->room_left );
|
|
}
|
|
|
|
room_typeprev = idsp_room;
|
|
|
|
RVB_CheckNewReverbVal( );
|
|
DLY_CheckNewDelayVal( );
|
|
DLY_CheckNewStereoDelayVal();
|
|
}
|
|
|
|
/*
|
|
===========
|
|
DSP_GetGain
|
|
|
|
(xash dsp interface)
|
|
===========
|
|
*/
|
|
float DSP_GetGain( int idsp )
|
|
{
|
|
return 1.0f;
|
|
}
|
|
|
|
void SX_Profiling_f( void )
|
|
{
|
|
portable_samplepair_t testbuffer[512];
|
|
float oldroom = room_type->value;
|
|
double start, end;
|
|
int i, calls;
|
|
|
|
for( i = 0; i < 512; i++ )
|
|
{
|
|
testbuffer[i].left = COM_RandomLong( 0, 3000 );
|
|
testbuffer[i].right = COM_RandomLong( 0, 3000 );
|
|
}
|
|
|
|
if( Cmd_Argc() > 1 )
|
|
{
|
|
Cvar_SetValue( "room_type", Q_atof( Cmd_Argv( 1 )));
|
|
SX_ReloadRoomFX();
|
|
CheckNewDspPresets(); // we just need idsp_room immediately, for message below
|
|
}
|
|
|
|
Con_Printf( "Profiling 10000 calls to DSP. Sample count is 512, room_type is %i\n", idsp_room );
|
|
|
|
start = Sys_DoubleTime();
|
|
for( calls = 10000; calls; calls-- )
|
|
{
|
|
DSP_Process( idsp_room, testbuffer, 512 );
|
|
}
|
|
end = Sys_DoubleTime();
|
|
|
|
Con_Printf( "----------\nTook %g seconds.\n", end - start );
|
|
|
|
if( Cmd_Argc() > 1 )
|
|
{
|
|
Cvar_SetValue( "room_type", oldroom );
|
|
SX_ReloadRoomFX();
|
|
CheckNewDspPresets();
|
|
}
|
|
} |