895 lines
20 KiB
895 lines
20 KiB
/* |
|
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 |
|
int 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(); |
|
} |
|
|
|
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(); |
|
} |
|
}
|
|
|