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.
9680 lines
239 KiB
9680 lines
239 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose:
|
||
|
//
|
||
|
// $NoKeywords: $
|
||
|
//
|
||
|
//=============================================================================//
|
||
|
// snd_dsp.c -- audio processing routines
|
||
|
|
||
|
|
||
|
#include "audio_pch.h"
|
||
|
#include "snd_mix_buf.h"
|
||
|
|
||
|
#include "iprediction.h"
|
||
|
#include "../../common.h" // for parsing routines
|
||
|
#include "vstdlib/random.h"
|
||
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
#include "tier0/memdbgon.h"
|
||
|
|
||
|
#define SIGN(d) ((d)<0?-1:1)
|
||
|
|
||
|
#define ABS(a) abs(a)
|
||
|
|
||
|
#define MSEC_TO_SAMPS(a) (((a)*SOUND_DMA_SPEED) / 1000) // convert milliseconds to # samples in equivalent time
|
||
|
#define SEC_TO_SAMPS(a) ((a)*SOUND_DMA_SPEED) // convert seconds to # samples in equivalent time
|
||
|
|
||
|
// Suppress the noisy warnings caused by CLIP_DSP
|
||
|
#if defined(__clang__)
|
||
|
#pragma GCC diagnostic ignored "-Wself-assign"
|
||
|
#endif
|
||
|
#define CLIP_DSP(x) (x)
|
||
|
|
||
|
extern ConVar das_debug;
|
||
|
|
||
|
#define SOUND_MS_PER_FT 1 // sound travels approx 1 foot per millisecond
|
||
|
#define ROOM_MAX_SIZE 1000 // max size in feet of room simulation for dsp
|
||
|
|
||
|
void DSP_ReleaseMemory( void );
|
||
|
bool DSP_LoadPresetFile( void );
|
||
|
|
||
|
extern float Gain_To_dB ( float gain );
|
||
|
extern float dB_To_Gain ( float dB );
|
||
|
extern float Gain_To_Amplitude ( float gain );
|
||
|
extern float Amplitude_To_Gain ( float amplitude );
|
||
|
|
||
|
extern bool g_bdas_room_init;
|
||
|
extern bool g_bdas_init_nodes;
|
||
|
|
||
|
//===============================================================================
|
||
|
//
|
||
|
// Digital Signal Processing algorithms for audio FX.
|
||
|
//
|
||
|
// KellyB 2/18/03
|
||
|
//===============================================================================
|
||
|
|
||
|
// Performance notes:
|
||
|
|
||
|
// DSP processing should take no more than 3ms total time per frame to remain on par with hl1
|
||
|
// Assume a min frame rate of 24fps = 42ms per frame
|
||
|
// at 24fps, to maintain 44.1khz output rate, we must process about 1840 mono samples per frame.
|
||
|
// So we must process 1840 samples in 3ms.
|
||
|
|
||
|
// on a 1Ghz CPU (mid-low end CPU) 3ms provides roughly 3,000,000 cycles.
|
||
|
// Thus we have 3e6 / 1840 = 1630 cycles per sample.
|
||
|
|
||
|
#define PBITS 12 // parameter bits
|
||
|
#define PMAX ((1 << PBITS)) // parameter max
|
||
|
|
||
|
// crossfade from y2 to y1 at point r (0 < r < PMAX)
|
||
|
|
||
|
#define XFADE(y1,y2,r) ((y2) + ( ( ((y1) - (y2)) * (r) ) >> PBITS) )
|
||
|
|
||
|
// exponential crossfade from y2 to y1 at point r (0 < r < PMAX)
|
||
|
|
||
|
#define XFADE_EXP(y1, y2, r) ((y2) + ((((((y1) - (y2)) * (r) ) >> PBITS) * (r)) >> PBITS) )
|
||
|
|
||
|
/////////////////////
|
||
|
// dsp helpers
|
||
|
/////////////////////
|
||
|
|
||
|
// reverse delay pointer
|
||
|
|
||
|
inline void DlyPtrReverse (int dlysize, int *psamps, int **ppsamp)
|
||
|
{
|
||
|
// when *ppsamp = psamps - 1, it wraps around to *ppsamp = psamps + dlysize
|
||
|
|
||
|
if ( *ppsamp < psamps )
|
||
|
*ppsamp += dlysize + 1;
|
||
|
}
|
||
|
|
||
|
// advance delay pointer
|
||
|
|
||
|
inline void DlyPtrForward (int dlysize, int *psamps, int **ppsamp)
|
||
|
{
|
||
|
// when *ppsamp = psamps + dlysize + 1, it wraps around to *ppsamp = psamps
|
||
|
|
||
|
if ( *ppsamp > psamps + dlysize )
|
||
|
*ppsamp -= dlysize + 1;
|
||
|
}
|
||
|
|
||
|
// Infinite Impulse Response (feedback) filter, cannonical form
|
||
|
|
||
|
// returns single sample 'out' for current input value 'in'
|
||
|
// in: input sample
|
||
|
// psamp: internal state array, dimension max(cdenom,cnumer) + 1
|
||
|
// cnumer,cdenom: numerator and denominator filter orders
|
||
|
// denom,numer: cdenom+1 dimensional arrays of filter params
|
||
|
//
|
||
|
// for cdenom = 4:
|
||
|
//
|
||
|
// 1 psamp0(n) numer0
|
||
|
// in(n)--->(+)--(*)---.------(*)---->(+)---> out(n)
|
||
|
// ^ | ^
|
||
|
// | [Delay d] |
|
||
|
// | | |
|
||
|
// | -denom1 |psamp1 numer1 |
|
||
|
// ----(*)---.------(*)-------
|
||
|
// ^ | ^
|
||
|
// | [Delay d] |
|
||
|
// | | |
|
||
|
// | -denom2 |psamp2 numer2 |
|
||
|
// ----(*)---.------(*)-------
|
||
|
// ^ | ^
|
||
|
// | [Delay d] |
|
||
|
// | | |
|
||
|
// | -denom3 |psamp3 numer3 |
|
||
|
// ----(*)---.------(*)-------
|
||
|
// ^ | ^
|
||
|
// | [Delay d] |
|
||
|
// | | |
|
||
|
// | -denom4 |psamp4 numer4 |
|
||
|
// ----(*)---.------(*)-------
|
||
|
//
|
||
|
// for each input sample in:
|
||
|
// psamp0 = in - denom1*psamp1 - denom2*psamp2 - ...
|
||
|
// out = numer0*psamp0 + numer1*psamp1 + ...
|
||
|
// psampi = psampi-1, i = cmax, cmax-1, ..., 1
|
||
|
|
||
|
inline int IIRFilter_Update_OrderN ( int cdenom, int *denom, int cnumer, int *numer, int *psamp, int in )
|
||
|
{
|
||
|
int cmax, i;
|
||
|
int out;
|
||
|
int in0;
|
||
|
|
||
|
out = 0;
|
||
|
in0 = in;
|
||
|
|
||
|
cmax = max ( cdenom, cnumer );
|
||
|
|
||
|
// add input values
|
||
|
|
||
|
// for (i = 1; i <= cdenom; i++)
|
||
|
// psamp[0] -= ( denom[i] * psamp[i] ) >> PBITS;
|
||
|
|
||
|
switch (cdenom)
|
||
|
{
|
||
|
case 12: in0 -= ( denom[12] * psamp[12] ) >> PBITS;
|
||
|
case 11: in0 -= ( denom[11] * psamp[11] ) >> PBITS;
|
||
|
case 10: in0 -= ( denom[10] * psamp[10] ) >> PBITS;
|
||
|
case 9: in0 -= ( denom[9] * psamp[9] ) >> PBITS;
|
||
|
case 8: in0 -= ( denom[8] * psamp[8] ) >> PBITS;
|
||
|
case 7: in0 -= ( denom[7] * psamp[7] ) >> PBITS;
|
||
|
case 6: in0 -= ( denom[6] * psamp[6] ) >> PBITS;
|
||
|
case 5: in0 -= ( denom[5] * psamp[5] ) >> PBITS;
|
||
|
case 4: in0 -= ( denom[4] * psamp[4] ) >> PBITS;
|
||
|
case 3: in0 -= ( denom[3] * psamp[3] ) >> PBITS;
|
||
|
case 2: in0 -= ( denom[2] * psamp[2] ) >> PBITS;
|
||
|
default:
|
||
|
case 1: in0 -= ( denom[1] * psamp[1] ) >> PBITS;
|
||
|
}
|
||
|
|
||
|
psamp[0] = in0;
|
||
|
|
||
|
// add output values
|
||
|
|
||
|
//for (i = 0; i <= cnumer; i++)
|
||
|
// out += ( numer[i] * psamp[i] ) >> PBITS;
|
||
|
|
||
|
switch (cnumer)
|
||
|
{
|
||
|
case 12: out += ( numer[12] * psamp[12] ) >> PBITS;
|
||
|
case 11: out += ( numer[11] * psamp[11] ) >> PBITS;
|
||
|
case 10: out += ( numer[10] * psamp[10] ) >> PBITS;
|
||
|
case 9: out += ( numer[9] * psamp[9] ) >> PBITS;
|
||
|
case 8: out += ( numer[8] * psamp[8] ) >> PBITS;
|
||
|
case 7: out += ( numer[7] * psamp[7] ) >> PBITS;
|
||
|
case 6: out += ( numer[6] * psamp[6] ) >> PBITS;
|
||
|
case 5: out += ( numer[5] * psamp[5] ) >> PBITS;
|
||
|
case 4: out += ( numer[4] * psamp[4] ) >> PBITS;
|
||
|
case 3: out += ( numer[3] * psamp[3] ) >> PBITS;
|
||
|
case 2: out += ( numer[2] * psamp[2] ) >> PBITS;
|
||
|
default:
|
||
|
case 1: out += ( numer[1] * psamp[1] ) >> PBITS;
|
||
|
case 0: out += ( numer[0] * psamp[0] ) >> PBITS;
|
||
|
}
|
||
|
|
||
|
// update internal state (reverse order)
|
||
|
|
||
|
for (i = cmax; i >= 1; i--)
|
||
|
psamp[i] = psamp[i-1];
|
||
|
|
||
|
// return current output sample
|
||
|
|
||
|
return out;
|
||
|
}
|
||
|
|
||
|
// 1st order filter - faster version
|
||
|
|
||
|
inline int IIRFilter_Update_Order1 ( int *denom, int cnumer, int *numer, int *psamp, int in )
|
||
|
{
|
||
|
int out;
|
||
|
|
||
|
if (!psamp[0] && !psamp[1] && !in)
|
||
|
return 0;
|
||
|
|
||
|
psamp[0] = in - (( denom[1] * psamp[1] ) >> PBITS);
|
||
|
|
||
|
out = ( ( numer[1] * psamp[1] ) + ( numer[0] * psamp[0] ) ) >> PBITS;
|
||
|
|
||
|
psamp[1] = psamp[0];
|
||
|
|
||
|
return out;
|
||
|
}
|
||
|
|
||
|
// return 'tdelay' delayed sample from delay buffer
|
||
|
// dlysize: delay samples
|
||
|
// psamps: head of delay buffer psamps[0...dlysize]
|
||
|
// psamp: current data pointer
|
||
|
// sdly: 0...dlysize
|
||
|
|
||
|
inline int GetDly ( int dlysize, int *psamps, int *psamp, int tdelay )
|
||
|
{
|
||
|
int *pout;
|
||
|
|
||
|
pout = psamp + tdelay;
|
||
|
|
||
|
if ( pout <= (psamps + dlysize))
|
||
|
return *pout;
|
||
|
else
|
||
|
return *(pout - dlysize - 1);
|
||
|
}
|
||
|
|
||
|
// update the delay buffer pointer
|
||
|
// dlysize: delay samples
|
||
|
// psamps: head of delay buffer psamps[0...dlysize]
|
||
|
// ppsamp: data pointer
|
||
|
|
||
|
inline void DlyUpdate ( int dlysize, int *psamps, int **ppsamp )
|
||
|
{
|
||
|
// decrement pointer and fix up on buffer boundary
|
||
|
|
||
|
// when *ppsamp = psamps-1, it wraps around to *ppsamp = psamps+dlysize
|
||
|
|
||
|
(*ppsamp)--;
|
||
|
DlyPtrReverse ( dlysize, psamps, ppsamp );
|
||
|
}
|
||
|
|
||
|
// simple delay with feedback, no filter in feedback line.
|
||
|
// delaysize: delay line size in samples
|
||
|
// tdelay: tap from this location - <= delaysize
|
||
|
// psamps: delay line buffer pointer of dimension delaysize+1
|
||
|
// ppsamp: circular pointer, must be init to &psamps[0] before first call
|
||
|
// fbgain: feedback value, 0-PMAX (normalized to 0.0-1.0)
|
||
|
// outgain: gain
|
||
|
// in: input sample
|
||
|
|
||
|
// psamps0(n) outgain
|
||
|
// in(n)--->(+)--------.-----(*)-> out(n)
|
||
|
// ^ |
|
||
|
// | [Delay d]
|
||
|
// | |
|
||
|
// | fbgain |Wd(n)
|
||
|
// ----(*)---.
|
||
|
|
||
|
inline int ReverbSimple ( int delaysize, int tdelay, int *psamps, int **ppsamp, int fbgain, int outgain, int in )
|
||
|
{
|
||
|
int out, sD;
|
||
|
|
||
|
// get current delay output
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
|
||
|
// calculate output + delay * gain
|
||
|
|
||
|
out = in + (( fbgain * sD ) >> PBITS);
|
||
|
|
||
|
// write to delay
|
||
|
|
||
|
**ppsamp = out;
|
||
|
|
||
|
// advance internal delay pointers
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
inline int ReverbSimple_xfade ( int delaysize, int tdelay, int tdelaynew, int xf, int *psamps, int **ppsamp, int fbgain, int outgain, int in )
|
||
|
{
|
||
|
int out, sD;
|
||
|
int sDnew;
|
||
|
|
||
|
// crossfade from tdelay to tdelaynew samples. xfade is 0..PMAX
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
sDnew = GetDly ( delaysize, psamps, *ppsamp, tdelaynew );
|
||
|
sD = sD + (((sDnew - sD) * xf) >> PBITS);
|
||
|
|
||
|
out = in + (( fbgain * sD ) >> PBITS);
|
||
|
**ppsamp = out;
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
// multitap simple reverb
|
||
|
|
||
|
// NOTE: tdelay3 > tdelay2 > tdelay1 > t0
|
||
|
// NOTE: fbgain * 4 < 1!
|
||
|
|
||
|
inline int ReverbSimple_multitap ( int delaysize, int tdelay0, int tdelay1, int tdelay2, int tdelay3, int *psamps, int **ppsamp, int fbgain, int outgain, int in )
|
||
|
{
|
||
|
int s1, s2, s3, s4, sum;
|
||
|
|
||
|
s1 = GetDly ( delaysize, psamps, *ppsamp, tdelay0 );
|
||
|
s2 = GetDly ( delaysize, psamps, *ppsamp, tdelay1 );
|
||
|
s3 = GetDly ( delaysize, psamps, *ppsamp, tdelay2 );
|
||
|
s4 = GetDly ( delaysize, psamps, *ppsamp, tdelay3 );
|
||
|
|
||
|
sum = s1 + s2 + s3 + s4;
|
||
|
|
||
|
// write to delay
|
||
|
|
||
|
**ppsamp = in + ((s4 * fbgain) >> PBITS);
|
||
|
|
||
|
// update delay pointers
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( ((sum + in) * outgain ) >> PBITS );
|
||
|
}
|
||
|
|
||
|
// modulate smallest tap delay only
|
||
|
|
||
|
inline int ReverbSimple_multitap_xfade ( int delaysize, int tdelay0, int tdelaynew, int xf, int tdelay1, int tdelay2, int tdelay3, int *psamps, int **ppsamp, int fbgain, int outgain, int in )
|
||
|
{
|
||
|
int s1, s2, s3, s4, sum;
|
||
|
int sD, sDnew;
|
||
|
|
||
|
// crossfade from tdelay to tdelaynew tap. xfade is 0..PMAX
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay3 );
|
||
|
sDnew = GetDly ( delaysize, psamps, *ppsamp, tdelaynew );
|
||
|
|
||
|
s4 = sD + (((sDnew - sD) * xf) >> PBITS);
|
||
|
|
||
|
s1 = GetDly ( delaysize, psamps, *ppsamp, tdelay0 );
|
||
|
s2 = GetDly ( delaysize, psamps, *ppsamp, tdelay1 );
|
||
|
s3 = GetDly ( delaysize, psamps, *ppsamp, tdelay2 );
|
||
|
|
||
|
sum = s1 + s2 + s3 + s4;
|
||
|
|
||
|
// write to delay
|
||
|
|
||
|
**ppsamp = in + ((s4 * fbgain) >> PBITS);
|
||
|
|
||
|
// update delay pointers
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( ((sum + in) * outgain ) >> PBITS );
|
||
|
}
|
||
|
|
||
|
// straight delay, no feedback
|
||
|
//
|
||
|
// delaysize: delay line size in samples
|
||
|
// tdelay: tap from this location - <= delaysize
|
||
|
// psamps: delay line buffer pointer of dimension delaysize+1
|
||
|
// ppsamp: circular pointer, must be init to &psamps[0] before first call
|
||
|
// in: input sample
|
||
|
//
|
||
|
// in(n)--->[Delay d]---> out(n)
|
||
|
//
|
||
|
|
||
|
inline int DelayLinear ( int delaysize, int tdelay, int *psamps, int **ppsamp, int in )
|
||
|
{
|
||
|
int out;
|
||
|
|
||
|
out = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
|
||
|
**ppsamp = in;
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( out );
|
||
|
}
|
||
|
|
||
|
// crossfade delay values from tdelay to tdelaynew, with xfade1 for tdelay and xfade2 for tdelaynew. xfade = 0...PMAX
|
||
|
|
||
|
inline int DelayLinear_xfade ( int delaysize, int tdelay, int tdelaynew, int xf, int *psamps, int **ppsamp, int in )
|
||
|
{
|
||
|
int out;
|
||
|
int outnew;
|
||
|
|
||
|
out = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
|
||
|
outnew = GetDly ( delaysize, psamps, *ppsamp, tdelaynew );
|
||
|
|
||
|
out = out + (((outnew - out) * xf) >> PBITS);
|
||
|
|
||
|
**ppsamp = in;
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( out );
|
||
|
}
|
||
|
|
||
|
// lowpass reverberator, replace feedback multiplier 'fbgain' in
|
||
|
// reverberator with a low pass filter
|
||
|
|
||
|
// delaysize: delay line size in samples
|
||
|
// tdelay: tap from this location - <= delaysize
|
||
|
// psamps: delay line buffer pointer of dimension delaysize+1
|
||
|
// ppsamp: circular pointer, must be init to &w[0] before first call
|
||
|
// fbgain: feedback gain (built into filter gain)
|
||
|
// outgain: output gain
|
||
|
// cnumer: filter order
|
||
|
// numer: filter numerator, 0-PMAX (normalized to 0.0-1.0), cnumer+1 dimensional
|
||
|
// denom: filter denominator, 0-PMAX (normalized to 0.0-1.0), cnumer+1 dimensional
|
||
|
// pfsamps: filter state, cnumer+1 dimensional
|
||
|
// in: input sample
|
||
|
|
||
|
// psamps0(n) outgain
|
||
|
// in(n)--->(+)--------------.----(*)--> out(n)
|
||
|
// ^ |
|
||
|
// | [Delay d]
|
||
|
// | |
|
||
|
// | fbgain |Wd(n)
|
||
|
// --(*)--[Filter])-
|
||
|
|
||
|
inline int DelayLowpass ( int delaysize, int tdelay, int *psamps, int **ppsamp, int fbgain, int outgain, int *denom, int Ll, int *numer, int *pfsamps, int in )
|
||
|
{
|
||
|
int out, sD;
|
||
|
|
||
|
// delay output is filter input
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
|
||
|
// filter output, with feedback 'fbgain' baked into filter params
|
||
|
|
||
|
out = in + IIRFilter_Update_Order1 ( denom, Ll, numer, pfsamps, sD );
|
||
|
|
||
|
// write to delay
|
||
|
|
||
|
**ppsamp = out;
|
||
|
|
||
|
// update delay pointers
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
// output with gain
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
inline int DelayLowpass_xfade ( int delaysize, int tdelay, int tdelaynew, int xf, int *psamps, int **ppsamp, int fbgain, int outgain, int *denom, int Ll, int *numer, int *pfsamps, int in )
|
||
|
{
|
||
|
int out, sD;
|
||
|
int sDnew;
|
||
|
|
||
|
// crossfade from tdelay to tdelaynew tap. xfade is 0..PMAX
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
sDnew = GetDly ( delaysize, psamps, *ppsamp, tdelaynew );
|
||
|
sD = sD + (((sDnew - sD) * xf) >> PBITS);
|
||
|
|
||
|
// filter output with feedback 'fbgain' baked into filter params
|
||
|
|
||
|
out = in + IIRFilter_Update_Order1 ( denom, Ll, numer, pfsamps, sD );
|
||
|
|
||
|
// write to delay
|
||
|
|
||
|
**ppsamp = out;
|
||
|
|
||
|
// update delay ptrs
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
// output with gain
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
// delay is multitap tdelay0,tdelay1,tdelay2,tdelay3
|
||
|
|
||
|
// NOTE: tdelay3 > tdelay2 > tdelay1 > tdelay0
|
||
|
// NOTE: fbgain * 4 < 1!
|
||
|
|
||
|
inline int DelayLowpass_multitap ( int delaysize, int tdelay0, int tdelay1, int tdelay2, int tdelay3, int *psamps, int **ppsamp, int fbgain, int outgain, int *denom, int Ll, int *numer, int *pfsamps, int in )
|
||
|
{
|
||
|
int s0, s1, s2, s3, s4, sum;
|
||
|
|
||
|
s1 = GetDly ( delaysize, psamps, *ppsamp, tdelay0 );
|
||
|
s2 = GetDly ( delaysize, psamps, *ppsamp, tdelay1 );
|
||
|
s3 = GetDly ( delaysize, psamps, *ppsamp, tdelay2 );
|
||
|
s4 = GetDly ( delaysize, psamps, *ppsamp, tdelay3 );
|
||
|
|
||
|
sum = s1 + s2 + s3 + s4;
|
||
|
|
||
|
s0 = in + IIRFilter_Update_Order1 ( denom, Ll, numer, pfsamps, s4 );
|
||
|
|
||
|
// write to delay
|
||
|
|
||
|
**ppsamp = s0;
|
||
|
|
||
|
// update delay ptrs
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( ((sum + in) * outgain ) >> PBITS );
|
||
|
}
|
||
|
|
||
|
inline int DelayLowpass_multitap_xfade ( int delaysize, int tdelay0, int tdelaynew, int xf, int tdelay1, int tdelay2, int tdelay3, int *psamps, int **ppsamp, int fbgain, int outgain, int *denom, int Ll, int *numer, int *pfsamps, int in )
|
||
|
{
|
||
|
int s0, s1, s2, s3, s4, sum;
|
||
|
|
||
|
int sD, sDnew;
|
||
|
|
||
|
// crossfade from tdelay to tdelaynew tap. xfade is 0..PMAX
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay3 );
|
||
|
sDnew = GetDly ( delaysize, psamps, *ppsamp, tdelaynew );
|
||
|
|
||
|
s4 = sD + (((sDnew - sD) * xf) >> PBITS);
|
||
|
|
||
|
s1 = GetDly ( delaysize, psamps, *ppsamp, tdelay0 );
|
||
|
s2 = GetDly ( delaysize, psamps, *ppsamp, tdelay1 );
|
||
|
s3 = GetDly ( delaysize, psamps, *ppsamp, tdelay2 );
|
||
|
|
||
|
sum = s1 + s2 + s3 + s4;
|
||
|
|
||
|
s0 = in + IIRFilter_Update_Order1 ( denom, Ll, numer, pfsamps, s4 );
|
||
|
|
||
|
**ppsamp = s0;
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( ((sum + in) * outgain ) >> PBITS );
|
||
|
}
|
||
|
|
||
|
// linear delay with lowpass filter on delay output and gain stage
|
||
|
// delaysize: delay line size in samples
|
||
|
// tdelay: delay tap from this location - <= delaysize
|
||
|
// psamps: delay line buffer pointer of dimension delaysize+1
|
||
|
// ppsamp: circular pointer, must init &psamps[0] before first call
|
||
|
// fbgain: feedback gain (ignored)
|
||
|
// outgain: output gain
|
||
|
// cnumer: filter order
|
||
|
// numer: filter numerator, 0-PMAX (normalized to 0.0-1.0), cnumer+1 dimensional
|
||
|
// denom: filter denominator, 0-PMAX (normalized to 0.0-1.0), cnumer+1 dimensional
|
||
|
// pfsamps: filter state, cnumer+1 dimensional
|
||
|
// in: input sample
|
||
|
|
||
|
// in(n)--->[Delay d]--->[Filter]-->(*outgain)---> out(n)
|
||
|
|
||
|
inline int DelayLinear_lowpass ( int delaysize, int tdelay, int *psamps, int **ppsamp, int fbgain, int outgain, int *denom, int cnumer, int *numer, int *pfsamps, int in )
|
||
|
{
|
||
|
int out, sD;
|
||
|
|
||
|
// delay output is filter input
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
|
||
|
// calc filter output
|
||
|
|
||
|
out = IIRFilter_Update_Order1 ( denom, cnumer, numer, pfsamps, sD );
|
||
|
|
||
|
// input sample to delay input
|
||
|
|
||
|
**ppsamp = in;
|
||
|
|
||
|
// update delay pointers
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
// output with gain
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
inline int DelayLinear_lowpass_xfade ( int delaysize, int tdelay, int tdelaynew, int xf, int *psamps, int **ppsamp, int fbgain, int outgain, int *denom, int cnumer, int *numer, int *pfsamps, int in )
|
||
|
{
|
||
|
int out, sD;
|
||
|
int sDnew;
|
||
|
|
||
|
// crossfade from tdelay to tdelaynew tap. xfade is 0..PMAX
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
sDnew = GetDly ( delaysize, psamps, *ppsamp, tdelaynew );
|
||
|
sD = sD + (((sDnew - sD) * xf) >> PBITS);
|
||
|
|
||
|
out = IIRFilter_Update_Order1 ( denom, cnumer, numer, pfsamps, sD );
|
||
|
|
||
|
**ppsamp = in;
|
||
|
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
|
||
|
// classic allpass reverb
|
||
|
// delaysize: delay line size in samples
|
||
|
// tdelay: tap from this location - <= D
|
||
|
// psamps: delay line buffer pointer of dimension delaysize+1
|
||
|
// ppsamp: circular pointer, must be init to &psamps[0] before first call
|
||
|
// fbgain: feedback value, 0-PMAX (normalized to 0.0-1.0)
|
||
|
// outgain: gain
|
||
|
|
||
|
// psamps0(n) -fbgain outgain
|
||
|
// in(n)--->(+)--------.-----(*)-->(+)--(*)-> out(n)
|
||
|
// ^ | ^
|
||
|
// | [Delay d] |
|
||
|
// | | |
|
||
|
// | fbgain |psampsd(n) |
|
||
|
// ----(*)---.-------------
|
||
|
//
|
||
|
// for each input sample 'in':
|
||
|
// psamps0 = in + fbgain * psampsd
|
||
|
// y = -fbgain * psamps0 + psampsd
|
||
|
// delay (d, psamps) - psamps is the delay buffer array
|
||
|
//
|
||
|
// or, using circular delay, for each input sample 'in':
|
||
|
//
|
||
|
// Sd = GetDly (delaysize,psamps,ppsamp,delaysize)
|
||
|
// S0 = in + fbgain*Sd
|
||
|
// y = -fbgain*S0 + Sd
|
||
|
// *ppsamp = S0
|
||
|
// DlyUpdate(delaysize, psamps, &ppsamp)
|
||
|
|
||
|
inline int DelayAllpass ( int delaysize, int tdelay, int *psamps, int **ppsamp, int fbgain, int outgain, int in )
|
||
|
{
|
||
|
int out, s0, sD;
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
s0 = in + (( fbgain * sD ) >> PBITS);
|
||
|
|
||
|
out = ( ( -fbgain * s0 ) >> PBITS ) + sD;
|
||
|
**ppsamp = s0;
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
|
||
|
inline int DelayAllpass_xfade ( int delaysize, int tdelay, int tdelaynew, int xf, int *psamps, int **ppsamp, int fbgain, int outgain, int in )
|
||
|
{
|
||
|
int out, s0, sD;
|
||
|
int sDnew;
|
||
|
|
||
|
// crossfade from t to tnew tap. xfade is 0..PMAX
|
||
|
|
||
|
sD = GetDly ( delaysize, psamps, *ppsamp, tdelay );
|
||
|
sDnew = GetDly ( delaysize, psamps, *ppsamp, tdelaynew );
|
||
|
sD = sD + (((sDnew - sD) * xf) >> PBITS);
|
||
|
|
||
|
s0 = in + (( fbgain * sD ) >> PBITS);
|
||
|
|
||
|
out = ( ( -fbgain * s0 ) >> PBITS ) + sD;
|
||
|
**ppsamp = s0;
|
||
|
DlyUpdate ( delaysize, psamps, ppsamp );
|
||
|
|
||
|
return ( (out * outgain) >> PBITS );
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////
|
||
|
// fixed point math for real-time wave table traversing, pitch shifting, resampling
|
||
|
///////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
#define FIX20_BITS 20 // 20 bits of fractional part
|
||
|
#define FIX20_SCALE (1 << FIX20_BITS)
|
||
|
|
||
|
#define FIX20_INTMAX ((1 << (32 - FIX20_BITS))-1) // maximum step integer
|
||
|
|
||
|
#define FLOAT_TO_FIX20(a) ((int)((a) * (float)FIX20_SCALE)) // convert float to fixed point
|
||
|
#define INT_TO_FIX20(a) (((int)(a)) << FIX20_BITS) // convert int to fixed point
|
||
|
#define FIX20_TO_FLOAT(a) ((float)(a) / (float)FIX20_SCALE) // convert fix20 to float
|
||
|
#define FIX20_INTPART(a) (((int)(a)) >> FIX20_BITS) // get integer part of fixed point
|
||
|
#define FIX20_FRACPART(a) ((a) - (((a) >> FIX20_BITS) << FIX20_BITS)) // get fractional part of fixed point
|
||
|
|
||
|
#define FIX20_FRACTION(a,b) (FIX(a)/(b)) // convert int a to fixed point, divide by b
|
||
|
|
||
|
typedef int fix20int;
|
||
|
|
||
|
/////////////////////////////////
|
||
|
// DSP processor parameter block
|
||
|
/////////////////////////////////
|
||
|
|
||
|
// NOTE: these prototypes must match the XXX_Params ( prc_t *pprc ) and XXX_GetNext ( XXX_t *p, int x ) functions
|
||
|
|
||
|
typedef void * (*prc_Param_t)( void *pprc ); // individual processor allocation functions
|
||
|
typedef int (*prc_GetNext_t) ( void *pdata, int x ); // get next function for processor
|
||
|
typedef int (*prc_GetNextN_t) ( void *pdata, portable_samplepair_t *pbuffer, int SampleCount, int op); // batch version of getnext
|
||
|
typedef void (*prc_Free_t) ( void *pdata ); // free function for processor
|
||
|
typedef void (*prc_Mod_t) (void *pdata, float v); // modulation function for processor
|
||
|
|
||
|
#define OP_LEFT 0 // batch process left channel in place
|
||
|
#define OP_RIGHT 1 // batch process right channel in place
|
||
|
#define OP_LEFT_DUPLICATE 2 // batch process left channel in place, duplicate to right channel
|
||
|
|
||
|
#define PRC_NULL 0 // pass through - must be 0
|
||
|
#define PRC_DLY 1 // simple feedback reverb
|
||
|
#define PRC_RVA 2 // parallel reverbs
|
||
|
#define PRC_FLT 3 // lowpass or highpass filter
|
||
|
#define PRC_CRS 4 // chorus
|
||
|
#define PRC_PTC 5 // pitch shifter
|
||
|
#define PRC_ENV 6 // adsr envelope
|
||
|
#define PRC_LFO 7 // lfo
|
||
|
#define PRC_EFO 8 // envelope follower
|
||
|
#define PRC_MDY 9 // mod delay
|
||
|
#define PRC_DFR 10 // diffusor - n series allpass delays
|
||
|
#define PRC_AMP 11 // amplifier with distortion
|
||
|
|
||
|
#define QUA_LO 0 // quality of filter or reverb. Must be 0,1,2,3.
|
||
|
#define QUA_MED 1
|
||
|
#define QUA_HI 2
|
||
|
#define QUA_VHI 3
|
||
|
#define QUA_MAX QUA_VHI
|
||
|
|
||
|
#define CPRCPARAMS 16 // up to 16 floating point params for each processor type
|
||
|
|
||
|
// processor definition - one for each running instance of a dsp processor
|
||
|
|
||
|
struct prc_t
|
||
|
{
|
||
|
int type; // PRC type
|
||
|
|
||
|
float prm[CPRCPARAMS]; // dsp processor parameters - array of floats
|
||
|
|
||
|
prc_Param_t pfnParam; // allocation function - takes ptr to prc, returns ptr to specialized data struct for proc type
|
||
|
prc_GetNext_t pfnGetNext; // get next function
|
||
|
prc_GetNextN_t pfnGetNextN; // batch version of get next
|
||
|
prc_Free_t pfnFree; // free function
|
||
|
prc_Mod_t pfnMod; // modulation function
|
||
|
|
||
|
void *pdata; // processor state data - ie: pdly, pflt etc.
|
||
|
};
|
||
|
|
||
|
// processor parameter ranges - for validating parameters during allocation of new processor
|
||
|
|
||
|
typedef struct prm_rng_t
|
||
|
{
|
||
|
int iprm; // parameter index
|
||
|
float lo; // min value of parameter
|
||
|
float hi; // max value of parameter
|
||
|
} prm_rng_s;
|
||
|
|
||
|
void PRC_CheckParams ( prc_t *pprc, prm_rng_t *prng );
|
||
|
|
||
|
///////////
|
||
|
// Filters
|
||
|
///////////
|
||
|
|
||
|
#define CFLTS 64 // max number of filters simultaneously active
|
||
|
#define FLT_M 12 // max order of any filter
|
||
|
|
||
|
#define FLT_LP 0 // lowpass filter
|
||
|
#define FLT_HP 1 // highpass filter
|
||
|
#define FLT_BP 2 // bandpass filter
|
||
|
#define FTR_MAX FLT_BP
|
||
|
|
||
|
// flt parameters
|
||
|
|
||
|
struct flt_t
|
||
|
{
|
||
|
bool fused; // true if slot in use
|
||
|
|
||
|
int b[FLT_M+1]; // filter numerator parameters (convert 0.0-1.0 to 0-PMAX representation)
|
||
|
int a[FLT_M+1]; // filter denominator parameters (convert 0.0-1.0 to 0-PMAX representation)
|
||
|
int w[FLT_M+1]; // filter state - samples (dimension of max (M, L))
|
||
|
int L; // filter order numerator (dimension of a[M+1])
|
||
|
int M; // filter order denominator (dimension of b[L+1])
|
||
|
int N; // # of series sections - 1 (0 = 1 section, 1 = 2 sections etc)
|
||
|
|
||
|
flt_t *pf1; // series cascaded versions of filter
|
||
|
flt_t *pf2;
|
||
|
flt_t *pf3;
|
||
|
};
|
||
|
|
||
|
// flt flts
|
||
|
|
||
|
flt_t flts[CFLTS];
|
||
|
|
||
|
void FLT_Init ( flt_t *pf ) { if ( pf ) Q_memset ( pf, 0, sizeof (flt_t) ); }
|
||
|
void FLT_InitAll ( void ) { for ( int i = 0 ; i < CFLTS; i++ ) FLT_Init ( &flts[i] ); }
|
||
|
|
||
|
void FLT_Free ( flt_t *pf )
|
||
|
{
|
||
|
if ( pf )
|
||
|
{
|
||
|
if (pf->pf1)
|
||
|
Q_memset ( pf->pf1, 0, sizeof (flt_t) );
|
||
|
|
||
|
if (pf->pf2)
|
||
|
Q_memset ( pf->pf2, 0, sizeof (flt_t) );
|
||
|
|
||
|
if (pf->pf3)
|
||
|
Q_memset ( pf->pf3, 0, sizeof (flt_t) );
|
||
|
|
||
|
Q_memset ( pf, 0, sizeof (flt_t) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void FLT_FreeAll ( void ) { for (int i = 0 ; i < CFLTS; i++) FLT_Free ( &flts[i] ); }
|
||
|
|
||
|
|
||
|
// find a free filter from the filter pool
|
||
|
// initialize filter numerator, denominator b[0..M], a[0..L]
|
||
|
// gain scales filter numerator
|
||
|
// N is # of series sections - 1
|
||
|
|
||
|
flt_t * FLT_Alloc ( int N, int M, int L, int *a, int *b, float gain )
|
||
|
{
|
||
|
int i, j;
|
||
|
flt_t *pf = NULL;
|
||
|
|
||
|
for (i = 0; i < CFLTS; i++)
|
||
|
{
|
||
|
if ( !flts[i].fused )
|
||
|
{
|
||
|
pf = &flts[i];
|
||
|
|
||
|
// transfer filter params into filter struct
|
||
|
pf->M = M;
|
||
|
pf->L = L;
|
||
|
pf->N = N;
|
||
|
|
||
|
for (j = 0; j <= M; j++)
|
||
|
pf->a[j] = a[j];
|
||
|
|
||
|
for (j = 0; j <= L; j++)
|
||
|
pf->b[j] = (int)((float)(b[j]) * gain);
|
||
|
|
||
|
pf->pf1 = NULL;
|
||
|
pf->pf2 = NULL;
|
||
|
pf->pf3 = NULL;
|
||
|
|
||
|
pf->fused = true;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Assert(pf); // make sure we're not trying to alloc more than CFLTS flts
|
||
|
|
||
|
return pf;
|
||
|
}
|
||
|
|
||
|
// convert filter params cutoff and type into
|
||
|
// iir transfer function params M, L, a[], b[]
|
||
|
|
||
|
// iir filter, 1st order, transfer function is H(z) = b0 + b1 Z^-1 / a0 + a1 Z^-1
|
||
|
// or H(z) = b0 - b1 Z^-1 / a0 + a1 Z^-1 for lowpass
|
||
|
|
||
|
// design cutoff filter at 3db (.5 gain) p579
|
||
|
|
||
|
void FLT_Design_3db_IIR ( float cutoff, float ftype, int *pM, int *pL, int *a, int *b )
|
||
|
{
|
||
|
// ftype: FLT_LP, FLT_HP, FLT_BP
|
||
|
|
||
|
double Wc = 2.0 * M_PI * cutoff / SOUND_DMA_SPEED; // radians per sample
|
||
|
double Oc;
|
||
|
double fa;
|
||
|
double fb;
|
||
|
|
||
|
// calculations:
|
||
|
// Wc = 2pi * fc/44100 convert to radians
|
||
|
// Oc = tan (Wc/2) * Gc / sqt ( 1 - Gc^2) get analog version, low pass
|
||
|
// Oc = tan (Wc/2) * (sqt (1 - Gc^2)) / Gc analog version, high pass
|
||
|
// Gc = 10 ^ (-Ac/20) gain at cutoff. Ac = 3db, so Gc^2 = 0.5
|
||
|
// a = ( 1 - Oc ) / ( 1 + Oc )
|
||
|
// b = ( 1 - a ) / 2
|
||
|
|
||
|
Oc = tan ( Wc / 2.0 );
|
||
|
|
||
|
fa = ( 1.0 - Oc ) / ( 1.0 + Oc );
|
||
|
|
||
|
fb = ( 1.0 - fa ) / 2.0;
|
||
|
|
||
|
if ( ftype == FLT_HP )
|
||
|
fb = ( 1.0 + fa ) / 2.0;
|
||
|
|
||
|
a[0] = 0; // a0 always ignored
|
||
|
a[1] = (int)( -fa * PMAX ); // quantize params down to 0-PMAX >> PBITS
|
||
|
b[0] = (int)( fb * PMAX );
|
||
|
b[1] = b[0];
|
||
|
|
||
|
if ( ftype == FLT_HP )
|
||
|
b[1] = -b[1];
|
||
|
|
||
|
*pM = *pL = 1;
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// filter parameter order
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
flt_iftype,
|
||
|
flt_icutoff,
|
||
|
flt_iqwidth,
|
||
|
flt_iquality,
|
||
|
flt_igain,
|
||
|
|
||
|
flt_cparam // # of params
|
||
|
} flt_e;
|
||
|
|
||
|
// filter parameter ranges
|
||
|
|
||
|
prm_rng_t flt_rng[] = {
|
||
|
|
||
|
{flt_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{flt_iftype, 0, FTR_MAX}, // filter type FLT_LP, FLT_HP, FLT_BP
|
||
|
{flt_icutoff, 10, 22050}, // cutoff frequency in hz at -3db gain
|
||
|
{flt_iqwidth, 0, 11025}, // width of BP (cut in starts at cutoff)
|
||
|
{flt_iquality, 0, QUA_MAX}, // QUA_LO, _MED, _HI, _VHI = # of series sections
|
||
|
{flt_igain, 0.0, 10.0}, // output gain 0-10.0
|
||
|
};
|
||
|
|
||
|
|
||
|
// convert prc float params to iir filter params, alloc filter and return ptr to it
|
||
|
// filter quality set by prc quality - 0,1,2
|
||
|
|
||
|
flt_t * FLT_Params ( prc_t *pprc )
|
||
|
{
|
||
|
float qual = pprc->prm[flt_iquality];
|
||
|
float cutoff = pprc->prm[flt_icutoff];
|
||
|
float ftype = pprc->prm[flt_iftype];
|
||
|
float qwidth = pprc->prm[flt_iqwidth];
|
||
|
float gain = pprc->prm[flt_igain];
|
||
|
|
||
|
int L = 0; // numerator order
|
||
|
int M = 0; // denominator order
|
||
|
int b[FLT_M+1]; // numerator params 0..PMAX
|
||
|
int b_scaled[FLT_M+1]; // gain scaled numerator
|
||
|
int a[FLT_M+1]; // denominator params 0..PMAX
|
||
|
|
||
|
int L_bp = 0; // bandpass numerator order
|
||
|
int M_bp = 0; // bandpass denominator order
|
||
|
int b_bp[FLT_M+1]; // bandpass numerator params 0..PMAX
|
||
|
int b_bp_scaled[FLT_M+1]; // gain scaled numerator
|
||
|
int a_bp[FLT_M+1]; // bandpass denominator params 0..PMAX
|
||
|
|
||
|
int N; // # of series sections
|
||
|
bool bpass = false;
|
||
|
|
||
|
// if qwidth > 0 then alloc bandpass filter (pf is lowpass)
|
||
|
|
||
|
if ( qwidth > 0.0 )
|
||
|
bpass = true;
|
||
|
|
||
|
if (bpass)
|
||
|
{
|
||
|
ftype = FLT_LP;
|
||
|
}
|
||
|
|
||
|
// low pass and highpass filter design
|
||
|
|
||
|
// 1st order IIR filter, 3db cutoff at fc
|
||
|
|
||
|
if ( bpass )
|
||
|
{
|
||
|
// highpass section
|
||
|
|
||
|
FLT_Design_3db_IIR ( cutoff, FLT_HP, &M_bp, &L_bp, a_bp, b_bp );
|
||
|
M_bp = clamp (M_bp, 1, FLT_M);
|
||
|
L_bp = clamp (L_bp, 1, FLT_M);
|
||
|
cutoff += qwidth;
|
||
|
}
|
||
|
|
||
|
// lowpass section
|
||
|
|
||
|
FLT_Design_3db_IIR ( cutoff, (int)ftype, &M, &L, a, b );
|
||
|
|
||
|
M = clamp (M, 1, FLT_M);
|
||
|
L = clamp (L, 1, FLT_M);
|
||
|
|
||
|
// quality = # of series sections - 1
|
||
|
|
||
|
N = clamp ((int)qual, 0, 3);
|
||
|
|
||
|
// make sure we alloc at least 2 filters
|
||
|
|
||
|
if (bpass)
|
||
|
N = max(N, 1);
|
||
|
|
||
|
flt_t *pf0 = NULL;
|
||
|
flt_t *pf1 = NULL;
|
||
|
flt_t *pf2 = NULL;
|
||
|
flt_t *pf3 = NULL;
|
||
|
|
||
|
// scale b numerators with gain - only scale for first filter if series filters
|
||
|
|
||
|
for (int i = 0; i < FLT_M; i++)
|
||
|
{
|
||
|
b_bp_scaled[i] = (int)((float)(b_bp[i]) * gain );
|
||
|
b_scaled[i] = (int)((float)(b[i]) * gain );
|
||
|
}
|
||
|
|
||
|
if (bpass)
|
||
|
{
|
||
|
// 1st filter is lowpass
|
||
|
|
||
|
pf0 = FLT_Alloc ( N, M_bp, L_bp, a_bp, b_bp_scaled, 1.0 );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pf0 = FLT_Alloc ( N, M, L, a, b_scaled, 1.0 );
|
||
|
}
|
||
|
|
||
|
// allocate series filters
|
||
|
|
||
|
if (pf0)
|
||
|
{
|
||
|
switch (N)
|
||
|
{
|
||
|
case 3:
|
||
|
// alloc last filter as lowpass also if FLT_BP
|
||
|
if (bpass)
|
||
|
pf3 = FLT_Alloc ( 0, M_bp, L_bp, a_bp, b_bp, 1.0 );
|
||
|
else
|
||
|
pf3 = FLT_Alloc ( 0, M, L, a, b, 1.0 );
|
||
|
case 2:
|
||
|
pf2 = FLT_Alloc ( 0, M, L, a, b, 1.0 );
|
||
|
case 1:
|
||
|
pf1 = FLT_Alloc ( 0, M, L, a, b, 1.0 );
|
||
|
case 0:
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
pf0->pf1 = pf1;
|
||
|
pf0->pf2 = pf2;
|
||
|
pf0->pf3 = pf3;
|
||
|
}
|
||
|
|
||
|
return pf0;
|
||
|
}
|
||
|
|
||
|
inline void * FLT_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams( (prc_t *)p, flt_rng);
|
||
|
return (void *) FLT_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
inline void FLT_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
// get next filter value for filter pf and input x
|
||
|
|
||
|
inline int FLT_GetNext ( flt_t *pf, int x )
|
||
|
{
|
||
|
flt_t *pf1;
|
||
|
flt_t *pf2;
|
||
|
flt_t *pf3;
|
||
|
int y;
|
||
|
|
||
|
switch( pf->N )
|
||
|
{
|
||
|
default:
|
||
|
case 0:
|
||
|
return IIRFilter_Update_Order1(pf->a, pf->L, pf->b, pf->w, x);
|
||
|
case 1:
|
||
|
pf1 = pf->pf1;
|
||
|
|
||
|
y = IIRFilter_Update_Order1(pf->a, pf->L, pf->b, pf->w, x);
|
||
|
return IIRFilter_Update_Order1(pf1->a, pf1->L, pf1->b, pf1->w, y);
|
||
|
case 2:
|
||
|
pf1 = pf->pf1;
|
||
|
pf2 = pf->pf2;
|
||
|
|
||
|
y = IIRFilter_Update_Order1(pf->a, pf->L, pf->b, pf->w, x);
|
||
|
y = IIRFilter_Update_Order1(pf1->a, pf1->L, pf1->b, pf1->w, y);
|
||
|
return IIRFilter_Update_Order1(pf2->a, pf2->L, pf2->b, pf2->w, y);
|
||
|
case 3:
|
||
|
pf1 = pf->pf1;
|
||
|
pf2 = pf->pf2;
|
||
|
pf3 = pf->pf3;
|
||
|
|
||
|
y = IIRFilter_Update_Order1(pf->a, pf->L, pf->b, pf->w, x);
|
||
|
y = IIRFilter_Update_Order1(pf1->a, pf1->L, pf1->b, pf1->w, y);
|
||
|
y = IIRFilter_Update_Order1(pf2->a, pf2->L, pf2->b, pf2->w, y);
|
||
|
return IIRFilter_Update_Order1(pf3->a, pf3->L, pf3->b, pf3->w, y);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void FLT_GetNextN( flt_t *pflt, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = FLT_GetNext( pflt, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = FLT_GetNext( pflt, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = FLT_GetNext( pflt, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////
|
||
|
// Positional updaters for pitch shift etc
|
||
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
// looping position within a wav, with integer and fractional parts
|
||
|
// used for pitch shifting, upsampling/downsampling
|
||
|
// 20 bits of fraction, 8+ bits of integer
|
||
|
|
||
|
struct pos_t
|
||
|
{
|
||
|
|
||
|
fix20int step; // wave table whole and fractional step value
|
||
|
fix20int cstep; // current cummulative step value
|
||
|
int pos; // current position within wav table
|
||
|
|
||
|
int D; // max dimension of array w[0...D] ie: # of samples = D+1
|
||
|
};
|
||
|
|
||
|
// circular wrap of pointer p, relative to array w
|
||
|
// D max buffer index w[0...D] (count of samples in buffer is D+1)
|
||
|
// i circular index
|
||
|
|
||
|
inline void POS_Wrap ( int D, int *i )
|
||
|
{
|
||
|
if ( *i > D )
|
||
|
*i -= D + 1; // when *pi = D + 1, it wraps around to *pi = 0
|
||
|
|
||
|
if ( *i < 0 )
|
||
|
*i += D + 1; // when *pi = - 1, it wraps around to *pi = D
|
||
|
}
|
||
|
|
||
|
// set initial update value - fstep can have no more than 8 bits of integer and 20 bits of fract
|
||
|
// D is array max dimension w[0...D] (ie: size D+1)
|
||
|
// w is ptr to array
|
||
|
// p is ptr to pos_t to initialize
|
||
|
|
||
|
inline void POS_Init( pos_t *p, int D, float fstep )
|
||
|
{
|
||
|
float step = fstep;
|
||
|
|
||
|
// make sure int part of step is capped at fix20_intmax
|
||
|
|
||
|
if ((int)step > FIX20_INTMAX)
|
||
|
step = (step - (int)step) + FIX20_INTMAX;
|
||
|
|
||
|
p->step = FLOAT_TO_FIX20(step); // convert fstep to fixed point
|
||
|
p->cstep = 0;
|
||
|
p->pos = 0; // current update value
|
||
|
|
||
|
p->D = D; // always init to end value, in case we're stepping backwards
|
||
|
}
|
||
|
|
||
|
// change step value - this is an instantaneous change, not smoothed.
|
||
|
|
||
|
inline void POS_ChangeVal( pos_t *p, float fstepnew )
|
||
|
{
|
||
|
p->step = FLOAT_TO_FIX20( fstepnew ); // convert fstep to fixed point
|
||
|
}
|
||
|
|
||
|
// return current integer position, then update internal position value
|
||
|
|
||
|
inline int POS_GetNext ( pos_t *p )
|
||
|
{
|
||
|
|
||
|
//float f = FIX20_TO_FLOAT(p->cstep);
|
||
|
//int i1 = FIX20_INTPART(p->cstep);
|
||
|
//float f1 = FIX20_TO_FLOAT(FIX20_FRACPART(p->cstep));
|
||
|
//float f2 = FIX20_TO_FLOAT(p->step);
|
||
|
|
||
|
p->cstep += p->step; // update accumulated fraction step value (fixed point)
|
||
|
p->pos += FIX20_INTPART( p->cstep ); // update pos with integer part of accumulated step
|
||
|
p->cstep = FIX20_FRACPART( p->cstep ); // throw away the integer part of accumulated step
|
||
|
|
||
|
// wrap pos around either end of buffer if needed
|
||
|
|
||
|
POS_Wrap(p->D, &(p->pos));
|
||
|
|
||
|
// make sure returned position is within array bounds
|
||
|
|
||
|
Assert (p->pos <= p->D);
|
||
|
|
||
|
return p->pos;
|
||
|
}
|
||
|
|
||
|
// oneshot position within wav
|
||
|
struct pos_one_t
|
||
|
{
|
||
|
pos_t p; // pos_t
|
||
|
|
||
|
bool fhitend; // flag indicating we hit end of oneshot wav
|
||
|
};
|
||
|
|
||
|
// set initial update value - fstep can have no more than 8 bits of integer and 20 bits of fract
|
||
|
// one shot position - play only once, don't wrap, when hit end of buffer, return last position
|
||
|
|
||
|
inline void POS_ONE_Init( pos_one_t *p1, int D, float fstep )
|
||
|
{
|
||
|
POS_Init( &p1->p, D, fstep ) ;
|
||
|
|
||
|
p1->fhitend = false;
|
||
|
}
|
||
|
|
||
|
// return current integer position, then update internal position value
|
||
|
|
||
|
inline int POS_ONE_GetNext ( pos_one_t *p1 )
|
||
|
{
|
||
|
int pos;
|
||
|
pos_t *p0;
|
||
|
|
||
|
pos = p1->p.pos; // return current position
|
||
|
|
||
|
if (p1->fhitend)
|
||
|
return pos;
|
||
|
|
||
|
p0 = &(p1->p);
|
||
|
p0->cstep += p0->step; // update accumulated fraction step value (fixed point)
|
||
|
p0->pos += FIX20_INTPART( p0->cstep ); // update pos with integer part of accumulated step
|
||
|
//p0->cstep = SIGN(p0->cstep) * FIX20_FRACPART( p0->cstep );
|
||
|
p0->cstep = FIX20_FRACPART( p0->cstep ); // throw away the integer part of accumulated step
|
||
|
|
||
|
// if we wrapped, stop updating, always return last position
|
||
|
// if step value is 0, return hit end
|
||
|
|
||
|
if (!p0->step || p0->pos < 0 || p0->pos >= p0->D )
|
||
|
p1->fhitend = true;
|
||
|
else
|
||
|
pos = p0->pos;
|
||
|
|
||
|
// make sure returned value is within array bounds
|
||
|
|
||
|
Assert ( pos <= p0->D );
|
||
|
|
||
|
return pos;
|
||
|
}
|
||
|
|
||
|
|
||
|
/////////////////////
|
||
|
// Reverbs and delays
|
||
|
/////////////////////
|
||
|
|
||
|
#define CDLYS 128 // max delay lines active. Also used for lfos.
|
||
|
|
||
|
#define DLY_PLAIN 0 // single feedback loop
|
||
|
#define DLY_ALLPASS 1 // feedback and feedforward loop - flat frequency response (diffusor)
|
||
|
#define DLY_LOWPASS 2 // lowpass filter in feedback loop
|
||
|
#define DLY_LINEAR 3 // linear delay, no feedback, unity gain
|
||
|
#define DLY_FLINEAR 4 // linear delay with lowpass filter and output gain
|
||
|
#define DLY_LOWPASS_4TAP 5 // lowpass filter in feedback loop, 4 delay taps
|
||
|
#define DLY_PLAIN_4TAP 6 // single feedback loop, 4 delay taps
|
||
|
|
||
|
#define DLY_MAX DLY_PLAIN_4TAP
|
||
|
|
||
|
#define DLY_HAS_MULTITAP(a) ((a) == DLY_LOWPASS_4TAP || (a) == DLY_PLAIN_4TAP)
|
||
|
#define DLY_HAS_FILTER(a) ((a) == DLY_FLINEAR || (a) == DLY_LOWPASS || (a) == DLY_LOWPASS_4TAP)
|
||
|
|
||
|
#define DLY_TAP_FEEDBACK_GAIN 0.25 // drop multitap feedback to compensate for sum of taps in dly_*multitap()
|
||
|
|
||
|
#define DLY_NORMALIZING_REDUCTION_MAX 0.25 // don't reduce gain (due to feedback) below N% of original gain
|
||
|
|
||
|
// delay line
|
||
|
|
||
|
struct dly_t
|
||
|
{
|
||
|
|
||
|
bool fused; // true if dly is in use
|
||
|
int type; // delay type
|
||
|
|
||
|
int D; // delay size, in samples
|
||
|
int t; // current tap, <= D
|
||
|
int tnew; // crossfading to tnew
|
||
|
int xf; // crossfade value of t (0..PMAX)
|
||
|
int t1,t2,t3; // additional taps for multi-tap delays
|
||
|
int a1,a2,a3; // feedback values for taps
|
||
|
int D0; // original delay size (only relevant if calling DLY_ChangeVal)
|
||
|
int *p; // circular buffer pointer
|
||
|
int *w; // array of samples
|
||
|
|
||
|
int a; // feedback value 0..PMAX,normalized to 0-1.0
|
||
|
int b; // gain value 0..PMAX, normalized to 0-1.0
|
||
|
|
||
|
flt_t *pflt; // pointer to filter, if type DLY_LOWPASS
|
||
|
};
|
||
|
|
||
|
dly_t dlys[CDLYS]; // delay lines
|
||
|
|
||
|
void DLY_Init ( dly_t *pdly ) { if ( pdly ) Q_memset( pdly, 0, sizeof (dly_t)); }
|
||
|
void DLY_InitAll ( void ) { for (int i = 0 ; i < CDLYS; i++) DLY_Init ( &dlys[i] ); }
|
||
|
void DLY_Free ( dly_t *pdly )
|
||
|
{
|
||
|
// free memory buffer
|
||
|
|
||
|
if ( pdly )
|
||
|
{
|
||
|
FLT_Free ( pdly->pflt );
|
||
|
|
||
|
if ( pdly->w )
|
||
|
{
|
||
|
delete[] pdly->w;
|
||
|
}
|
||
|
|
||
|
// free dly slot
|
||
|
|
||
|
Q_memset ( pdly, 0, sizeof (dly_t) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void DLY_FreeAll ( void ) { for (int i = 0; i < CDLYS; i++ ) DLY_Free ( &dlys[i] ); }
|
||
|
|
||
|
// return adjusted feedback value for given dly
|
||
|
// such that decay time is same as that for dmin and fbmin
|
||
|
|
||
|
// dmin - minimum delay
|
||
|
// fbmin - minimum feedback
|
||
|
// dly - delay to match decay to dmin, fbmin
|
||
|
|
||
|
float DLY_NormalizeFeedback ( int dmin, float fbmin, int dly )
|
||
|
{
|
||
|
// minimum decay time T to -60db for a simple reverb is:
|
||
|
|
||
|
// Tmin = (ln 10^-3 / Ln fbmin) * (Dmin / fs)
|
||
|
|
||
|
// where fs = sample frequency
|
||
|
|
||
|
// similarly,
|
||
|
|
||
|
// Tdly = (ln 10^-3 / Ln fb) * (D / fs)
|
||
|
|
||
|
// setting Tdly = Tmin and solving for fb gives:
|
||
|
|
||
|
// D / Dmin = ln fb / ln fbmin
|
||
|
|
||
|
// since y^x = z gives x = ln z / ln y
|
||
|
|
||
|
// fb = fbmin ^ (D/Dmin)
|
||
|
|
||
|
float fb = powf (fbmin, (float)dly / (float) dmin);
|
||
|
|
||
|
return fb;
|
||
|
}
|
||
|
|
||
|
// set up 'b' gain parameter of feedback delay to
|
||
|
// compensate for gain caused by feedback 'fb'.
|
||
|
|
||
|
void DLY_SetNormalizingGain ( dly_t *pdly, int feedback )
|
||
|
{
|
||
|
// compute normalized gain, set as output gain
|
||
|
|
||
|
// calculate gain of delay line with feedback, and use it to
|
||
|
// reduce output. ie: force delay line with feedback to unity gain
|
||
|
|
||
|
// for constant input x with feedback fb:
|
||
|
|
||
|
// out = x + x*fb + x * fb^2 + x * fb^3...
|
||
|
// gain = out/x
|
||
|
// so gain = 1 + fb + fb^2 + fb^3...
|
||
|
// which, by the miracle of geometric series, equates to 1/1-fb
|
||
|
// thus, gain = 1/(1-fb)
|
||
|
|
||
|
float fgain = 0;
|
||
|
float gain;
|
||
|
int b;
|
||
|
float fb = (float)feedback;
|
||
|
|
||
|
fb = fb / (float)PMAX;
|
||
|
fb = fpmin(fb, 0.999f);
|
||
|
|
||
|
// if b is 0, set b to PMAX (1)
|
||
|
|
||
|
b = pdly->b ? pdly->b : PMAX;
|
||
|
|
||
|
fgain = 1.0 / (1.0 - fb);
|
||
|
|
||
|
// compensating gain - multiply rva output by gain then >> PBITS
|
||
|
|
||
|
gain = (int)((1.0 / fgain) * PMAX);
|
||
|
|
||
|
gain = gain * 4; // compensate for fact that gain calculation is for +/- 32767 amplitude wavs
|
||
|
// ie: ok to allow a bit more gain because most wavs are not at theoretical peak amplitude at all times
|
||
|
|
||
|
// limit gain reduction to N% PMAX
|
||
|
|
||
|
gain = clamp (gain, (float)(PMAX * DLY_NORMALIZING_REDUCTION_MAX), (float)PMAX);
|
||
|
|
||
|
gain = ((float)b/(float)PMAX) * gain; // scale final gain by pdly->b.
|
||
|
|
||
|
pdly->b = (int)gain;
|
||
|
}
|
||
|
|
||
|
void DLY_ChangeTaps ( dly_t *pdly, int t0, int t1, int t2, int t3 );
|
||
|
|
||
|
// allocate a new delay line
|
||
|
// D number of samples to delay
|
||
|
// a feedback value (0-PMAX normalized to 0.0-1.0)
|
||
|
// b gain value (0-PMAX normalized to 0.0-1.0) - this is folded into the filter fb params
|
||
|
// if DLY_LOWPASS or DLY_FLINEAR:
|
||
|
// L - numerator order of filter
|
||
|
// M - denominator order of filter
|
||
|
// fb - numerator params, M+1
|
||
|
// fa - denominator params, L+1
|
||
|
|
||
|
dly_t * DLY_AllocLP ( int D, int a, int b, int type, int M, int L, int *fa, int *fb )
|
||
|
{
|
||
|
int *w;
|
||
|
int i;
|
||
|
dly_t *pdly = NULL;
|
||
|
int feedback;
|
||
|
|
||
|
// find open slot
|
||
|
|
||
|
for (i = 0; i < CDLYS; i++)
|
||
|
{
|
||
|
if (!dlys[i].fused)
|
||
|
{
|
||
|
pdly = &dlys[i];
|
||
|
DLY_Init( pdly );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( i == CDLYS )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate delay line.\n" );
|
||
|
return NULL; // all delay lines in use
|
||
|
}
|
||
|
|
||
|
// save original feedback value
|
||
|
|
||
|
feedback = a;
|
||
|
|
||
|
// adjust feedback a, gain b if delay is multitap unit
|
||
|
|
||
|
if ( DLY_HAS_MULTITAP(type) )
|
||
|
{
|
||
|
// split output gain over 4 taps
|
||
|
|
||
|
b = (int)((float)(b) * DLY_TAP_FEEDBACK_GAIN);
|
||
|
}
|
||
|
|
||
|
if ( DLY_HAS_FILTER(type) )
|
||
|
{
|
||
|
// alloc lowpass iir_filter
|
||
|
// delay feedback gain is built into filter gain
|
||
|
|
||
|
float gain = (float)a / (float)(PMAX);
|
||
|
|
||
|
pdly->pflt = FLT_Alloc( 0, M, L, fa, fb, gain );
|
||
|
if ( !pdly->pflt )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate filter for delay line.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// alloc delay memory
|
||
|
w = new int[D+1];
|
||
|
if ( !w )
|
||
|
{
|
||
|
Warning( "Sound DSP: Failed to lock.\n");
|
||
|
FLT_Free ( pdly->pflt );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
// clear delay array
|
||
|
|
||
|
Q_memset (w, 0, sizeof(int) * (D+1));
|
||
|
|
||
|
// init values
|
||
|
|
||
|
pdly->type = type;
|
||
|
pdly->D = D;
|
||
|
pdly->t = D; // set delay tap to full delay
|
||
|
pdly->tnew = D;
|
||
|
pdly->xf = 0;
|
||
|
pdly->D0 = D;
|
||
|
pdly->p = w; // init circular pointer to head of buffer
|
||
|
pdly->w = w;
|
||
|
pdly->a = min( a, PMAX - 1 ); // do not allow 100% feedback
|
||
|
pdly->b = b;
|
||
|
pdly->fused = true;
|
||
|
|
||
|
if ( type == DLY_LINEAR || type == DLY_FLINEAR )
|
||
|
{
|
||
|
// linear delay has no feedback and unity gain
|
||
|
|
||
|
pdly->a = 0;
|
||
|
pdly->b = PMAX;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// adjust b to compensate for feedback gain of steady state max input
|
||
|
|
||
|
DLY_SetNormalizingGain( pdly, feedback );
|
||
|
}
|
||
|
|
||
|
if ( DLY_HAS_MULTITAP(type) )
|
||
|
{
|
||
|
// initially set up all taps to same value - caller uses DLY_ChangeTaps to change values
|
||
|
|
||
|
DLY_ChangeTaps( pdly, D, D, D, D );
|
||
|
}
|
||
|
|
||
|
return (pdly);
|
||
|
}
|
||
|
|
||
|
// allocate lowpass or allpass delay
|
||
|
|
||
|
dly_t * DLY_Alloc( int D, int a, int b, int type )
|
||
|
{
|
||
|
return DLY_AllocLP( D, a, b, type, 0, 0, 0, 0 );
|
||
|
}
|
||
|
|
||
|
|
||
|
// Allocate new delay, convert from float params in prc preset to internal parameters
|
||
|
// Uses filter params in prc if delay is type lowpass
|
||
|
|
||
|
// delay parameter order
|
||
|
|
||
|
typedef enum {
|
||
|
|
||
|
dly_idtype, // NOTE: first 8 params must match those in mdy_e
|
||
|
dly_idelay,
|
||
|
dly_ifeedback,
|
||
|
dly_igain,
|
||
|
|
||
|
dly_iftype,
|
||
|
dly_icutoff,
|
||
|
dly_iqwidth,
|
||
|
dly_iquality,
|
||
|
|
||
|
dly_itap1,
|
||
|
dly_itap2,
|
||
|
dly_itap3,
|
||
|
|
||
|
dly_cparam
|
||
|
|
||
|
} dly_e;
|
||
|
|
||
|
|
||
|
// delay parameter ranges
|
||
|
|
||
|
prm_rng_t dly_rng[] = {
|
||
|
|
||
|
{dly_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
// delay params
|
||
|
|
||
|
{dly_idtype, 0, DLY_MAX}, // delay type DLY_PLAIN, DLY_LOWPASS, DLY_ALLPASS etc
|
||
|
{dly_idelay, -1.0, 1000.0}, // delay in milliseconds (-1 forces auto dsp to set delay value from room size)
|
||
|
{dly_ifeedback, 0.0, 0.99}, // feedback 0-1.0
|
||
|
{dly_igain, 0.0, 10.0}, // final gain of output stage, 0-10.0
|
||
|
|
||
|
// filter params if dly type DLY_LOWPASS or DLY_FLINEAR
|
||
|
|
||
|
{dly_iftype, 0, FTR_MAX},
|
||
|
{dly_icutoff, 10.0, 22050.0},
|
||
|
{dly_iqwidth, 100.0, 11025.0},
|
||
|
{dly_iquality, 0, QUA_MAX},
|
||
|
// note: -1 flag tells auto dsp to get value directly from room size
|
||
|
{dly_itap1, -1.0, 1000.0}, // delay in milliseconds NOTE: delay > tap3 > tap2 > tap1
|
||
|
{dly_itap2, -1.0, 1000.0}, // delay in milliseconds
|
||
|
{dly_itap3, -1.0, 1000.0}, // delay in milliseconds
|
||
|
};
|
||
|
|
||
|
dly_t * DLY_Params ( prc_t *pprc )
|
||
|
{
|
||
|
dly_t *pdly = NULL;
|
||
|
int D, a, b;
|
||
|
|
||
|
float delay = fabs(pprc->prm[dly_idelay]);
|
||
|
float feedback = pprc->prm[dly_ifeedback];
|
||
|
float gain = pprc->prm[dly_igain];
|
||
|
int type = pprc->prm[dly_idtype];
|
||
|
|
||
|
float ftype = pprc->prm[dly_iftype];
|
||
|
float cutoff = pprc->prm[dly_icutoff];
|
||
|
float qwidth = pprc->prm[dly_iqwidth];
|
||
|
float qual = pprc->prm[dly_iquality];
|
||
|
|
||
|
float t1 = fabs(pprc->prm[dly_itap1]);
|
||
|
float t2 = fabs(pprc->prm[dly_itap2]);
|
||
|
float t3 = fabs(pprc->prm[dly_itap3]);
|
||
|
|
||
|
D = MSEC_TO_SAMPS(delay); // delay samples
|
||
|
a = feedback * PMAX; // feedback
|
||
|
b = gain * PMAX; // gain
|
||
|
|
||
|
switch ( (int) type )
|
||
|
{
|
||
|
case DLY_PLAIN:
|
||
|
case DLY_PLAIN_4TAP:
|
||
|
case DLY_ALLPASS:
|
||
|
case DLY_LINEAR:
|
||
|
pdly = DLY_Alloc( D, a, b, type );
|
||
|
break;
|
||
|
|
||
|
case DLY_FLINEAR:
|
||
|
case DLY_LOWPASS:
|
||
|
case DLY_LOWPASS_4TAP:
|
||
|
{
|
||
|
// set up dummy lowpass filter to convert params
|
||
|
|
||
|
prc_t prcf;
|
||
|
|
||
|
prcf.prm[flt_iquality] = qual; // 0,1,2 - (0 or 1 low quality implies faster execution time)
|
||
|
prcf.prm[flt_icutoff] = cutoff;
|
||
|
prcf.prm[flt_iftype] = ftype;
|
||
|
prcf.prm[flt_iqwidth] = qwidth;
|
||
|
prcf.prm[flt_igain] = 1.0;
|
||
|
|
||
|
flt_t *pflt = (flt_t *)FLT_Params ( &prcf );
|
||
|
|
||
|
if ( !pflt )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate filter.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pdly = DLY_AllocLP ( D, a, b, type, pflt->M, pflt->L, pflt->a, pflt->b );
|
||
|
|
||
|
FLT_Free ( pflt );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// set up multi-tap delays
|
||
|
|
||
|
if ( pdly && DLY_HAS_MULTITAP((int)type) )
|
||
|
DLY_ChangeTaps( pdly, D, MSEC_TO_SAMPS(t1), MSEC_TO_SAMPS(t2), MSEC_TO_SAMPS(t3) );
|
||
|
|
||
|
return pdly;
|
||
|
}
|
||
|
|
||
|
inline void * DLY_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams( (prc_t *)p, dly_rng );
|
||
|
return (void *) DLY_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
// get next value from delay line, move x into delay line
|
||
|
|
||
|
inline int DLY_GetNext ( dly_t *pdly, int x )
|
||
|
{
|
||
|
switch (pdly->type)
|
||
|
{
|
||
|
default:
|
||
|
case DLY_PLAIN:
|
||
|
return ReverbSimple( pdly->D, pdly->t, pdly->w, &pdly->p, pdly->a, pdly->b, x );
|
||
|
case DLY_ALLPASS:
|
||
|
return DelayAllpass( pdly->D, pdly->t, pdly->w, &pdly->p, pdly->a, pdly->b, x );
|
||
|
case DLY_LOWPASS:
|
||
|
return DelayLowpass( pdly->D, pdly->t, pdly->w, &(pdly->p), pdly->a, pdly->b, pdly->pflt->a, pdly->pflt->L, pdly->pflt->b, pdly->pflt->w, x );
|
||
|
case DLY_LINEAR:
|
||
|
return DelayLinear( pdly->D, pdly->t, pdly->w, &pdly->p, x );
|
||
|
case DLY_FLINEAR:
|
||
|
return DelayLinear_lowpass( pdly->D, pdly->t, pdly->w, &(pdly->p), pdly->a, pdly->b, pdly->pflt->a, pdly->pflt->L, pdly->pflt->b, pdly->pflt->w, x );
|
||
|
case DLY_PLAIN_4TAP:
|
||
|
return ReverbSimple_multitap( pdly->D, pdly->t, pdly->t1, pdly->t2, pdly->t3, pdly->w, &pdly->p, pdly->a, pdly->b, x );
|
||
|
case DLY_LOWPASS_4TAP:
|
||
|
return DelayLowpass_multitap( pdly->D, pdly->t, pdly->t1, pdly->t2,pdly->t3, pdly->w, &(pdly->p), pdly->a, pdly->b, pdly->pflt->a, pdly->pflt->L, pdly->pflt->b, pdly->pflt->w, x );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
inline int DLY_GetNextXfade ( dly_t *pdly, int x )
|
||
|
{
|
||
|
|
||
|
switch (pdly->type)
|
||
|
{
|
||
|
default:
|
||
|
case DLY_PLAIN:
|
||
|
return ReverbSimple_xfade( pdly->D, pdly->t, pdly->tnew, pdly->xf, pdly->w, &pdly->p, pdly->a, pdly->b, x );
|
||
|
case DLY_ALLPASS:
|
||
|
return DelayAllpass_xfade( pdly->D, pdly->t, pdly->tnew, pdly->xf, pdly->w, &pdly->p, pdly->a, pdly->b, x );
|
||
|
case DLY_LOWPASS:
|
||
|
return DelayLowpass_xfade( pdly->D, pdly->t, pdly->tnew, pdly->xf, pdly->w, &(pdly->p), pdly->a, pdly->b, pdly->pflt->a, pdly->pflt->L, pdly->pflt->b, pdly->pflt->w, x );
|
||
|
case DLY_LINEAR:
|
||
|
return DelayLinear_xfade( pdly->D, pdly->t, pdly->tnew, pdly->xf, pdly->w, &pdly->p, x );
|
||
|
case DLY_FLINEAR:
|
||
|
return DelayLinear_lowpass_xfade( pdly->D, pdly->t, pdly->tnew, pdly->xf, pdly->w, &(pdly->p), pdly->a, pdly->b, pdly->pflt->a, pdly->pflt->L, pdly->pflt->b, pdly->pflt->w, x );
|
||
|
case DLY_PLAIN_4TAP:
|
||
|
return ReverbSimple_multitap_xfade( pdly->D, pdly->t, pdly->tnew, pdly->xf, pdly->t1, pdly->t2, pdly->t3, pdly->w, &pdly->p, pdly->a, pdly->b, x );
|
||
|
case DLY_LOWPASS_4TAP:
|
||
|
return DelayLowpass_multitap_xfade( pdly->D, pdly->t, pdly->tnew, pdly->xf, pdly->t1, pdly->t2, pdly->t3, pdly->w, &(pdly->p), pdly->a, pdly->b, pdly->pflt->a, pdly->pflt->L, pdly->pflt->b, pdly->pflt->w, x );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
// UNDONE: a) unwind this more - pb increments by 2 to avoid pb->left or pb->right deref.
|
||
|
// UNDONE: b) all filter and delay params are dereferenced outside of DLY_GetNext and passed as register values
|
||
|
// UNDONE: c) pull case statement in dly_getnext out, so loop directly calls the inline dly_*() routine.
|
||
|
|
||
|
inline void DLY_GetNextN( dly_t *pdly, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = DLY_GetNext( pdly, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = DLY_GetNext( pdly, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = DLY_GetNext( pdly, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// get tap on t'th sample in delay - don't update buffer pointers, this is done via DLY_GetNext
|
||
|
// Only valid for DLY_LINEAR.
|
||
|
|
||
|
inline int DLY_GetTap ( dly_t *pdly, int t )
|
||
|
{
|
||
|
return GetDly (pdly->D, pdly->w, pdly->p, t );
|
||
|
}
|
||
|
|
||
|
#define SWAP(a,b,t) {(t) = (a); (a) = (b); (b) = (t);}
|
||
|
|
||
|
// make instantaneous change to tap values t0..t3
|
||
|
// all values of t must be less than original delay D
|
||
|
// only processed for DLY_LOWPASS_4TAP & DLY_PLAIN_4TAP
|
||
|
// NOTE: pdly->a feedback must have been set before this call!
|
||
|
void DLY_ChangeTaps ( dly_t *pdly, int t0, int t1, int t2, int t3 )
|
||
|
{
|
||
|
if (!pdly)
|
||
|
return;
|
||
|
|
||
|
int temp;
|
||
|
|
||
|
// sort taps to make sure t3 > t2 > t1 > t0 !
|
||
|
|
||
|
for (int i = 0; i < 4; i++)
|
||
|
{
|
||
|
if (t0 > t1) SWAP(t0, t1, temp);
|
||
|
if (t1 > t2) SWAP(t1, t2, temp);
|
||
|
if (t2 > t3) SWAP(t2, t3, temp);
|
||
|
}
|
||
|
|
||
|
pdly->t = min ( t0, pdly->D0 );
|
||
|
pdly->t1 = min ( t1, pdly->D0 );
|
||
|
pdly->t2 = min ( t2, pdly->D0 );
|
||
|
pdly->t3 = min ( t3, pdly->D0 );
|
||
|
|
||
|
}
|
||
|
|
||
|
// make instantaneous change for first delay tap 't' to new delay value.
|
||
|
// t tap value must be <= original D (ie: we don't do any reallocation here)
|
||
|
|
||
|
void DLY_ChangeVal ( dly_t *pdly, int t )
|
||
|
{
|
||
|
// never set delay > original delay
|
||
|
|
||
|
pdly->t = min ( t, pdly->D0 );
|
||
|
}
|
||
|
|
||
|
// ignored - use MDY_ for modulatable delay
|
||
|
|
||
|
inline void DLY_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// Ramp - used for varying smoothly between int parameters ie: modulation delays
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
|
||
|
struct rmp_t
|
||
|
{
|
||
|
int initval; // initial ramp value
|
||
|
int target; // final ramp value
|
||
|
int sign; // increasing (1) or decreasing (-1) ramp
|
||
|
|
||
|
int yprev; // previous output value
|
||
|
bool fhitend; // true if hit end of ramp
|
||
|
bool bEndAtTime; // if true, fhitend is true when ramp time is hit (even if target not hit)
|
||
|
// if false, then fhitend is true only when target is hit
|
||
|
pos_one_t ps; // current ramp output
|
||
|
};
|
||
|
|
||
|
// ramp smoothly between initial value and target value in approx 'ramptime' seconds.
|
||
|
// (initial value may be greater or less than target value)
|
||
|
// never changes output by more than +1 or -1 (which can cause the ramp to take longer to complete than ramptime - see bEndAtTime)
|
||
|
// called once per sample while ramping
|
||
|
// ramptime - duration of ramp in seconds
|
||
|
// initval - initial ramp value
|
||
|
// targetval - target ramp value
|
||
|
// if bEndAtTime is true, then RMP_HitEnd returns true when ramp time is reached, EVEN IF TARGETVAL IS NOT REACHED
|
||
|
// if bEndAtTime is false, then RMP_HitEnd returns true when targetval is reached, EVEN IF DELTA IN RAMP VALUES IS > +/- 1
|
||
|
|
||
|
void RMP_Init( rmp_t *prmp, float ramptime, int initval, int targetval, bool bEndAtTime )
|
||
|
{
|
||
|
int rise;
|
||
|
int run;
|
||
|
|
||
|
if (prmp)
|
||
|
Q_memset( prmp, 0, sizeof (rmp_t) );
|
||
|
else
|
||
|
return;
|
||
|
|
||
|
run = (int) (ramptime * SOUND_DMA_SPEED); // 'samples' in ramp
|
||
|
rise = (targetval - initval); // height of ramp
|
||
|
|
||
|
// init fixed point iterator to iterate along the height of the ramp 'rise'
|
||
|
// always iterates from 0..'rise', increasing in value
|
||
|
|
||
|
POS_ONE_Init( &prmp->ps, ABS( rise ), ABS((float) rise) / ((float) run) );
|
||
|
|
||
|
prmp->yprev = initval;
|
||
|
prmp->initval = initval;
|
||
|
prmp->target = targetval;
|
||
|
prmp->sign = SIGN( rise );
|
||
|
prmp->bEndAtTime = bEndAtTime;
|
||
|
|
||
|
}
|
||
|
|
||
|
// continues from current position to new target position
|
||
|
|
||
|
void RMP_SetNext( rmp_t *prmp, float ramptime, int targetval )
|
||
|
{
|
||
|
RMP_Init ( prmp, ramptime, prmp->yprev, targetval, prmp->bEndAtTime );
|
||
|
}
|
||
|
|
||
|
inline bool RMP_HitEnd ( rmp_t *prmp )
|
||
|
{
|
||
|
return prmp->fhitend;
|
||
|
}
|
||
|
|
||
|
inline void RMP_SetEnd ( rmp_t *prmp )
|
||
|
{
|
||
|
prmp->fhitend = true;
|
||
|
}
|
||
|
|
||
|
// get next ramp value & update ramp, if bEndAtTime is true, never varies by more than +1 or -1 between calls
|
||
|
// when ramp hits target value, it thereafter always returns last value
|
||
|
|
||
|
inline int RMP_GetNext( rmp_t *prmp )
|
||
|
{
|
||
|
int y;
|
||
|
int d;
|
||
|
|
||
|
// if we hit ramp end, return last value
|
||
|
|
||
|
if (prmp->fhitend)
|
||
|
return prmp->yprev;
|
||
|
|
||
|
// get next integer position in ramp height.
|
||
|
|
||
|
d = POS_ONE_GetNext( &prmp->ps );
|
||
|
|
||
|
if ( prmp->ps.fhitend )
|
||
|
prmp->fhitend = true;
|
||
|
|
||
|
// increase or decrease from initval, depending on ramp sign
|
||
|
|
||
|
if ( prmp->sign > 0 )
|
||
|
y = prmp->initval + d;
|
||
|
else
|
||
|
y = prmp->initval - d;
|
||
|
|
||
|
// if bEndAtTime is true, only update current height by a max of +1 or -1
|
||
|
// this also means that for short ramp times, we may not hit target
|
||
|
|
||
|
if (prmp->bEndAtTime)
|
||
|
{
|
||
|
if ( ABS( y - prmp->yprev ) >= 1 )
|
||
|
prmp->yprev += prmp->sign;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// always hits target - but varies by more than +/- 1
|
||
|
|
||
|
prmp->yprev = y;
|
||
|
}
|
||
|
|
||
|
return prmp->yprev;
|
||
|
}
|
||
|
|
||
|
// get current ramp value, don't update ramp
|
||
|
|
||
|
inline int RMP_GetCurrent( rmp_t *prmp )
|
||
|
{
|
||
|
return prmp->yprev;
|
||
|
}
|
||
|
|
||
|
|
||
|
//////////////
|
||
|
// mod delay
|
||
|
//////////////
|
||
|
|
||
|
// modulate delay time anywhere from 0..D using MDY_ChangeVal. no output glitches (uses RMP)
|
||
|
|
||
|
#define CMDYS 64 // max # of mod delays active (steals from delays)
|
||
|
|
||
|
struct mdy_t
|
||
|
{
|
||
|
bool fused;
|
||
|
|
||
|
bool fchanging; // true if modulating to new delay value
|
||
|
|
||
|
dly_t *pdly; // delay
|
||
|
|
||
|
float ramptime; // ramp 'glide' time - time in seconds to change between values
|
||
|
|
||
|
int mtime; // time in samples between delay changes. 0 implies no self-modulating
|
||
|
int mtimecur; // current time in samples until next delay change
|
||
|
float depth; // modulate delay from D to D - (D*depth) depth 0-1.0
|
||
|
|
||
|
int mix; // PMAX as % processed fx signal mix
|
||
|
|
||
|
rmp_t rmp_interp; // interpolation ramp 0...PMAX
|
||
|
|
||
|
bool bPhaseInvert; // if true, invert phase of output
|
||
|
|
||
|
};
|
||
|
|
||
|
mdy_t mdys[CMDYS];
|
||
|
|
||
|
void MDY_Init( mdy_t *pmdy ) { if (pmdy) Q_memset( pmdy, 0, sizeof (mdy_t) ); };
|
||
|
void MDY_Free( mdy_t *pmdy ) { if (pmdy) { DLY_Free (pmdy->pdly); Q_memset( pmdy, 0, sizeof (mdy_t) ); } };
|
||
|
void MDY_InitAll() { for (int i = 0; i < CMDYS; i++) MDY_Init( &mdys[i] ); };
|
||
|
void MDY_FreeAll() { for (int i = 0; i < CMDYS; i++) MDY_Free( &mdys[i] ); };
|
||
|
|
||
|
|
||
|
// allocate mod delay, given previously allocated dly (NOTE: mod delay only sweeps tap 0, not t1,t2 or t3)
|
||
|
// ramptime is time in seconds for delay to change from dcur to dnew
|
||
|
// modtime is time in seconds between modulations. 0 if no self-modulation
|
||
|
// depth is 0-1.0 multiplier, new delay values when modulating are Dnew = randomlong (D - D*depth, D)
|
||
|
// mix - 0-1.0, default 1.0 for 100% fx mix - pans between input signal and fx signal
|
||
|
|
||
|
mdy_t *MDY_Alloc ( dly_t *pdly, float ramptime, float modtime, float depth, float mix )
|
||
|
{
|
||
|
int i;
|
||
|
mdy_t *pmdy;
|
||
|
|
||
|
if ( !pdly )
|
||
|
return NULL;
|
||
|
|
||
|
for (i = 0; i < CMDYS; i++)
|
||
|
{
|
||
|
if ( !mdys[i].fused )
|
||
|
{
|
||
|
pmdy = &mdys[i];
|
||
|
|
||
|
MDY_Init ( pmdy );
|
||
|
|
||
|
pmdy->pdly = pdly;
|
||
|
|
||
|
if ( !pmdy->pdly )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate delay for mod delay.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pmdy->fused = true;
|
||
|
pmdy->ramptime = ramptime;
|
||
|
pmdy->mtime = SEC_TO_SAMPS(modtime);
|
||
|
pmdy->mtimecur = pmdy->mtime;
|
||
|
pmdy->depth = depth;
|
||
|
pmdy->mix = int ( PMAX * mix );
|
||
|
pmdy->bPhaseInvert = false;
|
||
|
|
||
|
return pmdy;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
DevMsg ("DSP: Warning, failed to allocate mod delay.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
// change to new delay tap value t samples, ramp linearly over ramptime seconds
|
||
|
|
||
|
void MDY_ChangeVal ( mdy_t *pmdy, int t )
|
||
|
{
|
||
|
// if D > original delay value, cap at original value
|
||
|
|
||
|
t = min (pmdy->pdly->D0, t);
|
||
|
|
||
|
pmdy->fchanging = true;
|
||
|
|
||
|
// init interpolation ramp - always hit target
|
||
|
|
||
|
RMP_Init ( &pmdy->rmp_interp, pmdy->ramptime, 0, PMAX, false );
|
||
|
|
||
|
// init delay xfade values
|
||
|
|
||
|
pmdy->pdly->tnew = t;
|
||
|
pmdy->pdly->xf = 0;
|
||
|
}
|
||
|
|
||
|
// interpolate between current and target delay values
|
||
|
|
||
|
inline int MDY_GetNext( mdy_t *pmdy, int x )
|
||
|
{
|
||
|
int xout;
|
||
|
|
||
|
if ( !pmdy->fchanging )
|
||
|
{
|
||
|
// not modulating...
|
||
|
|
||
|
xout = DLY_GetNext( pmdy->pdly, x );
|
||
|
|
||
|
if ( !pmdy->mtime )
|
||
|
{
|
||
|
// return right away if not modulating (not changing and not self modulating)
|
||
|
|
||
|
goto mdy_return;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// modulating...
|
||
|
|
||
|
xout = DLY_GetNextXfade( pmdy->pdly, x );
|
||
|
|
||
|
// get xfade ramp & set up delay xfade value for next call to DLY_GetNextXfade()
|
||
|
|
||
|
pmdy->pdly->xf = RMP_GetNext( &pmdy->rmp_interp ); // 0...PMAX
|
||
|
|
||
|
if ( RMP_HitEnd( &pmdy->rmp_interp ) )
|
||
|
{
|
||
|
// done. set delay tap & value = target
|
||
|
|
||
|
DLY_ChangeVal( pmdy->pdly, pmdy->pdly->tnew );
|
||
|
|
||
|
pmdy->pdly->t = pmdy->pdly->tnew;
|
||
|
|
||
|
pmdy->fchanging = false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// if self-modulating and timer has expired, get next change
|
||
|
|
||
|
if ( pmdy->mtime && !pmdy->mtimecur-- )
|
||
|
{
|
||
|
pmdy->mtimecur = pmdy->mtime;
|
||
|
|
||
|
int D0 = pmdy->pdly->D0;
|
||
|
int Dnew;
|
||
|
float D1;
|
||
|
|
||
|
// modulate between 0 and 100% of d0
|
||
|
|
||
|
D1 = (float)D0 * (1.0 - pmdy->depth);
|
||
|
|
||
|
Dnew = RandomInt( (int)D1, D0 );
|
||
|
|
||
|
// set up modulation to new value
|
||
|
|
||
|
MDY_ChangeVal ( pmdy, Dnew );
|
||
|
}
|
||
|
|
||
|
mdy_return:
|
||
|
|
||
|
// reverse phase of output
|
||
|
|
||
|
if ( pmdy->bPhaseInvert )
|
||
|
xout = -xout;
|
||
|
|
||
|
// 100% fx mix
|
||
|
|
||
|
if ( pmdy->mix == PMAX)
|
||
|
return xout;
|
||
|
|
||
|
// special case 50/50 mix
|
||
|
|
||
|
if ( pmdy->mix == PMAX / 2)
|
||
|
return ( (xout + x) >> 1 );
|
||
|
|
||
|
// return mix of input and processed signal
|
||
|
|
||
|
return ( x + (((xout - x) * pmdy->mix) >> PBITS) );
|
||
|
}
|
||
|
|
||
|
|
||
|
// batch version for performance
|
||
|
// UNDONE: unwind MDY_GetNext so that it directly calls DLY_GetNextN:
|
||
|
// UNDONE: a) if not currently modulating and never self-modulating, then just unwind like DLY_GetNext
|
||
|
// UNDONE: b) if not currently modulating, figure out how many samples N until self-modulation timer kicks in again
|
||
|
// and stream out N samples just like DLY_GetNext
|
||
|
|
||
|
inline void MDY_GetNextN( mdy_t *pmdy, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = MDY_GetNext( pmdy, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = MDY_GetNext( pmdy, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = MDY_GetNext( pmdy, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
typedef enum {
|
||
|
|
||
|
mdy_idtype, // NOTE: first 8 params must match params in dly_e
|
||
|
mdy_idelay,
|
||
|
mdy_ifeedback,
|
||
|
mdy_igain,
|
||
|
|
||
|
mdy_iftype,
|
||
|
mdy_icutoff,
|
||
|
mdy_iqwidth,
|
||
|
mdy_iquality,
|
||
|
|
||
|
mdy_imodrate,
|
||
|
mdy_imoddepth,
|
||
|
mdy_imodglide,
|
||
|
|
||
|
mdy_imix,
|
||
|
mdy_ibxfade,
|
||
|
|
||
|
mdy_cparam
|
||
|
|
||
|
} mdy_e;
|
||
|
|
||
|
|
||
|
// parameter ranges
|
||
|
|
||
|
prm_rng_t mdy_rng[] = {
|
||
|
|
||
|
{mdy_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
// delay params
|
||
|
|
||
|
{mdy_idtype, 0, DLY_MAX}, // delay type DLY_PLAIN, DLY_LOWPASS, DLY_ALLPASS
|
||
|
{mdy_idelay, 0.0, 1000.0}, // delay in milliseconds
|
||
|
{mdy_ifeedback, 0.0, 0.99}, // feedback 0-1.0
|
||
|
{mdy_igain, 0.0, 1.0}, // final gain of output stage, 0-1.0
|
||
|
|
||
|
// filter params if mdy type DLY_LOWPASS
|
||
|
|
||
|
{mdy_iftype, 0, FTR_MAX},
|
||
|
{mdy_icutoff, 10.0, 22050.0},
|
||
|
{mdy_iqwidth, 100.0, 11025.0},
|
||
|
{mdy_iquality, 0, QUA_MAX},
|
||
|
|
||
|
{mdy_imodrate, 0.01, 200.0}, // frequency at which delay values change to new random value. 0 is no self-modulation
|
||
|
{mdy_imoddepth, 0.0, 1.0}, // how much delay changes (decreases) from current value (0-1.0)
|
||
|
{mdy_imodglide, 0.01, 100.0}, // glide time between dcur and dnew in milliseconds
|
||
|
{mdy_imix, 0.0, 1.0} // 1.0 = full fx mix, 0.5 = 50% fx, 50% dry
|
||
|
};
|
||
|
|
||
|
|
||
|
// convert user parameters to internal parameters, allocate and return
|
||
|
|
||
|
mdy_t * MDY_Params ( prc_t *pprc )
|
||
|
{
|
||
|
mdy_t *pmdy;
|
||
|
dly_t *pdly;
|
||
|
|
||
|
float ramptime = pprc->prm[mdy_imodglide] / 1000.0; // get ramp time in seconds
|
||
|
float modtime = 0.0f;
|
||
|
if ( pprc->prm[mdy_imodrate] != 0.0f )
|
||
|
{
|
||
|
modtime = 1.0 / pprc->prm[mdy_imodrate]; // time between modulations in seconds
|
||
|
}
|
||
|
float depth = pprc->prm[mdy_imoddepth]; // depth of modulations 0-1.0
|
||
|
float mix = pprc->prm[mdy_imix];
|
||
|
|
||
|
// alloc plain, allpass or lowpass delay
|
||
|
|
||
|
pdly = DLY_Params( pprc );
|
||
|
|
||
|
if ( !pdly )
|
||
|
return NULL;
|
||
|
|
||
|
pmdy = MDY_Alloc ( pdly, ramptime, modtime, depth, mix );
|
||
|
|
||
|
return pmdy;
|
||
|
}
|
||
|
|
||
|
inline void * MDY_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams ( (prc_t *)p, mdy_rng );
|
||
|
return (void *) MDY_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
// v is +/- 0-1.0
|
||
|
// change current delay value 0..D
|
||
|
|
||
|
void MDY_Mod ( mdy_t *pmdy, float v )
|
||
|
{
|
||
|
|
||
|
int D0 = pmdy->pdly->D0; // base delay value
|
||
|
float v2;
|
||
|
|
||
|
// if v is < -2.0 then delay is v + 10.0
|
||
|
// invert phase of output. hack.
|
||
|
|
||
|
if ( v < -2.0 )
|
||
|
{
|
||
|
v = v + 10.0;
|
||
|
pmdy->bPhaseInvert = true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pmdy->bPhaseInvert = false;
|
||
|
}
|
||
|
|
||
|
v2 = -(v + 1.0)/2.0; // v2 varies -1.0-0.0
|
||
|
|
||
|
// D0 varies 0..D0
|
||
|
|
||
|
D0 = D0 + (int)((float)D0 * v2);
|
||
|
|
||
|
// change delay
|
||
|
|
||
|
MDY_ChangeVal( pmdy, D0 );
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////
|
||
|
// Parallel reverbs
|
||
|
///////////////////
|
||
|
|
||
|
// Reverb A
|
||
|
// M parallel reverbs, mixed to mono output
|
||
|
|
||
|
#define CRVAS 64 // max number of parallel series reverbs active
|
||
|
|
||
|
#define CRVA_DLYS 12 // max number of delays making up reverb_a
|
||
|
|
||
|
struct rva_t
|
||
|
{
|
||
|
bool fused;
|
||
|
int m; // number of parallel plain or lowpass delays
|
||
|
int fparallel; // true if filters in parallel with delays, otherwise single output filter
|
||
|
flt_t *pflt; // series filters
|
||
|
|
||
|
dly_t *pdlys[CRVA_DLYS]; // array of pointers to delays
|
||
|
mdy_t *pmdlys[CRVA_DLYS]; // array of pointers to mod delays
|
||
|
|
||
|
bool fmoddly; // true if using mod delays
|
||
|
};
|
||
|
|
||
|
rva_t rvas[CRVAS];
|
||
|
|
||
|
void RVA_Init ( rva_t *prva ) { if ( prva ) Q_memset (prva, 0, sizeof (rva_t)); }
|
||
|
void RVA_InitAll( void ) { for (int i = 0; i < CRVAS; i++) RVA_Init ( &rvas[i] ); }
|
||
|
|
||
|
// free parallel series reverb
|
||
|
|
||
|
void RVA_Free( rva_t *prva )
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
if ( prva )
|
||
|
{
|
||
|
// free all delays
|
||
|
for (i = 0; i < CRVA_DLYS; i++)
|
||
|
DLY_Free ( prva->pdlys[i] );
|
||
|
|
||
|
// zero all ptrs to delays in mdy array
|
||
|
for (i = 0; i < CRVA_DLYS; i++)
|
||
|
{
|
||
|
if ( prva->pmdlys[i] )
|
||
|
prva->pmdlys[i]->pdly = NULL;
|
||
|
}
|
||
|
|
||
|
// free all mod delays
|
||
|
for (i = 0; i < CRVA_DLYS; i++)
|
||
|
MDY_Free ( prva->pmdlys[i] );
|
||
|
|
||
|
FLT_Free( prva->pflt );
|
||
|
|
||
|
Q_memset( prva, 0, sizeof (rva_t) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void RVA_FreeAll( void ) { for (int i = 0; i < CRVAS; i++) RVA_Free( &rvas[i] ); }
|
||
|
|
||
|
// create parallel reverb - m parallel reverbs summed
|
||
|
|
||
|
// D array of CRVB_DLYS reverb delay sizes max sample index w[0...D] (ie: D+1 samples)
|
||
|
// a array of reverb feedback parms for parallel reverbs (CRVB_P_DLYS)
|
||
|
// if a[i] < 0 then this is a predelay - use DLY_FLINEAR instead of DLY_LOWPASS
|
||
|
// b array of CRVB_P_DLYS - mix params for parallel reverbs
|
||
|
// m - number of parallel delays
|
||
|
// pflt - filter template, to be used by all parallel delays
|
||
|
// fparallel - true if filter operates in parallel with delays, otherwise filter output only
|
||
|
// fmoddly - > 0 if delays are all mod delays (milliseconds of delay modulation)
|
||
|
// fmodrate - # of delay repetitions between changes to mod delay
|
||
|
// ftaps - if > 0, use 4 taps per reverb delay unit (increases density) tap = D - n*ftaps n = 0,1,2,3
|
||
|
|
||
|
rva_t * RVA_Alloc ( int *D, int *a, int *b, int m, flt_t *pflt, int fparallel, float fmoddly, float fmodrate, float ftaps )
|
||
|
{
|
||
|
|
||
|
int i;
|
||
|
int dtype;
|
||
|
rva_t *prva;
|
||
|
flt_t *pflt2 = NULL;
|
||
|
|
||
|
bool btaps = ftaps > 0.0;
|
||
|
|
||
|
// find open slot
|
||
|
|
||
|
for ( i = 0; i < CRVAS; i++ )
|
||
|
{
|
||
|
if ( !rvas[i].fused )
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// return null if no free slots
|
||
|
|
||
|
if (i == CRVAS)
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate reverb.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
prva = &rvas[i];
|
||
|
|
||
|
// if series filter specified, alloc two series filters
|
||
|
|
||
|
if ( pflt && !fparallel)
|
||
|
{
|
||
|
// use filter data as template for a filter on output (2 cascaded filters)
|
||
|
|
||
|
pflt2 = FLT_Alloc (0, pflt->M, pflt->L, pflt->a, pflt->b, 1.0);
|
||
|
|
||
|
if (!pflt2)
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate flt for reverb.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pflt2->pf1 = FLT_Alloc (0, pflt->M, pflt->L, pflt->a, pflt->b, 1.0);
|
||
|
pflt2->N = 1;
|
||
|
}
|
||
|
|
||
|
// allocate parallel delays
|
||
|
|
||
|
for (i = 0; i < m; i++)
|
||
|
{
|
||
|
// set delay type
|
||
|
|
||
|
if ( pflt && fparallel )
|
||
|
// if a[i] param is < 0, allocate delay as predelay instead of feedback delay
|
||
|
dtype = a[i] < 0 ? DLY_FLINEAR : DLY_LOWPASS;
|
||
|
else
|
||
|
// if no filter specified, alloc as plain or multitap plain delay
|
||
|
dtype = btaps ? DLY_PLAIN_4TAP : DLY_PLAIN;
|
||
|
|
||
|
if ( dtype == DLY_LOWPASS && btaps )
|
||
|
dtype = DLY_LOWPASS_4TAP;
|
||
|
|
||
|
// if filter specified and parallel specified, alloc 1 filter per delay
|
||
|
|
||
|
if ( DLY_HAS_FILTER(dtype) )
|
||
|
prva->pdlys[i] = DLY_AllocLP( D[i], abs(a[i]), b[i], dtype, pflt->M, pflt->L, pflt->a, pflt->b );
|
||
|
else
|
||
|
prva->pdlys[i] = DLY_Alloc( D[i], abs(a[i]), b[i], dtype );
|
||
|
|
||
|
if ( DLY_HAS_MULTITAP(dtype) )
|
||
|
{
|
||
|
// set up delay taps to increase density around delay value.
|
||
|
|
||
|
// value of ftaps is the seed for all tap values
|
||
|
|
||
|
float t1 = max((double)MSEC_TO_SAMPS(5), D[i] * (1.0 - ftaps * 3.141592) );
|
||
|
float t2 = max((double)MSEC_TO_SAMPS(7), D[i] * (1.0 - ftaps * 1.697043) );
|
||
|
float t3 = max((double)MSEC_TO_SAMPS(10), D[i] * (1.0 - ftaps * 0.96325) );
|
||
|
|
||
|
DLY_ChangeTaps( prva->pdlys[i], (int)t1, (int)t2, (int)t3, D[i] );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
if ( fmoddly > 0.0 )
|
||
|
{
|
||
|
// alloc mod delays, using previously alloc'd delays
|
||
|
|
||
|
// ramptime is time in seconds for delay to change from dcur to dnew
|
||
|
// modtime is time in seconds between modulations. 0 if no self-modulation
|
||
|
// depth is 0-1.0 multiplier, new delay values when modulating are Dnew = randomlong (D - D*depth, D)
|
||
|
|
||
|
float ramptime;
|
||
|
float modtime;
|
||
|
float depth;
|
||
|
|
||
|
for (i = 0; i < m; i++)
|
||
|
{
|
||
|
int Do = prva->pdlys[i]->D;
|
||
|
|
||
|
modtime = (float)Do / (float)(SOUND_DMA_SPEED); // seconds per delay
|
||
|
depth = (fmoddly * 0.001f) / modtime; // convert milliseconds to 'depth' %
|
||
|
depth = clamp (depth, 0.01f, 0.99f);
|
||
|
modtime = modtime * fmodrate; // modulate every N delay passes
|
||
|
|
||
|
ramptime = fpmin(20.0f/1000.0f, modtime / 2); // ramp between delay values in N ms
|
||
|
|
||
|
prva->pmdlys[i] = MDY_Alloc( prva->pdlys[i], ramptime, modtime, depth, 1.0 );
|
||
|
}
|
||
|
|
||
|
prva->fmoddly = true;
|
||
|
}
|
||
|
|
||
|
// if we failed to alloc any reverb, free all, return NULL
|
||
|
|
||
|
for (i = 0; i < m; i++)
|
||
|
{
|
||
|
if ( !prva->pdlys[i] )
|
||
|
{
|
||
|
FLT_Free( pflt2 );
|
||
|
RVA_Free( prva );
|
||
|
DevMsg ("DSP: Warning, failed to allocate delay for reverb.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
prva->fused = true;
|
||
|
prva->m = m;
|
||
|
prva->fparallel = fparallel;
|
||
|
prva->pflt = pflt2;
|
||
|
return prva;
|
||
|
}
|
||
|
|
||
|
|
||
|
// parallel reverberator
|
||
|
//
|
||
|
// for each input sample x do:
|
||
|
// x0 = plain(D0,w0,&p0,a0,x)
|
||
|
// x1 = plain(D1,w1,&p1,a1,x)
|
||
|
// x2 = plain(D2,w2,&p2,a2,x)
|
||
|
// x3 = plain(D3,w3,&p3,a3,x)
|
||
|
// y = b0*x0 + b1*x1 + b2*x2 + b3*x3
|
||
|
//
|
||
|
// rgdly - array of M delays:
|
||
|
// D - Delay values (typical - 29, 37, 44, 50, 27, 31)
|
||
|
// w - array of delayed values
|
||
|
// p - array of pointers to circular delay line pointers
|
||
|
// a - array of M feedback values (typical - all equal, like 0.75 * PMAX)
|
||
|
// b - array of M gain values for plain reverb outputs (1, .9, .8, .7)
|
||
|
// xin - input value
|
||
|
// if fparallel, filters are built into delays,
|
||
|
// otherwise, filter is in feedback loop
|
||
|
|
||
|
|
||
|
int g_MapIntoPBITSDivInt[] =
|
||
|
{
|
||
|
0, PMAX/1, PMAX/2, PMAX/3, PMAX/4, PMAX/5, PMAX/6, PMAX/7, PMAX/8,
|
||
|
PMAX/9, PMAX/10, PMAX/11,PMAX/12,PMAX/13,PMAX/14,PMAX/15,PMAX/16,
|
||
|
};
|
||
|
|
||
|
inline int RVA_GetNext( rva_t *prva, int x )
|
||
|
{
|
||
|
int m = prva->m;
|
||
|
int y = 0;
|
||
|
|
||
|
if ( prva->fmoddly )
|
||
|
{
|
||
|
// get output of parallel mod delays
|
||
|
|
||
|
for (int i = 0; i < m; i++ )
|
||
|
y += MDY_GetNext( prva->pmdlys[i], x );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// get output of parallel delays
|
||
|
|
||
|
for (int i = 0; i < m; i++ )
|
||
|
y += DLY_GetNext( prva->pdlys[i], x );
|
||
|
}
|
||
|
|
||
|
// PERFORMANCE: y/m is now baked into the 'b' gain params for each delay ( b = b/m )
|
||
|
// y = (y * g_MapIntoPBITSDivInt[m]) >> PBITS;
|
||
|
|
||
|
if ( prva->fparallel )
|
||
|
return y;
|
||
|
|
||
|
// run series filters if present
|
||
|
|
||
|
if ( prva->pflt )
|
||
|
{
|
||
|
y = FLT_GetNext( prva->pflt, y);
|
||
|
}
|
||
|
|
||
|
return y;
|
||
|
}
|
||
|
|
||
|
|
||
|
// batch version for performance
|
||
|
// UNDONE: unwind RVA_GetNextN so that it directly calls DLY_GetNextN or MDY_GetNextN
|
||
|
|
||
|
inline void RVA_GetNextN( rva_t *prva, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = RVA_GetNext( prva, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = RVA_GetNext( prva, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = RVA_GetNext( prva, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// reverb parameter order
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
rva_size_max,
|
||
|
rva_size_min,
|
||
|
|
||
|
rva_inumdelays,
|
||
|
rva_ifeedback,
|
||
|
rva_igain,
|
||
|
|
||
|
rva_icutoff,
|
||
|
|
||
|
rva_ifparallel,
|
||
|
rva_imoddly,
|
||
|
rva_imodrate,
|
||
|
|
||
|
rva_width,
|
||
|
rva_depth,
|
||
|
rva_height,
|
||
|
|
||
|
rva_fbwidth,
|
||
|
rva_fbdepth,
|
||
|
rva_fbheight,
|
||
|
|
||
|
rva_iftaps,
|
||
|
|
||
|
rva_cparam // # of params
|
||
|
} rva_e;
|
||
|
|
||
|
// filter parameter ranges
|
||
|
|
||
|
prm_rng_t rva_rng[] = {
|
||
|
|
||
|
{rva_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
// reverb params
|
||
|
{rva_size_max, 0.0, 1000.0}, // max room delay in milliseconds
|
||
|
{rva_size_min, 0.0, 1000.0}, // min room delay in milliseconds
|
||
|
{rva_inumdelays,1.0, 12.0}, // controls # of parallel or series delays
|
||
|
{rva_ifeedback, 0.0, 1.0}, // feedback of delays
|
||
|
{rva_igain, 0.0, 10.0}, // output gain
|
||
|
|
||
|
// filter params for each parallel reverb (quality set to 0 for max execution speed)
|
||
|
|
||
|
{rva_icutoff, 10, 22050},
|
||
|
|
||
|
{rva_ifparallel, 0, 1}, // if 1, then all filters operate in parallel with delays. otherwise filter output only
|
||
|
{rva_imoddly, 0.0, 50.0}, // if > 0 then all delays are modulating delays, mod param controls milliseconds of mod depth
|
||
|
{rva_imodrate, 0.0, 10.0}, // how many delay repetitions pass between mod changes to delayl
|
||
|
|
||
|
// override params - for more detailed description of room
|
||
|
// note: width/depth/height < 0 only for some automatic dsp presets
|
||
|
{rva_width, -1000.0, 1000.0}, // 0-1000.0 millisec (room width in feet) - used instead of size if non-zero
|
||
|
{rva_depth, -1000.0, 1000.0}, // 0-1000.0 room depth in feet - used instead of size if non-zero
|
||
|
{rva_height, -1000.0, 1000.0}, // 0-1000.0 room height in feet - used instead of size if non-zero
|
||
|
|
||
|
{rva_fbwidth, -1.0, 1.0}, // 0-1.0 material reflectivity - used as feedback param instead of decay if non-zero
|
||
|
{rva_fbdepth, -1.0, 1.0}, // 0-1.0 material reflectivity - used as feedback param instead of decay if non-zero
|
||
|
{rva_fbheight, -1.0, 1.0}, // 0-1.0 material reflectivity - used as feedback param instead of decay if non-zero
|
||
|
// if < 0, a predelay is allocated, then feedback is -1*param given
|
||
|
|
||
|
{rva_iftaps, 0.0, 0.333} // if > 0, use 3 extra taps with delay values = d * (1 - faps*n) n = 0,1,2,3
|
||
|
};
|
||
|
|
||
|
#define RVA_BASEM 1 // base number of parallel delays
|
||
|
|
||
|
// nominal delay and feedback values. More delays = more density.
|
||
|
|
||
|
#define RVADLYSMAX 49
|
||
|
float rvadlys[] = {18, 23, 28, 33, 42, 21, 26, 36, 39, 45, 47, 30};
|
||
|
float rvafbs[] = {0.9, 0.9, 0.9, 0.85, 0.8, 0.9, 0.9, 0.85, 0.8, 0.8, 0.8, 0.85};
|
||
|
|
||
|
#define SWAP(a,b,t) {(t) = (a); (a) = (b); (b) = (t);}
|
||
|
|
||
|
#define RVA_MIN_SEPARATION 7 // minimum separation between reverbs, in ms.
|
||
|
|
||
|
// Construct D,a,b delay arrays given array of length,width,height sizes and feedback values
|
||
|
// rgd[] array of delay values in milliseconds (feet)
|
||
|
// rgf[] array of feedback values 0..1
|
||
|
// m # of parallel reverbs to construct
|
||
|
// D[] array of output delay values for parallel reverbs
|
||
|
// a[] array of output feedback values
|
||
|
// b[] array of output gain values = 1/m
|
||
|
// gain - output gain
|
||
|
// feedback - default feedback if rgf members are 0
|
||
|
|
||
|
void RVA_ConstructDelays( float *rgd, float *rgf, int m, int *D, int *a, int *b, float gain, float feedback )
|
||
|
{
|
||
|
|
||
|
int i;
|
||
|
float r;
|
||
|
int d;
|
||
|
float t, d1, d2, dm;
|
||
|
bool bpredelay;
|
||
|
|
||
|
// sort descending, so rgd[0] is largest delay & rgd[2] is smallest
|
||
|
|
||
|
if (rgd[2] > rgd[1]) { SWAP(rgd[2], rgd[1], t); SWAP(rgf[2], rgf[1], t); }
|
||
|
if (rgd[1] > rgd[0]) { SWAP(rgd[0], rgd[1], t); SWAP(rgf[0], rgf[1], t); }
|
||
|
if (rgd[2] > rgd[1]) { SWAP(rgd[2], rgd[1], t); SWAP(rgf[2], rgf[1], t); }
|
||
|
|
||
|
// if all feedback values 0, use default feedback
|
||
|
|
||
|
if (rgf[0] == 0.0 && rgf[1] == 0.0 && rgf[2] == 0.0 )
|
||
|
{
|
||
|
// use feedback param for all
|
||
|
|
||
|
rgf[0] = rgf[1] = rgf[2] = feedback;
|
||
|
|
||
|
// adjust feedback down for larger delays so that decay is constant for all delays
|
||
|
|
||
|
rgf[0] = DLY_NormalizeFeedback( rgd[2], rgf[2], rgd[0] );
|
||
|
rgf[1] = DLY_NormalizeFeedback( rgd[2], rgf[2], rgd[1] );
|
||
|
|
||
|
}
|
||
|
|
||
|
// make sure all reverbs are different by at least RVA_MIN_SEPARATION * m/3 m is 3,6,9 or 12
|
||
|
|
||
|
int dmin = (m/3) * RVA_MIN_SEPARATION;
|
||
|
|
||
|
d1 = rgd[1] - rgd[2];
|
||
|
|
||
|
if (d1 <= dmin)
|
||
|
rgd[1] += (dmin-d1); // make difference = dmin
|
||
|
|
||
|
d2 = rgd[0] - rgd[1];
|
||
|
|
||
|
if (d2 <= dmin)
|
||
|
rgd[0] += (dmin-d1); // make difference = dmin
|
||
|
|
||
|
for ( i = 0; i < m; i++ )
|
||
|
{
|
||
|
// reverberations due to room width, depth, height
|
||
|
// assume sound moves at approx 1ft/ms
|
||
|
|
||
|
int j = (int)(fmod ((float)i, 3.0f)); // j counts 0,1,2 0,1,2 0,1..
|
||
|
|
||
|
d = (int)rgd[j];
|
||
|
r = fabs(rgf[j]);
|
||
|
|
||
|
bpredelay = ((rgf[j] < 0) && i < 3);
|
||
|
|
||
|
// re-use predelay values as reverb values:
|
||
|
|
||
|
if (rgf[j] < 0 && !bpredelay)
|
||
|
d = max((int)(rgd[j] / 4.0), RVA_MIN_SEPARATION);
|
||
|
|
||
|
if (i < 3)
|
||
|
dm = 0.0;
|
||
|
else
|
||
|
dm = max( (double)(RVA_MIN_SEPARATION * (i/3)), ((i/3) * ((float)d * 0.18)) );
|
||
|
|
||
|
d += (int)dm;
|
||
|
D[i] = MSEC_TO_SAMPS(d);
|
||
|
|
||
|
// D[i] = MSEC_TO_SAMPS(d + ((i/3) * RVA_MIN_SEPARATION)); // (i/3) counts 0,0,0 1,1,1 2,2,2 ... separate all reverbs by 5ms
|
||
|
|
||
|
// feedback - due to wall/floor/ceiling reflectivity
|
||
|
a[i] = (int) min (0.999 * PMAX, (double)PMAX * r);
|
||
|
|
||
|
if (bpredelay)
|
||
|
a[i] = -a[i]; // flag delay as predelay
|
||
|
|
||
|
b[i] = (int)((float)(gain * PMAX) / (float)m);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void RVA_PerfTest()
|
||
|
{
|
||
|
double time1, time2;
|
||
|
|
||
|
int i;
|
||
|
int k;
|
||
|
int j;
|
||
|
int m;
|
||
|
int a[100];
|
||
|
|
||
|
time1 = Plat_FloatTime();
|
||
|
|
||
|
for (m = 0; m < 1000; m++)
|
||
|
{
|
||
|
for (i = 0, j = 10000; i < 10000; i++, j--)
|
||
|
{
|
||
|
// j = j % 6;
|
||
|
// k = (i * j) >> PBITS;
|
||
|
|
||
|
k = i / ((j % 6) + 1);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
time2 = Plat_FloatTime();
|
||
|
|
||
|
DevMsg("divide = %2.5f \n", (time2-time1));
|
||
|
|
||
|
|
||
|
for (i=1;i<10;i++)
|
||
|
a[i] = PMAX / i;
|
||
|
|
||
|
time1 = Plat_FloatTime();
|
||
|
|
||
|
for (m = 0; m < 1000; m++)
|
||
|
{
|
||
|
for (i = 0, j = 10000; i < 10000; i++, j--)
|
||
|
{
|
||
|
k = (i * a[(j % 6) + 1] ) >> PBITS;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
time2 = Plat_FloatTime();
|
||
|
|
||
|
DevMsg("shift & multiply = %2.5f \n", (time2-time1));
|
||
|
}
|
||
|
|
||
|
rva_t * RVA_Params ( prc_t *pprc )
|
||
|
{
|
||
|
rva_t *prva;
|
||
|
|
||
|
float size_max = pprc->prm[rva_size_max]; // max delay size
|
||
|
float size_min = pprc->prm[rva_size_min]; // min delay size
|
||
|
|
||
|
float numdelays = pprc->prm[rva_inumdelays]; // controls # of parallel delays
|
||
|
float feedback = pprc->prm[rva_ifeedback]; // 0-1.0 controls feedback parameters
|
||
|
float gain = pprc->prm[rva_igain]; // 0-10.0 controls output gain
|
||
|
|
||
|
float cutoff = pprc->prm[rva_icutoff]; // filter cutoff
|
||
|
|
||
|
float fparallel = pprc->prm[rva_ifparallel]; // if true, all filters are in delay feedback paths - otherwise single flt on output
|
||
|
|
||
|
float fmoddly = pprc->prm[rva_imoddly]; // if > 0, milliseconds of delay mod depth
|
||
|
float fmodrate = pprc->prm[rva_imodrate]; // if fmoddly > 0, # of delay repetitions between modulations
|
||
|
|
||
|
float width = fabs(pprc->prm[rva_width]); // 0-1000 controls size of 1/3 of delays - used instead of size if non-zero
|
||
|
float depth = fabs(pprc->prm[rva_depth]); // 0-1000 controls size of 1/3 of delays - used instead of size if non-zero
|
||
|
float height = fabs(pprc->prm[rva_height]); // 0-1000 controls size of 1/3 of delays - used instead of size if non-zero
|
||
|
|
||
|
float fbwidth = pprc->prm[rva_fbwidth]; // feedback parameter for walls 0..2
|
||
|
float fbdepth = pprc->prm[rva_fbdepth]; // feedback parameter for floor
|
||
|
float fbheight = pprc->prm[rva_fbheight]; // feedback parameter for ceiling
|
||
|
|
||
|
float ftaps = pprc->prm[rva_iftaps]; // if > 0 increase reverb density using 3 extra taps d = (1.0 - ftaps * n) n = 0,1,2,3
|
||
|
|
||
|
|
||
|
|
||
|
// RVA_PerfTest();
|
||
|
|
||
|
// D array of CRVB_DLYS reverb delay sizes max sample index w[0...D] (ie: D+1 samples)
|
||
|
// a array of reverb feedback parms for parallel delays
|
||
|
// b array of CRVB_P_DLYS - mix params for parallel reverbs
|
||
|
// m - number of parallel delays
|
||
|
|
||
|
int D[CRVA_DLYS];
|
||
|
int a[CRVA_DLYS];
|
||
|
int b[CRVA_DLYS];
|
||
|
int m;
|
||
|
|
||
|
// limit # delays 1-12
|
||
|
|
||
|
m = clamp (numdelays, (float)RVA_BASEM, (float)CRVA_DLYS);
|
||
|
|
||
|
// set up D (delay) a (feedback) b (gain) arrays
|
||
|
|
||
|
if ( int(width) || int(height) || int(depth) )
|
||
|
{
|
||
|
// if width, height, depth given, use values as simple delays
|
||
|
|
||
|
float rgd[3];
|
||
|
float rgfb[3];
|
||
|
|
||
|
// force m to 3, 6, 9 or 12
|
||
|
|
||
|
if (m < 3) m = 3;
|
||
|
if (m > 3 && m < 6) m = 6;
|
||
|
if (m > 6 && m < 9) m = 9;
|
||
|
if (m > 9) m = 12;
|
||
|
|
||
|
rgd[0] = width; rgfb[0] = fbwidth;
|
||
|
rgd[1] = depth; rgfb[1] = fbdepth;
|
||
|
rgd[2] = height; rgfb[2] = fbheight;
|
||
|
|
||
|
RVA_ConstructDelays( rgd, rgfb, m, D, a, b, gain, feedback );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// use size parameter instead of width/depth/height
|
||
|
|
||
|
for ( int i = 0; i < m; i++ )
|
||
|
{
|
||
|
// delays of parallel reverb. D[0] = size_min.
|
||
|
|
||
|
D[i] = MSEC_TO_SAMPS( size_min + (int)( ((float)(size_max - size_min) / (float)m) * (float)i) );
|
||
|
|
||
|
// feedback and gain of parallel reverb
|
||
|
|
||
|
if (i == 0)
|
||
|
{
|
||
|
// set feedback for smallest delay
|
||
|
|
||
|
a[i] = (int) min (0.999 * PMAX, (double)PMAX * feedback );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// adjust feedback down for larger delays so that decay time is constant
|
||
|
|
||
|
a[i] = (int) min (0.999 * PMAX, (double)PMAX * DLY_NormalizeFeedback( D[0], feedback, D[i] ) );
|
||
|
}
|
||
|
|
||
|
b[i] = (int) ((float)(gain * PMAX) / (float)m);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// add filter
|
||
|
|
||
|
flt_t *pflt = NULL;
|
||
|
|
||
|
if ( cutoff )
|
||
|
{
|
||
|
|
||
|
// set up dummy lowpass filter to convert params
|
||
|
|
||
|
prc_t prcf;
|
||
|
|
||
|
prcf.prm[flt_iquality] = QUA_LO; // force filter to low quality for faster execution time
|
||
|
prcf.prm[flt_icutoff] = cutoff;
|
||
|
prcf.prm[flt_iftype] = FLT_LP;
|
||
|
prcf.prm[flt_iqwidth] = 0;
|
||
|
prcf.prm[flt_igain] = 1.0;
|
||
|
|
||
|
pflt = (flt_t *)FLT_Params ( &prcf );
|
||
|
}
|
||
|
|
||
|
prva = RVA_Alloc ( D, a, b, m, pflt, fparallel, fmoddly, fmodrate, ftaps );
|
||
|
|
||
|
FLT_Free( pflt );
|
||
|
|
||
|
return prva;
|
||
|
}
|
||
|
|
||
|
|
||
|
inline void * RVA_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams ( (prc_t *)p, rva_rng );
|
||
|
return (void *) RVA_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
inline void RVA_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
|
||
|
|
||
|
////////////
|
||
|
// Diffusor
|
||
|
///////////
|
||
|
|
||
|
// (N series allpass reverbs)
|
||
|
|
||
|
#define CDFRS 64 // max number of series reverbs active
|
||
|
|
||
|
#define CDFR_DLYS 16 // max number of delays making up diffusor
|
||
|
|
||
|
struct dfr_t
|
||
|
{
|
||
|
bool fused;
|
||
|
int n; // series allpass delays
|
||
|
int w[CDFR_DLYS]; // internal state array for series allpass filters
|
||
|
|
||
|
dly_t *pdlys[CDFR_DLYS]; // array of pointers to delays
|
||
|
};
|
||
|
|
||
|
dfr_t dfrs[CDFRS];
|
||
|
|
||
|
void DFR_Init ( dfr_t *pdfr ) { if ( pdfr ) Q_memset (pdfr, 0, sizeof (dfr_t)); }
|
||
|
void DFR_InitAll( void ) { for (int i = 0; i < CDFRS; i++) DFR_Init ( &dfrs[i] ); }
|
||
|
|
||
|
// free parallel series reverb
|
||
|
|
||
|
void DFR_Free( dfr_t *pdfr )
|
||
|
{
|
||
|
if ( pdfr )
|
||
|
{
|
||
|
// free all delays
|
||
|
|
||
|
for (int i = 0; i < CDFR_DLYS; i++)
|
||
|
DLY_Free ( pdfr->pdlys[i] );
|
||
|
|
||
|
Q_memset( pdfr, 0, sizeof (dfr_t) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void DFR_FreeAll( void ) { for (int i = 0; i < CDFRS; i++) DFR_Free( &dfrs[i] ); }
|
||
|
|
||
|
// create n series allpass reverbs
|
||
|
|
||
|
// D array of CRVB_DLYS reverb delay sizes max sample index w[0...D] (ie: D+1 samples)
|
||
|
// a array of reverb feedback parms for series delays
|
||
|
// b array of gain params for parallel reverbs
|
||
|
// n - number of series delays
|
||
|
|
||
|
dfr_t * DFR_Alloc ( int *D, int *a, int *b, int n )
|
||
|
{
|
||
|
|
||
|
int i;
|
||
|
dfr_t *pdfr;
|
||
|
|
||
|
// find open slot
|
||
|
|
||
|
for (i = 0; i < CDFRS; i++)
|
||
|
{
|
||
|
if (!dfrs[i].fused)
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// return null if no free slots
|
||
|
|
||
|
if (i == CDFRS)
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate diffusor.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pdfr = &dfrs[i];
|
||
|
|
||
|
DFR_Init( pdfr );
|
||
|
|
||
|
// alloc reverbs
|
||
|
|
||
|
for (i = 0; i < n; i++)
|
||
|
pdfr->pdlys[i] = DLY_Alloc( D[i], a[i], b[i], DLY_ALLPASS );
|
||
|
|
||
|
// if we failed to alloc any reverb, free all, return NULL
|
||
|
|
||
|
for (i = 0; i < n; i++)
|
||
|
{
|
||
|
if ( !pdfr->pdlys[i])
|
||
|
{
|
||
|
DFR_Free( pdfr );
|
||
|
DevMsg ("DSP: Warning, failed to allocate delay for diffusor.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
pdfr->fused = true;
|
||
|
pdfr->n = n;
|
||
|
|
||
|
return pdfr;
|
||
|
}
|
||
|
|
||
|
|
||
|
// series reverberator
|
||
|
|
||
|
inline int DFR_GetNext( dfr_t *pdfr, int x )
|
||
|
{
|
||
|
int i;
|
||
|
int y;
|
||
|
dly_t *pdly;
|
||
|
|
||
|
y = x;
|
||
|
|
||
|
for (i = 0; i < pdfr->n; i++)
|
||
|
{
|
||
|
pdly = pdfr->pdlys[i];
|
||
|
y = DelayAllpass( pdly->D, pdly->t, pdly->w, &pdly->p, pdly->a, pdly->b, y );
|
||
|
}
|
||
|
|
||
|
return y;
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void DFR_GetNextN( dfr_t *pdfr, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = DFR_GetNext( pdfr, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = DFR_GetNext( pdfr, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = DFR_GetNext( pdfr, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#define DFR_BASEN 1 // base number of series allpass delays
|
||
|
|
||
|
// nominal diffusor delay and feedback values
|
||
|
|
||
|
float dfrdlys[] = {13, 19, 26, 21, 32, 36, 38, 16, 24, 28, 41, 35, 10, 46, 50, 27};
|
||
|
float dfrfbs[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
|
||
|
|
||
|
|
||
|
// diffusor parameter order
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
dfr_isize,
|
||
|
dfr_inumdelays,
|
||
|
dfr_ifeedback,
|
||
|
dfr_igain,
|
||
|
|
||
|
dfr_cparam // # of params
|
||
|
|
||
|
} dfr_e;
|
||
|
|
||
|
// diffusor parameter ranges
|
||
|
|
||
|
prm_rng_t dfr_rng[] = {
|
||
|
|
||
|
{dfr_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{dfr_isize, 0.0, 1.0}, // 0-1.0 scales all delays
|
||
|
{dfr_inumdelays,0.0, 4.0}, // 0-4.0 controls # of series delays
|
||
|
{dfr_ifeedback, 0.0, 1.0}, // 0-1.0 scales all feedback parameters
|
||
|
{dfr_igain, 0.0, 10.0}, // 0-1.0 scales all feedback parameters
|
||
|
};
|
||
|
|
||
|
|
||
|
dfr_t * DFR_Params ( prc_t *pprc )
|
||
|
{
|
||
|
dfr_t *pdfr;
|
||
|
int i;
|
||
|
int s;
|
||
|
float size = pprc->prm[dfr_isize]; // 0-1.0 scales all delays
|
||
|
float numdelays = pprc->prm[dfr_inumdelays]; // 0-4.0 controls # of series delays
|
||
|
float feedback = pprc->prm[dfr_ifeedback]; // 0-1.0 scales all feedback parameters
|
||
|
float gain = pprc->prm[dfr_igain]; // 0-10.0 controls output gain
|
||
|
|
||
|
// D array of CRVB_DLYS reverb delay sizes max sample index w[0...D] (ie: D+1 samples)
|
||
|
// a array of reverb feedback parms for series delays (CRVB_S_DLYS)
|
||
|
// b gain of each reverb section
|
||
|
// n - number of series delays
|
||
|
|
||
|
int D[CDFR_DLYS];
|
||
|
int a[CDFR_DLYS];
|
||
|
int b[CDFR_DLYS];
|
||
|
int n;
|
||
|
|
||
|
if (gain == 0.0)
|
||
|
gain = 1.0;
|
||
|
|
||
|
// get # series diffusors
|
||
|
|
||
|
// limit m, n to half max number of delays
|
||
|
|
||
|
n = clamp (Float2Int(numdelays), DFR_BASEN, CDFR_DLYS/2);
|
||
|
|
||
|
// compute delays for diffusors
|
||
|
|
||
|
for (i = 0; i < n; i++)
|
||
|
{
|
||
|
s = (int)( dfrdlys[i] * size );
|
||
|
|
||
|
// delay of diffusor
|
||
|
|
||
|
D[i] = MSEC_TO_SAMPS(s);
|
||
|
|
||
|
// feedback and gain of diffusor
|
||
|
|
||
|
a[i] = min (0.999 * PMAX, (double)(dfrfbs[i] * PMAX * feedback));
|
||
|
b[i] = (int) ( (float)(gain * (float)PMAX) );
|
||
|
}
|
||
|
|
||
|
|
||
|
pdfr = DFR_Alloc ( D, a, b, n );
|
||
|
|
||
|
return pdfr;
|
||
|
}
|
||
|
|
||
|
inline void * DFR_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams ((prc_t *)p, dfr_rng);
|
||
|
return (void *) DFR_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
inline void DFR_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
|
||
|
//////////////////////
|
||
|
// LFO wav definitions
|
||
|
//////////////////////
|
||
|
|
||
|
#define CLFOSAMPS 512 // samples per wav table - single cycle only
|
||
|
#define LFOBITS 14 // bits of peak amplitude of lfo wav
|
||
|
#define LFOAMP ((1<<LFOBITS)-1) // peak amplitude of lfo wav
|
||
|
|
||
|
//types of lfo wavs
|
||
|
|
||
|
#define LFO_SIN 0 // sine wav
|
||
|
#define LFO_TRI 1 // triangle wav
|
||
|
#define LFO_SQR 2 // square wave, 50% duty cycle
|
||
|
#define LFO_SAW 3 // forward saw wav
|
||
|
#define LFO_RND 4 // random wav
|
||
|
#define LFO_LOG_IN 5 // logarithmic fade in
|
||
|
#define LFO_LOG_OUT 6 // logarithmic fade out
|
||
|
#define LFO_LIN_IN 7 // linear fade in
|
||
|
#define LFO_LIN_OUT 8 // linear fade out
|
||
|
#define LFO_MAX LFO_LIN_OUT
|
||
|
|
||
|
#define CLFOWAV 9 // number of LFO wav tables
|
||
|
|
||
|
struct lfowav_t // lfo or envelope wave table
|
||
|
{
|
||
|
int type; // lfo type
|
||
|
dly_t *pdly; // delay holds wav values and step pointers
|
||
|
};
|
||
|
|
||
|
lfowav_t lfowavs[CLFOWAV];
|
||
|
|
||
|
// deallocate lfo wave table. Called only when sound engine exits.
|
||
|
|
||
|
void LFOWAV_Free( lfowav_t *plw )
|
||
|
{
|
||
|
// free delay
|
||
|
|
||
|
if ( plw )
|
||
|
DLY_Free( plw->pdly );
|
||
|
|
||
|
Q_memset( plw, 0, sizeof (lfowav_t) );
|
||
|
}
|
||
|
|
||
|
// deallocate all lfo wave tables. Called only when sound engine exits.
|
||
|
|
||
|
void LFOWAV_FreeAll( void )
|
||
|
{
|
||
|
for ( int i = 0; i < CLFOWAV; i++ )
|
||
|
LFOWAV_Free( &lfowavs[i] );
|
||
|
}
|
||
|
|
||
|
// fill lfo array w with count samples of lfo type 'type'
|
||
|
// all lfo wavs except fade out, rnd, and log_out should start with 0 output
|
||
|
|
||
|
void LFOWAV_Fill( int *w, int count, int type )
|
||
|
{
|
||
|
int i,x;
|
||
|
switch (type)
|
||
|
{
|
||
|
default:
|
||
|
case LFO_SIN: // sine wav, all values 0 <= x <= LFOAMP, initial value = 0
|
||
|
for (i = 0; i < count; i++ )
|
||
|
{
|
||
|
x = ( int )( (float)(LFOAMP) * sinf( (2.0 * M_PI_F * (float)i / (float)count ) + (M_PI_F * 1.5) ) );
|
||
|
w[i] = (x + LFOAMP)/2;
|
||
|
}
|
||
|
break;
|
||
|
case LFO_TRI: // triangle wav, all values 0 <= x <= LFOAMP, initial value = 0
|
||
|
for (i = 0; i < count; i++)
|
||
|
{
|
||
|
w[i] = ( int ) ( (float)(2 * LFOAMP * i ) / (float)(count) );
|
||
|
|
||
|
if ( i > count / 2 )
|
||
|
w[i] = ( int ) ( (float) (2 * LFOAMP) - (float)( 2 * LFOAMP * i ) / (float)(count) );
|
||
|
}
|
||
|
break;
|
||
|
case LFO_SQR: // square wave, 50% duty cycle, all values 0 <= x <= LFOAMP, initial value = 0
|
||
|
for (i = 0; i < count; i++)
|
||
|
w[i] = i > count / 2 ? 0 : LFOAMP;
|
||
|
break;
|
||
|
case LFO_SAW: // forward saw wav, aall values 0 <= x <= LFOAMP, initial value = 0
|
||
|
for (i = 0; i < count; i++)
|
||
|
w[i] = ( int ) ( (float)(LFOAMP) * (float)i / (float)(count) );
|
||
|
break;
|
||
|
case LFO_RND: // random wav, all values 0 <= x <= LFOAMP
|
||
|
for (i = 0; i < count; i++)
|
||
|
w[i] = ( int ) ( RandomInt(0, LFOAMP) );
|
||
|
break;
|
||
|
case LFO_LOG_IN: // logarithmic fade in, all values 0 <= x <= LFOAMP, initial value = 0
|
||
|
for (i = 0; i < count; i++)
|
||
|
w[i] = ( int ) ( (float)(LFOAMP) * powf( (float)i / (float)count, 2));
|
||
|
break;
|
||
|
case LFO_LOG_OUT: // logarithmic fade out, all values 0 <= x <= LFOAMP, initial value = LFOAMP
|
||
|
for (i = 0; i < count; i++)
|
||
|
w[i] = ( int ) ( (float)(LFOAMP) * powf( 1.0 - ((float)i / (float)count), 2 ));
|
||
|
break;
|
||
|
case LFO_LIN_IN: // linear fade in, all values 0 <= x <= LFOAMP, initial value = 0
|
||
|
for (i = 0; i < count; i++)
|
||
|
w[i] = ( int ) ( (float)(LFOAMP) * (float)i / (float)(count) );
|
||
|
break;
|
||
|
case LFO_LIN_OUT: // linear fade out, all values 0 <= x <= LFOAMP, initial value = LFOAMP
|
||
|
for (i = 0; i < count; i++)
|
||
|
w[i] = LFOAMP - ( int ) ( (float)(LFOAMP) * (float)i / (float)(count) );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// allocate all lfo wave tables. Called only when sound engine loads.
|
||
|
|
||
|
void LFOWAV_InitAll()
|
||
|
{
|
||
|
int i;
|
||
|
dly_t *pdly;
|
||
|
|
||
|
Q_memset( lfowavs, 0, sizeof( lfowavs ) );
|
||
|
|
||
|
// alloc space for each lfo wav type
|
||
|
|
||
|
for (i = 0; i < CLFOWAV; i++)
|
||
|
{
|
||
|
pdly = DLY_Alloc( CLFOSAMPS, 0, 0 , DLY_PLAIN);
|
||
|
|
||
|
lfowavs[i].pdly = pdly;
|
||
|
lfowavs[i].type = i;
|
||
|
|
||
|
LFOWAV_Fill( pdly->w, CLFOSAMPS, i );
|
||
|
}
|
||
|
|
||
|
// if any dlys fail to alloc, free all
|
||
|
|
||
|
for (i = 0; i < CLFOWAV; i++)
|
||
|
{
|
||
|
if ( !lfowavs[i].pdly )
|
||
|
LFOWAV_FreeAll();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
////////////////////////////////////////
|
||
|
// LFO iterators - one shot and looping
|
||
|
////////////////////////////////////////
|
||
|
|
||
|
#define CLFO 16 // max active lfos (this steals from active delays)
|
||
|
|
||
|
struct lfo_t
|
||
|
{
|
||
|
bool fused; // true if slot take
|
||
|
|
||
|
dly_t *pdly; // delay points to lfo wav within lfowav_t (don't free this)
|
||
|
|
||
|
int gain;
|
||
|
|
||
|
float f; // playback frequency in hz
|
||
|
|
||
|
pos_t pos; // current position within wav table, looping
|
||
|
pos_one_t pos1; // current position within wav table, one shot
|
||
|
|
||
|
int foneshot; // true - one shot only, don't repeat
|
||
|
};
|
||
|
|
||
|
lfo_t lfos[CLFO];
|
||
|
|
||
|
void LFO_Init( lfo_t *plfo ) { if ( plfo ) Q_memset( plfo, 0, sizeof (lfo_t) ); }
|
||
|
void LFO_InitAll( void ) { for (int i = 0; i < CLFO; i++) LFO_Init(&lfos[i]); }
|
||
|
void LFO_Free( lfo_t *plfo ) { if ( plfo ) Q_memset( plfo, 0, sizeof (lfo_t) ); }
|
||
|
void LFO_FreeAll( void ) { for (int i = 0; i < CLFO; i++) LFO_Free(&lfos[i]); }
|
||
|
|
||
|
|
||
|
// get step value given desired playback frequency
|
||
|
|
||
|
inline float LFO_HzToStep ( float freqHz )
|
||
|
{
|
||
|
float lfoHz;
|
||
|
|
||
|
// calculate integer and fractional step values,
|
||
|
// assume an update rate of SOUND_DMA_SPEED samples/sec
|
||
|
|
||
|
// 1 cycle/CLFOSAMPS * SOUND_DMA_SPEED samps/sec = cycles/sec = current lfo rate
|
||
|
//
|
||
|
// lforate * X = freqHz so X = freqHz/lforate = update rate
|
||
|
|
||
|
lfoHz = (float)(SOUND_DMA_SPEED) / (float)(CLFOSAMPS);
|
||
|
|
||
|
return freqHz / lfoHz;
|
||
|
}
|
||
|
|
||
|
// return pointer to new lfo
|
||
|
|
||
|
lfo_t * LFO_Alloc( int wtype, float freqHz, bool foneshot, float gain )
|
||
|
{
|
||
|
int i;
|
||
|
int type = min ( CLFOWAV - 1, wtype );
|
||
|
float lfostep;
|
||
|
|
||
|
for (i = 0; i < CLFO; i++)
|
||
|
if (!lfos[i].fused)
|
||
|
{
|
||
|
lfo_t *plfo = &lfos[i];
|
||
|
|
||
|
LFO_Init( plfo );
|
||
|
|
||
|
plfo->fused = true;
|
||
|
plfo->pdly = lfowavs[type].pdly; // pdly in lfo points to wav table data in lfowavs
|
||
|
plfo->f = freqHz;
|
||
|
plfo->foneshot = foneshot;
|
||
|
plfo->gain = gain * PMAX;
|
||
|
|
||
|
lfostep = LFO_HzToStep( freqHz );
|
||
|
|
||
|
// init positional pointer (ie: fixed point updater for controlling pitch of lfo)
|
||
|
|
||
|
if ( !foneshot )
|
||
|
POS_Init(&(plfo->pos), plfo->pdly->D, lfostep );
|
||
|
else
|
||
|
POS_ONE_Init(&(plfo->pos1), plfo->pdly->D,lfostep );
|
||
|
|
||
|
return plfo;
|
||
|
}
|
||
|
DevMsg ("DSP: Warning, failed to allocate LFO.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
// get next lfo value
|
||
|
// Value returned is 0..LFOAMP. can be normalized by shifting right by LFOBITS
|
||
|
// To play back at correct passed in frequency, routien should be
|
||
|
// called once for every output sample (ie: at SOUND_DMA_SPEED)
|
||
|
// x is dummy param
|
||
|
|
||
|
inline int LFO_GetNext( lfo_t *plfo, int x )
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
// get current position
|
||
|
|
||
|
if ( !plfo->foneshot )
|
||
|
i = POS_GetNext( &plfo->pos );
|
||
|
else
|
||
|
i = POS_ONE_GetNext( &plfo->pos1 );
|
||
|
|
||
|
// return current sample
|
||
|
|
||
|
if (plfo->gain == PMAX)
|
||
|
return plfo->pdly->w[i];
|
||
|
else
|
||
|
return (plfo->pdly->w[i] * plfo->gain ) >> PBITS;
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void LFO_GetNextN( lfo_t *plfo, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = LFO_GetNext( plfo, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = LFO_GetNext( plfo, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = LFO_GetNext( plfo, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// uses lfowav, rate, foneshot
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
lfo_iwav,
|
||
|
lfo_irate,
|
||
|
lfo_ifoneshot,
|
||
|
lfo_igain,
|
||
|
|
||
|
lfo_cparam // # of params
|
||
|
|
||
|
} lfo_e;
|
||
|
|
||
|
// parameter ranges
|
||
|
|
||
|
prm_rng_t lfo_rng[] = {
|
||
|
|
||
|
{lfo_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{lfo_iwav, 0.0, LFO_MAX}, // lfo type to use (LFO_SIN, LFO_RND...)
|
||
|
{lfo_irate, 0.0, 16000.0}, // modulation rate in hz. for MDY, 1/rate = 'glide' time in seconds
|
||
|
{lfo_ifoneshot, 0.0, 1.0}, // 1.0 if lfo is oneshot
|
||
|
{lfo_igain, 0.0, 10.0}, // output gain
|
||
|
};
|
||
|
|
||
|
|
||
|
lfo_t * LFO_Params ( prc_t *pprc )
|
||
|
{
|
||
|
lfo_t *plfo;
|
||
|
bool foneshot = pprc->prm[lfo_ifoneshot] > 0 ? true : false;
|
||
|
float gain = pprc->prm[lfo_igain];
|
||
|
|
||
|
plfo = LFO_Alloc ( pprc->prm[lfo_iwav], pprc->prm[lfo_irate], foneshot, gain );
|
||
|
|
||
|
return plfo;
|
||
|
}
|
||
|
|
||
|
void LFO_ChangeVal ( lfo_t *plfo, float fhz )
|
||
|
{
|
||
|
float fstep = LFO_HzToStep( fhz );
|
||
|
|
||
|
// change lfo playback rate to new frequency fhz
|
||
|
|
||
|
if ( plfo->foneshot )
|
||
|
POS_ChangeVal( &plfo->pos, fstep );
|
||
|
else
|
||
|
POS_ChangeVal( &plfo->pos1.p, fstep );
|
||
|
}
|
||
|
|
||
|
inline void * LFO_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams ( (prc_t *)p, lfo_rng );
|
||
|
return (void *) LFO_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
// v is +/- 0-1.0
|
||
|
// v changes current lfo frequency up/down by +/- v%
|
||
|
|
||
|
inline void LFO_Mod ( lfo_t *plfo, float v )
|
||
|
{
|
||
|
float fhz;
|
||
|
float fhznew;
|
||
|
|
||
|
fhz = plfo->f;
|
||
|
fhznew = fhz * (1.0 + v);
|
||
|
|
||
|
LFO_ChangeVal ( plfo, fhznew );
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
////////////////////////////////////////
|
||
|
// Time Compress/expand with pitch shift
|
||
|
////////////////////////////////////////
|
||
|
|
||
|
// realtime pitch shift - ie: pitch shift without change to playback rate
|
||
|
|
||
|
#define CPTCS 64
|
||
|
|
||
|
struct ptc_t
|
||
|
{
|
||
|
bool fused;
|
||
|
|
||
|
dly_t *pdly_in; // input buffer space
|
||
|
dly_t *pdly_out; // output buffer space
|
||
|
|
||
|
int *pin; // input buffer (pdly_in->w)
|
||
|
int *pout; // output buffer (pdly_out->w)
|
||
|
|
||
|
int cin; // # samples in input buffer
|
||
|
int cout; // # samples in output buffer
|
||
|
|
||
|
int cxfade; // # samples in crossfade segment
|
||
|
int ccut; // # samples to cut
|
||
|
int cduplicate; // # samples to duplicate (redundant - same as ccut)
|
||
|
|
||
|
int iin; // current index into input buffer (reading)
|
||
|
|
||
|
pos_one_t psn; // stepping index through output buffer
|
||
|
|
||
|
bool fdup; // true if duplicating, false if cutting
|
||
|
|
||
|
float fstep; // pitch shift & time compress/expand
|
||
|
};
|
||
|
|
||
|
ptc_t ptcs[CPTCS];
|
||
|
|
||
|
void PTC_Init( ptc_t *pptc ) { if (pptc) Q_memset( pptc, 0, sizeof (ptc_t) ); };
|
||
|
void PTC_Free( ptc_t *pptc )
|
||
|
{
|
||
|
if (pptc)
|
||
|
{
|
||
|
DLY_Free (pptc->pdly_in);
|
||
|
DLY_Free (pptc->pdly_out);
|
||
|
|
||
|
Q_memset( pptc, 0, sizeof (ptc_t) );
|
||
|
}
|
||
|
};
|
||
|
void PTC_InitAll() { for (int i = 0; i < CPTCS; i++) PTC_Init( &ptcs[i] ); };
|
||
|
void PTC_FreeAll() { for (int i = 0; i < CPTCS; i++) PTC_Free( &ptcs[i] ); };
|
||
|
|
||
|
|
||
|
|
||
|
// Time compressor/expander with pitch shift (ie: pitch changes, playback rate does not)
|
||
|
//
|
||
|
// Algorithm:
|
||
|
|
||
|
// 1) Duplicate or discard chunks of sound to provide tslice * fstep seconds of sound.
|
||
|
// (The user-selectable size of the buffer to process is tslice milliseconds in length)
|
||
|
// 2) Resample this compressed/expanded buffer at fstep to produce a pitch shifted
|
||
|
// output with the same duration as the input (ie: #samples out = # samples in, an
|
||
|
// obvious requirement for realtime inline processing).
|
||
|
|
||
|
// timeslice is size in milliseconds of full buffer to process.
|
||
|
// timeslice * fstep is the size of the expanded/compressed buffer
|
||
|
// timexfade is length in milliseconds of crossfade region between duplicated or cut sections
|
||
|
// fstep is % expanded/compressed sound normalized to 0.01-2.0 (1% - 200%)
|
||
|
|
||
|
// input buffer:
|
||
|
|
||
|
// iin-->
|
||
|
|
||
|
// [0... tslice ...D] input samples 0...D (D is NEWEST sample)
|
||
|
// [0... ...n][m... tseg ...D] region to be cut or duplicated m...D
|
||
|
|
||
|
// [0... [p..txf1..n][m... tseg ...D] fade in region 1 txf1 p...n
|
||
|
// [0... ...n][m..[q..txf2..D] fade out region 2 txf2 q...D
|
||
|
|
||
|
|
||
|
// pitch up: duplicate into output buffer: tdup = tseg
|
||
|
|
||
|
// [0... ...n][m... tdup ...D][m... tdup ...D] output buffer size with duplicate region
|
||
|
// [0... ...n][m..[p...xf1..n][m... tdup ...D] fade in p...n while fading out q...D
|
||
|
// [0... ...n][m..[q...xf2..D][m... tdup ...D]
|
||
|
// [0... ...n][m..[.XFADE...n][m... tdup ...D] final duplicated output buffer - resample at fstep
|
||
|
|
||
|
// pitch down: cut into output buffer: tcut = tseg
|
||
|
|
||
|
// [0... ...n][m... tcut ...D] input samples with cut region delineated m...D
|
||
|
// [0... ...n] output buffer size after cut
|
||
|
// [0... [q..txf2...D] fade in txf1 q...D while fade out txf2 p...n
|
||
|
// [0... [.XFADE ...D] final cut output buffer - resample at fstep
|
||
|
|
||
|
|
||
|
ptc_t * PTC_Alloc( float timeslice, float timexfade, float fstep )
|
||
|
{
|
||
|
|
||
|
int i;
|
||
|
ptc_t *pptc;
|
||
|
float tout;
|
||
|
int cin, cout;
|
||
|
float tslice = timeslice;
|
||
|
float txfade = timexfade;
|
||
|
float tcutdup;
|
||
|
|
||
|
// find time compressor slot
|
||
|
|
||
|
for ( i = 0; i < CPTCS; i++ )
|
||
|
{
|
||
|
if ( !ptcs[i].fused )
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if ( i == CPTCS )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate pitch shifter.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pptc = &ptcs[i];
|
||
|
|
||
|
PTC_Init ( pptc );
|
||
|
|
||
|
// get size of region to cut or duplicate
|
||
|
|
||
|
tcutdup = abs((fstep - 1.0) * timeslice);
|
||
|
|
||
|
// to prevent buffer overruns:
|
||
|
|
||
|
// make sure timeslice is greater than cut/dup time
|
||
|
|
||
|
tslice = max ( (double)tslice, 1.1 * tcutdup);
|
||
|
|
||
|
// make sure xfade time smaller than cut/dup time, and smaller than (timeslice-cutdup) time
|
||
|
|
||
|
txfade = min ( (double)txfade, 0.9 * tcutdup );
|
||
|
txfade = min ( (double)txfade, 0.9 * (tslice - tcutdup));
|
||
|
|
||
|
pptc->cxfade = MSEC_TO_SAMPS( txfade );
|
||
|
pptc->ccut = MSEC_TO_SAMPS( tcutdup );
|
||
|
pptc->cduplicate = MSEC_TO_SAMPS( tcutdup );
|
||
|
|
||
|
// alloc delay lines (buffers)
|
||
|
|
||
|
tout = tslice * fstep;
|
||
|
|
||
|
cin = MSEC_TO_SAMPS( tslice );
|
||
|
cout = MSEC_TO_SAMPS( tout );
|
||
|
|
||
|
pptc->pdly_in = DLY_Alloc( cin, 0, 1, DLY_LINEAR ); // alloc input buffer
|
||
|
pptc->pdly_out = DLY_Alloc( cout, 0, 1, DLY_LINEAR); // alloc output buffer
|
||
|
|
||
|
if ( !pptc->pdly_in || !pptc->pdly_out )
|
||
|
{
|
||
|
PTC_Free( pptc );
|
||
|
DevMsg ("DSP: Warning, failed to allocate delay for pitch shifter.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
// buffer pointers
|
||
|
|
||
|
pptc->pin = pptc->pdly_in->w;
|
||
|
pptc->pout = pptc->pdly_out->w;
|
||
|
|
||
|
// input buffer index
|
||
|
|
||
|
pptc->iin = 0;
|
||
|
|
||
|
// output buffer index
|
||
|
|
||
|
POS_ONE_Init ( &pptc->psn, cout, fstep );
|
||
|
|
||
|
// if fstep > 1.0 we're pitching shifting up, so fdup = true
|
||
|
|
||
|
pptc->fdup = fstep > 1.0 ? true : false;
|
||
|
|
||
|
pptc->cin = cin;
|
||
|
pptc->cout = cout;
|
||
|
|
||
|
pptc->fstep = fstep;
|
||
|
pptc->fused = true;
|
||
|
|
||
|
return pptc;
|
||
|
}
|
||
|
|
||
|
// linear crossfader
|
||
|
// yfadein - instantaneous value fading in
|
||
|
// ydafeout -instantaneous value fading out
|
||
|
// nsamples - duration in #samples of fade
|
||
|
// isample - index in to fade 0...nsamples-1
|
||
|
|
||
|
inline int xfade ( int yfadein, int yfadeout, int nsamples, int isample )
|
||
|
{
|
||
|
int yout;
|
||
|
int m = (isample << PBITS ) / nsamples;
|
||
|
|
||
|
// yout = ((yfadein * m) >> PBITS) + ((yfadeout * (PMAX - m)) >> PBITS);
|
||
|
yout = (yfadeout + (yfadein - yfadeout) * m ) >> PBITS;
|
||
|
|
||
|
return yout;
|
||
|
}
|
||
|
|
||
|
// w - pointer to start of input buffer samples
|
||
|
// v - pointer to start of output buffer samples
|
||
|
// cin - # of input buffer samples
|
||
|
// cout = # of output buffer samples
|
||
|
// cxfade = # of crossfade samples
|
||
|
// cduplicate = # of samples in duplicate/cut segment
|
||
|
|
||
|
void TimeExpand( int *w, int *v, int cin, int cout, int cxfade, int cduplicate )
|
||
|
{
|
||
|
int i,j;
|
||
|
int m;
|
||
|
int p;
|
||
|
int q;
|
||
|
int D;
|
||
|
|
||
|
// input buffer
|
||
|
// xfade source duplicate
|
||
|
// [0...........][p.......n][m...........D]
|
||
|
|
||
|
// output buffer
|
||
|
// xfade region duplicate
|
||
|
// [0.....................n][m..[q.......D][m...........D]
|
||
|
|
||
|
// D - index of last sample in input buffer
|
||
|
// m - index of 1st sample in duplication region
|
||
|
// p - index of 1st sample of crossfade source
|
||
|
// q - index of 1st sample in crossfade region
|
||
|
|
||
|
D = cin - 1;
|
||
|
m = cin - cduplicate;
|
||
|
p = m - cxfade;
|
||
|
q = cin - cxfade;
|
||
|
|
||
|
// copy up to crossfade region
|
||
|
|
||
|
for (i = 0; i < q; i++)
|
||
|
v[i] = w[i];
|
||
|
|
||
|
// crossfade region
|
||
|
|
||
|
j = p;
|
||
|
|
||
|
for (i = q; i <= D; i++)
|
||
|
v[i] = xfade (w[j++], w[i], cxfade, i-q); // fade out p..n, fade in q..D
|
||
|
|
||
|
// duplicate region
|
||
|
|
||
|
j = D+1;
|
||
|
|
||
|
for (i = m; i <= D; i++)
|
||
|
v[j++] = w[i];
|
||
|
|
||
|
}
|
||
|
|
||
|
// cut ccut samples from end of input buffer, crossfade end of cut section
|
||
|
// with end of remaining section
|
||
|
|
||
|
// w - pointer to start of input buffer samples
|
||
|
// v - pointer to start of output buffer samples
|
||
|
// cin - # of input buffer samples
|
||
|
// cout = # of output buffer samples
|
||
|
// cxfade = # of crossfade samples
|
||
|
// ccut = # of samples in cut segment
|
||
|
|
||
|
void TimeCompress( int *w, int *v, int cin, int cout, int cxfade, int ccut )
|
||
|
{
|
||
|
int i,j;
|
||
|
int m;
|
||
|
int p;
|
||
|
int q;
|
||
|
int D;
|
||
|
|
||
|
// input buffer
|
||
|
// xfade source
|
||
|
// [0.....................n][m..[p.......D]
|
||
|
|
||
|
// xfade region cut
|
||
|
// [0...........][q.......n][m...........D]
|
||
|
|
||
|
// output buffer
|
||
|
// xfade to source
|
||
|
// [0...........][p.......D]
|
||
|
|
||
|
// D - index of last sample in input buffer
|
||
|
// m - index of 1st sample in cut region
|
||
|
// p - index of 1st sample of crossfade source
|
||
|
// q - index of 1st sample in crossfade region
|
||
|
|
||
|
D = cin - 1;
|
||
|
m = cin - ccut;
|
||
|
p = cin - cxfade;
|
||
|
q = m - cxfade;
|
||
|
|
||
|
// copy up to crossfade region
|
||
|
|
||
|
for (i = 0; i < q; i++)
|
||
|
v[i] = w[i];
|
||
|
|
||
|
// crossfade region
|
||
|
|
||
|
j = p;
|
||
|
|
||
|
for (i = q; i < m; i++)
|
||
|
v[i] = xfade (w[j++], w[i], cxfade, i-q); // fade out p..n, fade in q..D
|
||
|
|
||
|
// skip rest of input buffer
|
||
|
}
|
||
|
|
||
|
// get next sample
|
||
|
|
||
|
// put input sample into input (delay) buffer
|
||
|
// get output sample from output buffer, step by fstep %
|
||
|
// output buffer is time expanded or compressed version of previous input buffer
|
||
|
|
||
|
inline int PTC_GetNext( ptc_t *pptc, int x )
|
||
|
{
|
||
|
int iout, xout;
|
||
|
bool fhitend = false;
|
||
|
|
||
|
// write x into input buffer
|
||
|
Assert (pptc->iin < pptc->cin);
|
||
|
|
||
|
pptc->pin[pptc->iin] = x;
|
||
|
|
||
|
pptc->iin++;
|
||
|
|
||
|
// check for end of input buffer
|
||
|
|
||
|
if ( pptc->iin >= pptc->cin )
|
||
|
fhitend = true;
|
||
|
|
||
|
// read sample from output buffer, resampling at fstep
|
||
|
|
||
|
iout = POS_ONE_GetNext( &pptc->psn );
|
||
|
Assert (iout < pptc->cout);
|
||
|
xout = pptc->pout[iout];
|
||
|
|
||
|
if ( fhitend )
|
||
|
{
|
||
|
// if hit end of input buffer (ie: input buffer is full)
|
||
|
// reset input buffer pointer
|
||
|
// reset output buffer pointer
|
||
|
// rebuild entire output buffer (TimeCompress/TimeExpand)
|
||
|
|
||
|
pptc->iin = 0;
|
||
|
|
||
|
POS_ONE_Init( &pptc->psn, pptc->cout, pptc->fstep );
|
||
|
|
||
|
if ( pptc->fdup )
|
||
|
TimeExpand ( pptc->pin, pptc->pout, pptc->cin, pptc->cout, pptc->cxfade, pptc->cduplicate );
|
||
|
else
|
||
|
TimeCompress ( pptc->pin, pptc->pout, pptc->cin, pptc->cout, pptc->cxfade, pptc->ccut );
|
||
|
}
|
||
|
|
||
|
return xout;
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void PTC_GetNextN( ptc_t *pptc, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = PTC_GetNext( pptc, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = PTC_GetNext( pptc, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = PTC_GetNext( pptc, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// change time compression to new value
|
||
|
// fstep is new value
|
||
|
// ramptime is how long change takes in seconds (ramps smoothly), 0 for no ramp
|
||
|
|
||
|
void PTC_ChangeVal( ptc_t *pptc, float fstep, float ramptime )
|
||
|
{
|
||
|
// UNDONE: ignored
|
||
|
// UNDONE: just realloc time compressor with new fstep
|
||
|
}
|
||
|
|
||
|
// uses pitch:
|
||
|
// 1.0 = playback normal rate
|
||
|
// 0.5 = cut 50% of sound (2x playback)
|
||
|
// 1.5 = add 50% sound (0.5x playback)
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
ptc_ipitch,
|
||
|
ptc_itimeslice,
|
||
|
ptc_ixfade,
|
||
|
|
||
|
ptc_cparam // # of params
|
||
|
|
||
|
} ptc_e;
|
||
|
|
||
|
// diffusor parameter ranges
|
||
|
|
||
|
prm_rng_t ptc_rng[] = {
|
||
|
|
||
|
{ptc_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{ptc_ipitch, 0.1, 4.0}, // 0-n.0 where 1.0 = 1 octave up and 0.5 is one octave down
|
||
|
{ptc_itimeslice, 20.0, 300.0}, // in milliseconds - size of sound chunk to analyze and cut/duplicate - 100ms nominal
|
||
|
{ptc_ixfade, 1.0, 200.0}, // in milliseconds - size of crossfade region between spliced chunks - 20ms nominal
|
||
|
};
|
||
|
|
||
|
|
||
|
ptc_t * PTC_Params ( prc_t *pprc )
|
||
|
{
|
||
|
ptc_t *pptc;
|
||
|
|
||
|
float pitch = pprc->prm[ptc_ipitch];
|
||
|
float timeslice = pprc->prm[ptc_itimeslice];
|
||
|
float txfade = pprc->prm[ptc_ixfade];
|
||
|
|
||
|
pptc = PTC_Alloc( timeslice, txfade, pitch );
|
||
|
|
||
|
return pptc;
|
||
|
}
|
||
|
|
||
|
inline void * PTC_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams ( (prc_t *)p, ptc_rng );
|
||
|
return (void *) PTC_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
// change to new pitch value
|
||
|
// v is +/- 0-1.0
|
||
|
// v changes current pitch up/down by +/- v%
|
||
|
|
||
|
void PTC_Mod ( ptc_t *pptc, float v )
|
||
|
{
|
||
|
float fstep;
|
||
|
float fstepnew;
|
||
|
|
||
|
fstep = pptc->fstep;
|
||
|
fstepnew = fstep * (1.0 + v);
|
||
|
|
||
|
PTC_ChangeVal( pptc, fstepnew, 0.01 );
|
||
|
}
|
||
|
|
||
|
|
||
|
////////////////////
|
||
|
// ADSR envelope
|
||
|
////////////////////
|
||
|
|
||
|
#define CENVS 64 // max # of envelopes active
|
||
|
#define CENVRMPS 4 // A, D, S, R
|
||
|
|
||
|
#define ENV_LIN 0 // linear a,d,s,r
|
||
|
#define ENV_EXP 1 // exponential a,d,s,r
|
||
|
#define ENV_MAX ENV_EXP
|
||
|
|
||
|
#define ENV_BITS 14 // bits of resolution of ramp
|
||
|
|
||
|
struct env_t
|
||
|
{
|
||
|
bool fused;
|
||
|
|
||
|
bool fhitend; // true if done
|
||
|
bool fexp; // true if exponential ramps
|
||
|
|
||
|
int ienv; // current ramp
|
||
|
rmp_t rmps[CENVRMPS]; // ramps
|
||
|
};
|
||
|
|
||
|
env_t envs[CENVS];
|
||
|
|
||
|
void ENV_Init( env_t *penv ) { if (penv) Q_memset( penv, 0, sizeof (env_t) ); };
|
||
|
void ENV_Free( env_t *penv ) { if (penv) Q_memset( penv, 0, sizeof (env_t) ); };
|
||
|
void ENV_InitAll() { for (int i = 0; i < CENVS; i++) ENV_Init( &envs[i] ); };
|
||
|
void ENV_FreeAll() { for (int i = 0; i < CENVS; i++) ENV_Free( &envs[i] ); };
|
||
|
|
||
|
|
||
|
// allocate ADSR envelope
|
||
|
// all times are in seconds
|
||
|
// amp1 - attack amplitude multiplier 0-1.0
|
||
|
// amp2 - sustain amplitude multiplier 0-1.0
|
||
|
// amp3 - end of sustain amplitude multiplier 0-1.0
|
||
|
|
||
|
env_t *ENV_Alloc ( int type, float famp1, float famp2, float famp3, float attack, float decay, float sustain, float release, bool fexp)
|
||
|
{
|
||
|
int i;
|
||
|
env_t *penv;
|
||
|
|
||
|
for (i = 0; i < CENVS; i++)
|
||
|
{
|
||
|
if ( !envs[i].fused )
|
||
|
{
|
||
|
|
||
|
int amp1 = famp1 * (1 << ENV_BITS); // ramp resolution
|
||
|
int amp2 = famp2 * (1 << ENV_BITS);
|
||
|
int amp3 = famp3 * (1 << ENV_BITS);
|
||
|
|
||
|
penv = &envs[i];
|
||
|
|
||
|
ENV_Init (penv);
|
||
|
|
||
|
// UNDONE: ignoring type = ENV_EXP - use oneshot LFOS instead with sawtooth/exponential
|
||
|
|
||
|
// set up ramps
|
||
|
|
||
|
RMP_Init( &penv->rmps[0], attack, 0, amp1, true );
|
||
|
RMP_Init( &penv->rmps[1], decay, amp1, amp2, true );
|
||
|
RMP_Init( &penv->rmps[2], sustain, amp2, amp3, true );
|
||
|
RMP_Init( &penv->rmps[3], release, amp3, 0, true );
|
||
|
|
||
|
penv->ienv = 0;
|
||
|
penv->fused = true;
|
||
|
penv->fhitend = false;
|
||
|
penv->fexp = fexp;
|
||
|
return penv;
|
||
|
}
|
||
|
}
|
||
|
DevMsg ("DSP: Warning, failed to allocate envelope.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
inline int ENV_GetNext( env_t *penv, int x )
|
||
|
{
|
||
|
if ( !penv->fhitend )
|
||
|
{
|
||
|
int i;
|
||
|
int y;
|
||
|
|
||
|
i = penv->ienv;
|
||
|
y = RMP_GetNext ( &penv->rmps[i] );
|
||
|
|
||
|
// check for next ramp
|
||
|
|
||
|
if ( penv->rmps[i].fhitend )
|
||
|
i++;
|
||
|
|
||
|
penv->ienv = i;
|
||
|
|
||
|
// check for end of all ramps
|
||
|
|
||
|
if ( i > 3)
|
||
|
penv->fhitend = true;
|
||
|
|
||
|
// multiply input signal by ramp
|
||
|
|
||
|
if (penv->fexp)
|
||
|
return (((x * y) >> ENV_BITS) * y) >> ENV_BITS;
|
||
|
else
|
||
|
return (x * y) >> ENV_BITS;
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void ENV_GetNextN( env_t *penv, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = ENV_GetNext( penv, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = ENV_GetNext( penv, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = ENV_GetNext( penv, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// uses lfowav, amp1, amp2, amp3, attack, decay, sustain, release
|
||
|
// lfowav is type, currently ignored - ie: LFO_LIN_IN, LFO_LOG_IN
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
env_itype,
|
||
|
env_iamp1,
|
||
|
env_iamp2,
|
||
|
env_iamp3,
|
||
|
env_iattack,
|
||
|
env_idecay,
|
||
|
env_isustain,
|
||
|
env_irelease,
|
||
|
env_ifexp,
|
||
|
env_cparam // # of params
|
||
|
|
||
|
} env_e;
|
||
|
|
||
|
// parameter ranges
|
||
|
|
||
|
prm_rng_t env_rng[] = {
|
||
|
|
||
|
{env_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{env_itype, 0.0,ENV_MAX}, // ENV_LINEAR, ENV_LOG - currently ignored
|
||
|
{env_iamp1, 0.0, 1.0}, // attack peak amplitude 0-1.0
|
||
|
{env_iamp2, 0.0, 1.0}, // decay target amplitued 0-1.0
|
||
|
{env_iamp3, 0.0, 1.0}, // sustain target amplitude 0-1.0
|
||
|
{env_iattack, 0.0, 20000.0}, // attack time in milliseconds
|
||
|
{env_idecay, 0.0, 20000.0}, // envelope decay time in milliseconds
|
||
|
{env_isustain, 0.0, 20000.0}, // sustain time in milliseconds
|
||
|
{env_irelease, 0.0, 20000.0}, // release time in milliseconds
|
||
|
{env_ifexp, 0.0, 1.0}, // 1.0 if exponential ramps
|
||
|
};
|
||
|
|
||
|
env_t * ENV_Params ( prc_t *pprc )
|
||
|
{
|
||
|
env_t *penv;
|
||
|
|
||
|
float type = pprc->prm[env_itype];
|
||
|
float amp1 = pprc->prm[env_iamp1];
|
||
|
float amp2 = pprc->prm[env_iamp2];
|
||
|
float amp3 = pprc->prm[env_iamp3];
|
||
|
float attack = pprc->prm[env_iattack]/1000.0;
|
||
|
float decay = pprc->prm[env_idecay]/1000.0;
|
||
|
float sustain = pprc->prm[env_isustain]/1000.0;
|
||
|
float release = pprc->prm[env_irelease]/1000.0;
|
||
|
float fexp = pprc->prm[env_ifexp];
|
||
|
bool bexp;
|
||
|
|
||
|
bexp = fexp > 0.0 ? 1 : 0;
|
||
|
penv = ENV_Alloc ( type, amp1, amp2, amp3, attack, decay, sustain, release, bexp );
|
||
|
return penv;
|
||
|
}
|
||
|
|
||
|
inline void * ENV_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams( (prc_t *)p, env_rng );
|
||
|
return (void *) ENV_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
inline void ENV_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
//////////////////////////
|
||
|
// Gate & envelope follower
|
||
|
//////////////////////////
|
||
|
|
||
|
#define CEFOS 64 // max # of envelope followers active
|
||
|
|
||
|
struct efo_t
|
||
|
{
|
||
|
bool fused;
|
||
|
|
||
|
int xout; // current output value
|
||
|
|
||
|
// gate params
|
||
|
|
||
|
bool bgate; // if true, gate function is on
|
||
|
|
||
|
bool bgateon; // if true, gate is on
|
||
|
bool bexp; // if true, use exponential fade out
|
||
|
|
||
|
int thresh; // amplitude threshold for gate on
|
||
|
int thresh_off; // amplitidue threshold for gate off
|
||
|
|
||
|
float attack_time; // gate attack time in seconds
|
||
|
float decay_time; // gate decay time in seconds
|
||
|
|
||
|
rmp_t rmp_attack; // gate on ramp - attack
|
||
|
rmp_t rmp_decay; // gate off ramp - decay
|
||
|
};
|
||
|
|
||
|
efo_t efos[CEFOS];
|
||
|
|
||
|
void EFO_Init( efo_t *pefo ) { if (pefo) Q_memset( pefo, 0, sizeof (efo_t) ); };
|
||
|
void EFO_Free( efo_t *pefo ) { if (pefo) Q_memset( pefo, 0, sizeof (efo_t) ); };
|
||
|
void EFO_InitAll() { for (int i = 0; i < CEFOS; i++) EFO_Init( &efos[i] ); };
|
||
|
void EFO_FreeAll() { for (int i = 0; i < CEFOS; i++) EFO_Free( &efos[i] ); };
|
||
|
|
||
|
// return true when gate is off AND decay ramp has hit end
|
||
|
|
||
|
inline bool EFO_GateOff( efo_t *pefo )
|
||
|
{
|
||
|
return ( !pefo->bgateon && RMP_HitEnd( &pefo->rmp_decay ) );
|
||
|
}
|
||
|
|
||
|
|
||
|
// allocate enveloper follower
|
||
|
|
||
|
#define EFO_HYST_AMP 1000 // hysteresis amplitude
|
||
|
|
||
|
efo_t *EFO_Alloc ( float threshold, float attack_sec, float decay_sec, bool bexp )
|
||
|
{
|
||
|
int i;
|
||
|
efo_t *pefo;
|
||
|
|
||
|
for (i = 0; i < CEFOS; i++)
|
||
|
{
|
||
|
if ( !efos[i].fused )
|
||
|
{
|
||
|
pefo = &efos[i];
|
||
|
|
||
|
EFO_Init ( pefo );
|
||
|
|
||
|
pefo->xout = 0;
|
||
|
pefo->fused = true;
|
||
|
|
||
|
// init gate params
|
||
|
|
||
|
pefo->bgate = threshold > 0.0;
|
||
|
|
||
|
if (pefo->bgate)
|
||
|
{
|
||
|
pefo->attack_time = attack_sec;
|
||
|
pefo->decay_time = decay_sec;
|
||
|
|
||
|
RMP_Init( &pefo->rmp_attack, attack_sec, 0, PMAX, false);
|
||
|
RMP_Init( &pefo->rmp_decay, decay_sec, PMAX, 0, false);
|
||
|
RMP_SetEnd( &pefo->rmp_attack );
|
||
|
RMP_SetEnd( &pefo->rmp_decay );
|
||
|
|
||
|
pefo->thresh = threshold;
|
||
|
pefo->thresh_off = max(1.f, threshold - EFO_HYST_AMP);
|
||
|
pefo->bgateon = false;
|
||
|
pefo->bexp = bexp;
|
||
|
}
|
||
|
|
||
|
return pefo;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
DevMsg ("DSP: Warning, failed to allocate envelope follower.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
// values of L for CEFO_BITS_DIVIDE: L = (1 - 1/(1 << CEFO_BITS_DIVIDE))
|
||
|
// 1 L = 0.5
|
||
|
// 2 L = 0.75
|
||
|
// 3 L = 0.875
|
||
|
// 4 L = 0.9375
|
||
|
// 5 L = 0.96875
|
||
|
// 6 L = 0.984375
|
||
|
// 7 L = 0.9921875
|
||
|
// 8 L = 0.99609375
|
||
|
// 9 L = 0.998046875
|
||
|
// 10 L = 0.9990234375
|
||
|
// 11 L = 0.99951171875
|
||
|
// 12 L = 0.999755859375
|
||
|
|
||
|
|
||
|
// decay time constant for values of L, for E = 10^-3 = 60dB of attenuation
|
||
|
//
|
||
|
// Neff = Ln E / Ln L = -6.9077552 / Ln L
|
||
|
//
|
||
|
// 1 L = 0.5 Neff = 10 samples
|
||
|
// 2 L = 0.75 Neff = 24
|
||
|
// 3 L = 0.875 Neff = 51
|
||
|
// 4 L = 0.9375 Neff = 107
|
||
|
// 5 L = 0.96875 Neff = 217
|
||
|
// 6 L = 0.984375 Neff = 438
|
||
|
// 7 L = 0.9921875 Neff = 880
|
||
|
// 8 L = 0.99609375 Neff = 1764
|
||
|
// 9 L = 0.998046875 Neff = 3533
|
||
|
// 10 L = 0.9990234375 Neff = 7070
|
||
|
// 11 L = 0.99951171875 Neff = 14143
|
||
|
// 12 L = 0.999755859375 Neff = 28290
|
||
|
|
||
|
#define CEFO_BITS 11 // 14143 samples in gate window (3hz)
|
||
|
|
||
|
inline int EFO_GetNext( efo_t *pefo, int x )
|
||
|
{
|
||
|
int r;
|
||
|
int xa = abs(x);
|
||
|
int xdif;
|
||
|
|
||
|
|
||
|
// get envelope:
|
||
|
// Cn = L * Cn-1 + ( 1 - L ) * |x|
|
||
|
|
||
|
// which simplifies to:
|
||
|
// Cn = |x| + (Cn-1 - |x|) * L
|
||
|
|
||
|
// for 0 < L < 1
|
||
|
|
||
|
// increasing L increases time to rise or fall to a new input level
|
||
|
|
||
|
// so: increasing CEFO_BITS_DIVIDE increases rise/fall time
|
||
|
|
||
|
// where: L = (1 - 1/(1 << CEFO_BITS))
|
||
|
// xdif = Cn-1 - |x|
|
||
|
// so: xdif * L = xdif - xdif / (1 << CEFO_BITS) = ((xdif << CEFO_BITS) - xdif ) >> CEFO_BITS
|
||
|
|
||
|
xdif = pefo->xout - xa;
|
||
|
|
||
|
pefo->xout = xa + (((xdif << CEFO_BITS) - xdif) >> CEFO_BITS);
|
||
|
|
||
|
if ( pefo->bgate )
|
||
|
{
|
||
|
// gate
|
||
|
|
||
|
bool bgateon_prev = pefo->bgateon;
|
||
|
|
||
|
// gate hysteresis
|
||
|
|
||
|
if (bgateon_prev)
|
||
|
// gate was on - it's off only if amp drops below thresh_off
|
||
|
pefo->bgateon = ( pefo->xout >= pefo->thresh_off );
|
||
|
else
|
||
|
// gate was off - it's on only if amp > thresh
|
||
|
pefo->bgateon = ( pefo->xout >= pefo->thresh );
|
||
|
|
||
|
if ( pefo->bgateon )
|
||
|
{
|
||
|
// gate is on
|
||
|
|
||
|
if ( bgateon_prev && RMP_HitEnd( &pefo->rmp_attack ))
|
||
|
return x; // gate is fully on
|
||
|
|
||
|
if ( !bgateon_prev )
|
||
|
{
|
||
|
// gate just turned on, start ramp attack
|
||
|
|
||
|
// start attack from previous decay ramp if active
|
||
|
|
||
|
r = RMP_HitEnd( &pefo->rmp_decay ) ? 0 : RMP_GetNext( &pefo->rmp_decay );
|
||
|
RMP_SetEnd( &pefo->rmp_decay);
|
||
|
|
||
|
// DevMsg ("GATE ON \n");
|
||
|
|
||
|
RMP_Init( &pefo->rmp_attack, pefo->attack_time, r, PMAX, false);
|
||
|
|
||
|
return (x * r) >> PBITS;
|
||
|
}
|
||
|
|
||
|
if ( !RMP_HitEnd( &pefo->rmp_attack ) )
|
||
|
{
|
||
|
r = RMP_GetNext( &pefo->rmp_attack );
|
||
|
|
||
|
// gate is on and ramping up
|
||
|
|
||
|
return (x * r) >> PBITS;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// gate is fully off
|
||
|
|
||
|
if ( !bgateon_prev && RMP_HitEnd( &pefo->rmp_decay))
|
||
|
return 0;
|
||
|
|
||
|
if ( bgateon_prev )
|
||
|
{
|
||
|
// gate just turned off, start ramp decay
|
||
|
|
||
|
// start decay from previous attack ramp if active
|
||
|
|
||
|
r = RMP_HitEnd( &pefo->rmp_attack ) ? PMAX : RMP_GetNext( &pefo->rmp_attack );
|
||
|
RMP_SetEnd( &pefo->rmp_attack);
|
||
|
|
||
|
RMP_Init( &pefo->rmp_decay, pefo->decay_time, r, 0, false);
|
||
|
|
||
|
// DevMsg ("GATE OFF \n");
|
||
|
|
||
|
// if exponential set, gate has exponential ramp down. Otherwise linear ramp down.
|
||
|
|
||
|
if ( pefo->bexp )
|
||
|
return ( (((x * r) >> PBITS) * r ) >> PBITS );
|
||
|
else
|
||
|
return (x * r) >> PBITS;
|
||
|
|
||
|
}
|
||
|
else if ( !RMP_HitEnd( &pefo->rmp_decay ) )
|
||
|
{
|
||
|
// gate is off and ramping down
|
||
|
|
||
|
r = RMP_GetNext( &pefo->rmp_decay );
|
||
|
|
||
|
|
||
|
// if exponential set, gate has exponential ramp down. Otherwise linear ramp down.
|
||
|
|
||
|
if ( pefo->bexp )
|
||
|
return ( (((x * r) >> PBITS) * r ) >> PBITS );
|
||
|
else
|
||
|
return (x * r) >> PBITS;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return x;
|
||
|
}
|
||
|
|
||
|
return pefo->xout;
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void EFO_GetNextN( efo_t *pefo, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = EFO_GetNext( pefo, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = EFO_GetNext( pefo, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = EFO_GetNext( pefo, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
// parameter order
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
efo_ithreshold,
|
||
|
efo_iattack,
|
||
|
efo_idecay,
|
||
|
efo_iexp,
|
||
|
|
||
|
efo_cparam // # of params
|
||
|
|
||
|
} efo_e;
|
||
|
|
||
|
// parameter ranges
|
||
|
|
||
|
prm_rng_t efo_rng[] = {
|
||
|
|
||
|
{efo_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{efo_ithreshold, -140.0, 0.0}, // gate threshold in db. if 0.0 then no gate.
|
||
|
{efo_iattack, 0.0, 20000.0}, // attack time in milliseconds
|
||
|
{efo_idecay, 0.0, 20000.0}, // envelope decay time in milliseconds
|
||
|
{efo_iexp, 0.0, 1.0}, // if 1, use exponential decay ramp (for more realistic reverb tail)
|
||
|
|
||
|
};
|
||
|
|
||
|
efo_t * EFO_Params ( prc_t *pprc )
|
||
|
{
|
||
|
efo_t *penv;
|
||
|
|
||
|
float threshold = Gain_To_Amplitude( dB_To_Gain(pprc->prm[efo_ithreshold]) );
|
||
|
float attack = pprc->prm[efo_iattack]/1000.0;
|
||
|
float decay = pprc->prm[efo_idecay]/1000.0;
|
||
|
float fexp = pprc->prm[efo_iexp];
|
||
|
bool bexp;
|
||
|
|
||
|
// check for no gate
|
||
|
|
||
|
if ( pprc->prm[efo_ithreshold] == 0.0 )
|
||
|
threshold = 0.0;
|
||
|
|
||
|
bexp = fexp > 0.0 ? 1 : 0;
|
||
|
|
||
|
penv = EFO_Alloc ( threshold, attack, decay, bexp );
|
||
|
return penv;
|
||
|
}
|
||
|
|
||
|
inline void * EFO_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams( (prc_t *)p, efo_rng );
|
||
|
return (void *) EFO_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
inline void EFO_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////
|
||
|
// Chorus - lfo modulated delay
|
||
|
///////////////////////////////////////////
|
||
|
|
||
|
|
||
|
#define CCRSS 64 // max number chorus' active
|
||
|
|
||
|
struct crs_t
|
||
|
{
|
||
|
bool fused;
|
||
|
|
||
|
mdy_t *pmdy; // modulatable delay
|
||
|
lfo_t *plfo; // modulating lfo
|
||
|
|
||
|
int lfoprev; // previous modulator value from lfo
|
||
|
|
||
|
};
|
||
|
|
||
|
crs_t crss[CCRSS];
|
||
|
|
||
|
void CRS_Init( crs_t *pcrs ) { if (pcrs) Q_memset( pcrs, 0, sizeof (crs_t) ); };
|
||
|
void CRS_Free( crs_t *pcrs )
|
||
|
{
|
||
|
if (pcrs)
|
||
|
{
|
||
|
MDY_Free ( pcrs->pmdy );
|
||
|
LFO_Free ( pcrs->plfo );
|
||
|
Q_memset( pcrs, 0, sizeof (crs_t) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CRS_InitAll() { for (int i = 0; i < CCRSS; i++) CRS_Init( &crss[i] ); }
|
||
|
void CRS_FreeAll() { for (int i = 0; i < CCRSS; i++) CRS_Free( &crss[i] ); }
|
||
|
|
||
|
// fstep is base pitch shift, ie: floating point step value, where 1.0 = +1 octave, 0.5 = -1 octave
|
||
|
// lfotype is LFO_SIN, LFO_RND, LFO_TRI etc (LFO_RND for chorus, LFO_SIN for flange)
|
||
|
// fHz is modulation frequency in Hz
|
||
|
// depth is modulation depth, 0-1.0
|
||
|
// mix is mix of chorus and clean signal
|
||
|
|
||
|
#define CRS_DELAYMAX 100 // max milliseconds of sweepable delay
|
||
|
#define CRS_RAMPTIME 5 // milliseconds to ramp between new delay values
|
||
|
|
||
|
crs_t * CRS_Alloc( int lfotype, float fHz, float fdepth, float mix )
|
||
|
{
|
||
|
|
||
|
int i;
|
||
|
crs_t *pcrs;
|
||
|
dly_t *pdly;
|
||
|
mdy_t *pmdy;
|
||
|
lfo_t *plfo;
|
||
|
float ramptime;
|
||
|
int D;
|
||
|
|
||
|
// find free chorus slot
|
||
|
|
||
|
for ( i = 0; i < CCRSS; i++ )
|
||
|
{
|
||
|
if ( !crss[i].fused )
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if ( i == CCRSS )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate chorus.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pcrs = &crss[i];
|
||
|
|
||
|
CRS_Init ( pcrs );
|
||
|
|
||
|
D = fdepth * MSEC_TO_SAMPS(CRS_DELAYMAX); // sweep from 0 - n milliseconds
|
||
|
|
||
|
ramptime = (float) CRS_RAMPTIME / 1000.0; // # milliseconds to ramp between new values
|
||
|
|
||
|
pdly = DLY_Alloc ( D, 0, 1, DLY_LINEAR );
|
||
|
|
||
|
pmdy = MDY_Alloc ( pdly, ramptime, 0.0, 0.0, mix );
|
||
|
|
||
|
plfo = LFO_Alloc ( lfotype, fHz, false, 1.0 );
|
||
|
|
||
|
if ( !plfo || !pmdy )
|
||
|
{
|
||
|
LFO_Free ( plfo );
|
||
|
MDY_Free ( pmdy );
|
||
|
DevMsg ("DSP: Warning, failed to allocate lfo or mdy for chorus.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pcrs->pmdy = pmdy;
|
||
|
pcrs->plfo = plfo;
|
||
|
pcrs->fused = true;
|
||
|
|
||
|
return pcrs;
|
||
|
}
|
||
|
|
||
|
// return next chorused sample (modulated delay) mixed with input sample
|
||
|
|
||
|
inline int CRS_GetNext( crs_t *pcrs, int x )
|
||
|
{
|
||
|
int l;
|
||
|
int y;
|
||
|
|
||
|
// get current mod delay value
|
||
|
|
||
|
y = MDY_GetNext ( pcrs->pmdy, x );
|
||
|
|
||
|
// get next lfo value for modulation
|
||
|
// note: lfo must return 0 as first value
|
||
|
|
||
|
l = LFO_GetNext ( pcrs->plfo, x );
|
||
|
|
||
|
// if modulator has changed, change mdy
|
||
|
|
||
|
if ( l != pcrs->lfoprev )
|
||
|
{
|
||
|
// calculate new tap starts at D)
|
||
|
|
||
|
int D = pcrs->pmdy->pdly->D0;
|
||
|
int tap;
|
||
|
|
||
|
// lfo should always output values 0 <= l <= LFOMAX
|
||
|
|
||
|
if (l < 0)
|
||
|
l = 0;
|
||
|
|
||
|
tap = D - ((l * D) >> LFOBITS);
|
||
|
|
||
|
MDY_ChangeVal ( pcrs->pmdy, tap );
|
||
|
|
||
|
pcrs->lfoprev = l;
|
||
|
}
|
||
|
|
||
|
return y;
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void CRS_GetNextN( crs_t *pcrs, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = CRS_GetNext( pcrs, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = CRS_GetNext( pcrs, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = CRS_GetNext( pcrs, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
typedef enum {
|
||
|
|
||
|
crs_ilfotype,
|
||
|
crs_irate,
|
||
|
crs_idepth,
|
||
|
crs_imix,
|
||
|
|
||
|
crs_cparam
|
||
|
|
||
|
} crs_e;
|
||
|
|
||
|
|
||
|
// parameter ranges
|
||
|
|
||
|
prm_rng_t crs_rng[] = {
|
||
|
|
||
|
{crs_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{crs_ilfotype, 0, LFO_MAX}, // lfotype is LFO_SIN, LFO_RND, LFO_TRI etc (LFO_RND for chorus, LFO_SIN for flange)
|
||
|
{crs_irate, 0.0, 1000.0}, // rate is modulation frequency in Hz
|
||
|
{crs_idepth, 0.0, 1.0}, // depth is modulation depth, 0-1.0
|
||
|
{crs_imix, 0.0, 1.0}, // mix is mix of chorus and clean signal
|
||
|
|
||
|
};
|
||
|
|
||
|
// uses pitch, lfowav, rate, depth
|
||
|
|
||
|
crs_t * CRS_Params ( prc_t *pprc )
|
||
|
{
|
||
|
crs_t *pcrs;
|
||
|
|
||
|
pcrs = CRS_Alloc ( pprc->prm[crs_ilfotype], pprc->prm[crs_irate], pprc->prm[crs_idepth], pprc->prm[crs_imix] );
|
||
|
|
||
|
return pcrs;
|
||
|
}
|
||
|
|
||
|
inline void * CRS_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams ( (prc_t *)p, crs_rng );
|
||
|
return (void *) CRS_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
inline void CRS_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
|
||
|
////////////////////////////////////////////////////
|
||
|
// amplifier - modulatable gain, distortion
|
||
|
////////////////////////////////////////////////////
|
||
|
|
||
|
#define CAMPS 64 // max number amps active
|
||
|
|
||
|
#define AMPSLEW 10 // milliseconds of slew time between gain changes
|
||
|
|
||
|
struct amp_t
|
||
|
{
|
||
|
bool fused;
|
||
|
|
||
|
int gain; // amplification 0-6.0 * PMAX
|
||
|
int gain_max; // original gain setting
|
||
|
int distmix; // 0-1.0 mix of distortion with clean * PMAX
|
||
|
int vfeed; // 0-1.0 feedback with distortion * PMAX
|
||
|
int vthresh; // amplitude of clipping threshold 0..32768
|
||
|
|
||
|
|
||
|
bool fchanging; // true if modulating to new amp value
|
||
|
float ramptime; // ramp 'glide' time - time in seconds to change between values
|
||
|
int mtime; // time in samples between amp changes. 0 implies no self-modulating
|
||
|
int mtimecur; // current time in samples until next amp change
|
||
|
int depth; // modulate amp from A to A - (A*depth) depth 0-1.0
|
||
|
bool brand; // if true, use random modulation otherwise alternate btwn max/min
|
||
|
rmp_t rmp_interp; // interpolation ramp 0...PMAX
|
||
|
|
||
|
};
|
||
|
|
||
|
amp_t amps[CAMPS];
|
||
|
|
||
|
void AMP_Init( amp_t *pamp ) { if (pamp) Q_memset( pamp, 0, sizeof (amp_t) ); };
|
||
|
void AMP_Free( amp_t *pamp )
|
||
|
{
|
||
|
if (pamp)
|
||
|
{
|
||
|
Q_memset( pamp, 0, sizeof (amp_t) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void AMP_InitAll() { for (int i = 0; i < CAMPS; i++) AMP_Init( &s[i] ); }
|
||
|
void AMP_FreeAll() { for (int i = 0; i < CAMPS; i++) AMP_Free( &s[i] ); }
|
||
|
|
||
|
|
||
|
amp_t * AMP_Alloc( float gain, float vthresh, float distmix, float vfeed, float ramptime, float modtime, float depth, bool brand )
|
||
|
{
|
||
|
int i;
|
||
|
amp_t *pamp;
|
||
|
|
||
|
// find free amp slot
|
||
|
|
||
|
for ( i = 0; i < CAMPS; i++ )
|
||
|
{
|
||
|
if ( !amps[i].fused )
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if ( i == CAMPS )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, failed to allocate amp.\n" );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pamp = &s[i];
|
||
|
|
||
|
AMP_Init ( pamp );
|
||
|
|
||
|
pamp->fused = true;
|
||
|
|
||
|
pamp->gain = gain * PMAX;
|
||
|
pamp->gain_max = gain * PMAX;
|
||
|
pamp->distmix = distmix * PMAX;
|
||
|
pamp->vfeed = vfeed * PMAX;
|
||
|
pamp->vthresh = vthresh * 32767.0;
|
||
|
|
||
|
// modrate, 0.01, 200.0}, // frequency at which amplitude values change to new random value. 0 is no self-modulation
|
||
|
// moddepth, 0.0, 1.0}, // how much amplitude changes (decreases) from current value (0-1.0)
|
||
|
// modglide, 0.01, 100.0}, // glide time between mapcur and ampnew in milliseconds
|
||
|
|
||
|
pamp->ramptime = ramptime;
|
||
|
pamp->mtime = SEC_TO_SAMPS(modtime);
|
||
|
pamp->mtimecur = pamp->mtime;
|
||
|
pamp->depth = depth * PMAX;
|
||
|
pamp->brand = brand;
|
||
|
|
||
|
return pamp;
|
||
|
}
|
||
|
|
||
|
// return next amplified sample
|
||
|
|
||
|
inline int AMP_GetNext( amp_t *pamp, int x )
|
||
|
{
|
||
|
int y = x;
|
||
|
int d;
|
||
|
|
||
|
// if distortion is on, add distortion, feedback
|
||
|
|
||
|
if ( pamp->vthresh < PMAX && pamp->distmix )
|
||
|
{
|
||
|
int vthresh = pamp->vthresh;
|
||
|
|
||
|
/* if ( pamp->vfeed > 0.0 )
|
||
|
{
|
||
|
// UNDONE: feedback
|
||
|
}
|
||
|
*/
|
||
|
// clip distort
|
||
|
|
||
|
d = ( y > vthresh ? vthresh : ( y < -vthresh ? -vthresh : y));
|
||
|
|
||
|
// mix distorted with clean (1.0 = full distortion)
|
||
|
|
||
|
if ( pamp->distmix < PMAX )
|
||
|
y = y + (((d - y) * pamp->distmix ) >> PBITS);
|
||
|
else
|
||
|
y = d;
|
||
|
}
|
||
|
|
||
|
// get output for current gain value
|
||
|
|
||
|
int xout = (y * pamp->gain) >> PBITS;
|
||
|
|
||
|
if ( !pamp->fchanging && !pamp->mtime )
|
||
|
{
|
||
|
// if not modulating and not self modulating, return right away
|
||
|
|
||
|
return xout;
|
||
|
}
|
||
|
|
||
|
if (pamp->fchanging)
|
||
|
{
|
||
|
// modulating...
|
||
|
|
||
|
// get next gain value
|
||
|
|
||
|
pamp->gain = RMP_GetNext( &pamp->rmp_interp ); // 0...next gain
|
||
|
|
||
|
if ( RMP_HitEnd( &pamp->rmp_interp ) )
|
||
|
{
|
||
|
// done.
|
||
|
|
||
|
pamp->fchanging = false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// if self-modulating and timer has expired, get next change
|
||
|
|
||
|
if ( pamp->mtime && !pamp->mtimecur-- )
|
||
|
{
|
||
|
pamp->mtimecur = pamp->mtime;
|
||
|
|
||
|
int gain_new;
|
||
|
int G1;
|
||
|
int G2 = pamp->gain_max;
|
||
|
|
||
|
// modulate between 0 and 100% of gain_max
|
||
|
|
||
|
G1 = pamp->gain_max - ((pamp->gain_max * pamp->depth) >> PBITS);
|
||
|
|
||
|
if (pamp->brand)
|
||
|
{
|
||
|
gain_new = RandomInt( min(G1,G2), max(G1,G2) );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// alternate between min & max
|
||
|
|
||
|
gain_new = (pamp->gain == G1 ? G2 : G1);
|
||
|
}
|
||
|
|
||
|
// set up modulation to new value
|
||
|
|
||
|
pamp->fchanging = true;
|
||
|
|
||
|
// init gain ramp - always hit target
|
||
|
|
||
|
RMP_Init ( &pamp->rmp_interp, pamp->ramptime, pamp->gain, gain_new, false );
|
||
|
}
|
||
|
|
||
|
return xout;
|
||
|
|
||
|
}
|
||
|
|
||
|
// batch version for performance
|
||
|
|
||
|
inline void AMP_GetNextN( amp_t *pamp, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
int count = SampleCount;
|
||
|
portable_samplepair_t *pb = pbuffer;
|
||
|
|
||
|
switch (op)
|
||
|
{
|
||
|
default:
|
||
|
case OP_LEFT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = AMP_GetNext( pamp, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_RIGHT:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->right = AMP_GetNext( pamp, pb->right );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
case OP_LEFT_DUPLICATE:
|
||
|
while (count--)
|
||
|
{
|
||
|
pb->left = pb->right = AMP_GetNext( pamp, pb->left );
|
||
|
pb++;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
inline void AMP_Mod( amp_t *pamp, float v )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
// parameter order
|
||
|
|
||
|
typedef enum {
|
||
|
|
||
|
amp_gain,
|
||
|
amp_vthresh,
|
||
|
amp_distmix,
|
||
|
amp_vfeed,
|
||
|
amp_imodrate,
|
||
|
amp_imoddepth,
|
||
|
amp_imodglide,
|
||
|
amp_irand,
|
||
|
amp_cparam
|
||
|
|
||
|
} amp_e;
|
||
|
|
||
|
|
||
|
// parameter ranges
|
||
|
|
||
|
prm_rng_t amp_rng[] = {
|
||
|
|
||
|
{amp_cparam, 0, 0}, // first entry is # of parameters
|
||
|
|
||
|
{amp_gain, 0.0, 1000.0}, // amplification
|
||
|
{amp_vthresh, 0.0, 1.0}, // threshold for distortion (1.0 = no distortion)
|
||
|
{amp_distmix, 0.0, 1.0}, // mix of clean and distortion (1.0 = full distortion, 0.0 = full clean)
|
||
|
{amp_vfeed, 0.0, 1.0}, // distortion feedback
|
||
|
|
||
|
{amp_imodrate, 0.0, 200.0}, // frequency at which amplitude values change to new random value. 0 is no self-modulation
|
||
|
{amp_imoddepth, 0.0, 1.0}, // how much amplitude changes (decreases) from current value (0-1.0)
|
||
|
{amp_imodglide, 0.01, 100.0}, // glide time between mapcur and ampnew in milliseconds
|
||
|
{amp_irand, 0.0, 1.0}, // if 1, use random modulation otherwise alternate from max-min-max
|
||
|
};
|
||
|
|
||
|
amp_t * AMP_Params ( prc_t *pprc )
|
||
|
{
|
||
|
amp_t *pamp;
|
||
|
|
||
|
float ramptime = 0.0;
|
||
|
float modtime = 0.0;
|
||
|
float depth = 0.0;
|
||
|
float rand = pprc->prm[amp_irand];
|
||
|
bool brand;
|
||
|
|
||
|
if (pprc->prm[amp_imodrate] > 0.0)
|
||
|
{
|
||
|
ramptime = pprc->prm[amp_imodglide] / 1000.0; // get ramp time in seconds
|
||
|
modtime = 1.0 / max((double)pprc->prm[amp_imodrate], 0.01); // time between modulations in seconds
|
||
|
depth = pprc->prm[amp_imoddepth]; // depth of modulations 0-1.0
|
||
|
}
|
||
|
|
||
|
brand = rand > 0.0 ? 1 : 0;
|
||
|
|
||
|
pamp = AMP_Alloc ( pprc->prm[amp_gain], pprc->prm[amp_vthresh], pprc->prm[amp_distmix], pprc->prm[amp_vfeed],
|
||
|
ramptime, modtime, depth, brand );
|
||
|
|
||
|
return pamp;
|
||
|
}
|
||
|
|
||
|
inline void * AMP_VParams ( void *p )
|
||
|
{
|
||
|
PRC_CheckParams ( (prc_t *)p, amp_rng );
|
||
|
return (void *) AMP_Params ((prc_t *)p);
|
||
|
}
|
||
|
|
||
|
|
||
|
/////////////////
|
||
|
// NULL processor
|
||
|
/////////////////
|
||
|
|
||
|
struct nul_t
|
||
|
{
|
||
|
int type;
|
||
|
};
|
||
|
|
||
|
nul_t nuls[] = {{0}};
|
||
|
|
||
|
void NULL_Init ( nul_t *pnul ) { }
|
||
|
void NULL_InitAll( ) { }
|
||
|
void NULL_Free ( nul_t *pnul ) { }
|
||
|
void NULL_FreeAll ( ) { }
|
||
|
nul_t *NULL_Alloc ( ) { return &nuls[0]; }
|
||
|
|
||
|
inline int NULL_GetNext ( void *p, int x) { return x; }
|
||
|
|
||
|
inline void NULL_GetNextN( nul_t *pnul, portable_samplepair_t *pbuffer, int SampleCount, int op ) { return; }
|
||
|
|
||
|
inline void NULL_Mod ( void *p, float v ) { return; }
|
||
|
|
||
|
inline void * NULL_VParams ( void *p ) { return (void *) (&nuls[0]); }
|
||
|
|
||
|
//////////////////////////
|
||
|
// DSP processors presets - see dsp_presets.txt
|
||
|
//////////////////////////
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
// init array of processors - first store pfnParam, pfnGetNext and pfnFree functions for type,
|
||
|
// then call the pfnParam function to initialize each processor
|
||
|
|
||
|
// prcs - an array of prc structures, all with initialized params
|
||
|
// count - number of elements in the array
|
||
|
|
||
|
// returns false if failed to init one or more processors
|
||
|
|
||
|
bool PRC_InitAll( prc_t *prcs, int count )
|
||
|
{
|
||
|
int i;
|
||
|
prc_Param_t pfnParam; // allocation function - takes ptr to prc, returns ptr to specialized data struct for proc type
|
||
|
prc_GetNext_t pfnGetNext; // get next function
|
||
|
prc_GetNextN_t pfnGetNextN; // get next function, batch version
|
||
|
prc_Free_t pfnFree;
|
||
|
prc_Mod_t pfnMod;
|
||
|
|
||
|
bool fok = true;;
|
||
|
|
||
|
if ( count == 0 )
|
||
|
count = 1;
|
||
|
|
||
|
// set up pointers to XXX_Free, XXX_GetNext and XXX_Params functions
|
||
|
|
||
|
for (i = 0; i < count; i++)
|
||
|
{
|
||
|
switch (prcs[i].type)
|
||
|
{
|
||
|
default:
|
||
|
case PRC_NULL:
|
||
|
pfnFree = (prc_Free_t)NULL_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)NULL_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)NULL_GetNextN;
|
||
|
pfnParam = NULL_VParams;
|
||
|
pfnMod = (prc_Mod_t)NULL_Mod;
|
||
|
break;
|
||
|
case PRC_DLY:
|
||
|
pfnFree = (prc_Free_t)DLY_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)DLY_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)DLY_GetNextN;
|
||
|
pfnParam = DLY_VParams;
|
||
|
pfnMod = (prc_Mod_t)DLY_Mod;
|
||
|
break;
|
||
|
case PRC_RVA:
|
||
|
pfnFree = (prc_Free_t)RVA_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)RVA_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)RVA_GetNextN;
|
||
|
pfnParam = RVA_VParams;
|
||
|
pfnMod = (prc_Mod_t)RVA_Mod;
|
||
|
break;
|
||
|
case PRC_FLT:
|
||
|
pfnFree = (prc_Free_t)FLT_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)FLT_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)FLT_GetNextN;
|
||
|
pfnParam = FLT_VParams;
|
||
|
pfnMod = (prc_Mod_t)FLT_Mod;
|
||
|
break;
|
||
|
case PRC_CRS:
|
||
|
pfnFree = (prc_Free_t)CRS_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)CRS_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)CRS_GetNextN;
|
||
|
pfnParam = CRS_VParams;
|
||
|
pfnMod = (prc_Mod_t)CRS_Mod;
|
||
|
break;
|
||
|
case PRC_PTC:
|
||
|
pfnFree = (prc_Free_t)PTC_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)PTC_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)PTC_GetNextN;
|
||
|
pfnParam = PTC_VParams;
|
||
|
pfnMod = (prc_Mod_t)PTC_Mod;
|
||
|
break;
|
||
|
case PRC_ENV:
|
||
|
pfnFree = (prc_Free_t)ENV_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)ENV_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)ENV_GetNextN;
|
||
|
pfnParam = ENV_VParams;
|
||
|
pfnMod = (prc_Mod_t)ENV_Mod;
|
||
|
break;
|
||
|
case PRC_LFO:
|
||
|
pfnFree = (prc_Free_t)LFO_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)LFO_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)LFO_GetNextN;
|
||
|
pfnParam = LFO_VParams;
|
||
|
pfnMod = (prc_Mod_t)LFO_Mod;
|
||
|
break;
|
||
|
case PRC_EFO:
|
||
|
pfnFree = (prc_Free_t)EFO_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)EFO_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)EFO_GetNextN;
|
||
|
pfnParam = EFO_VParams;
|
||
|
pfnMod = (prc_Mod_t)EFO_Mod;
|
||
|
break;
|
||
|
case PRC_MDY:
|
||
|
pfnFree = (prc_Free_t)MDY_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)MDY_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)MDY_GetNextN;
|
||
|
pfnParam = MDY_VParams;
|
||
|
pfnMod = (prc_Mod_t)MDY_Mod;
|
||
|
break;
|
||
|
case PRC_DFR:
|
||
|
pfnFree = (prc_Free_t)DFR_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)DFR_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)DFR_GetNextN;
|
||
|
pfnParam = DFR_VParams;
|
||
|
pfnMod = (prc_Mod_t)DFR_Mod;
|
||
|
break;
|
||
|
case PRC_AMP:
|
||
|
pfnFree = (prc_Free_t)AMP_Free;
|
||
|
pfnGetNext = (prc_GetNext_t)AMP_GetNext;
|
||
|
pfnGetNextN = (prc_GetNextN_t)AMP_GetNextN;
|
||
|
pfnParam = AMP_VParams;
|
||
|
pfnMod = (prc_Mod_t)AMP_Mod;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// set up function pointers
|
||
|
|
||
|
prcs[i].pfnParam = pfnParam;
|
||
|
prcs[i].pfnGetNext = pfnGetNext;
|
||
|
prcs[i].pfnGetNextN = pfnGetNextN;
|
||
|
prcs[i].pfnFree = pfnFree;
|
||
|
prcs[i].pfnMod = pfnMod;
|
||
|
|
||
|
// call param function, store pdata for the processor type
|
||
|
|
||
|
prcs[i].pdata = pfnParam ( (void *) (&prcs[i]) );
|
||
|
|
||
|
if ( !prcs[i].pdata )
|
||
|
fok = false;
|
||
|
}
|
||
|
|
||
|
return fok;
|
||
|
}
|
||
|
|
||
|
// free individual processor's data
|
||
|
|
||
|
void PRC_Free ( prc_t *pprc )
|
||
|
{
|
||
|
if ( pprc->pfnFree && pprc->pdata )
|
||
|
pprc->pfnFree ( pprc->pdata );
|
||
|
}
|
||
|
|
||
|
// free all processors for supplied array
|
||
|
// prcs - array of processors
|
||
|
// count - elements in array
|
||
|
|
||
|
void PRC_FreeAll ( prc_t *prcs, int count )
|
||
|
{
|
||
|
for (int i = 0; i < count; i++)
|
||
|
PRC_Free( &prcs[i] );
|
||
|
}
|
||
|
|
||
|
// get next value for processor - (usually called directly by PSET_GetNext)
|
||
|
|
||
|
inline int PRC_GetNext ( prc_t *pprc, int x )
|
||
|
{
|
||
|
return pprc->pfnGetNext ( pprc->pdata, x );
|
||
|
}
|
||
|
|
||
|
// automatic parameter range limiting
|
||
|
// force parameters between specified min/max in param_rng
|
||
|
|
||
|
void PRC_CheckParams ( prc_t *pprc, prm_rng_t *prng )
|
||
|
{
|
||
|
// first entry in param_rng is # of parameters
|
||
|
|
||
|
int cprm = prng[0].iprm;
|
||
|
|
||
|
for (int i = 0; i < cprm; i++)
|
||
|
{
|
||
|
// if parameter is 0.0, always allow it (this is 'off' for most params)
|
||
|
|
||
|
if ( pprc->prm[i] != 0.0 && (pprc->prm[i] > prng[i+1].hi || pprc->prm[i] < prng[i+1].lo) )
|
||
|
{
|
||
|
DevMsg ("DSP: Warning, clamping out of range parameter.\n" );
|
||
|
pprc->prm[i] = clamp (pprc->prm[i], prng[i+1].lo, prng[i+1].hi);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// DSP presets
|
||
|
|
||
|
// A dsp preset comprises one or more dsp processors in linear, parallel or feedback configuration
|
||
|
|
||
|
// preset configurations
|
||
|
//
|
||
|
#define PSET_SIMPLE 0
|
||
|
|
||
|
// x(n)--->P(0)--->y(n)
|
||
|
|
||
|
#define PSET_LINEAR 1
|
||
|
|
||
|
// x(n)--->P(0)-->P(1)-->...P(m)--->y(n)
|
||
|
|
||
|
|
||
|
#define PSET_PARALLEL2 5
|
||
|
|
||
|
// x(n)--->P(0)-->(+)-->y(n)
|
||
|
// ^
|
||
|
// |
|
||
|
// x(n)--->P(1)-----
|
||
|
|
||
|
#define PSET_PARALLEL4 6
|
||
|
|
||
|
// x(n)--->P(0)-->P(1)-->(+)-->y(n)
|
||
|
// ^
|
||
|
// |
|
||
|
// x(n)--->P(2)-->P(3)-----
|
||
|
|
||
|
#define PSET_PARALLEL5 7
|
||
|
|
||
|
// x(n)--->P(0)-->P(1)-->(+)-->P(4)-->y(n)
|
||
|
// ^
|
||
|
// |
|
||
|
// x(n)--->P(2)-->P(3)-----
|
||
|
|
||
|
#define PSET_FEEDBACK 8
|
||
|
|
||
|
// x(n)-P(0)--(+)-->P(1)-->P(2)---->y(n)
|
||
|
// ^ |
|
||
|
// | v
|
||
|
// -----P(4)<--P(3)--
|
||
|
|
||
|
#define PSET_FEEDBACK3 9
|
||
|
|
||
|
// x(n)---(+)-->P(0)--------->y(n)
|
||
|
// ^ |
|
||
|
// | v
|
||
|
// -----P(2)<--P(1)--
|
||
|
|
||
|
#define PSET_FEEDBACK4 10
|
||
|
|
||
|
// x(n)---(+)-->P(0)-------->P(3)--->y(n)
|
||
|
// ^ |
|
||
|
// | v
|
||
|
// ---P(2)<--P(1)--
|
||
|
|
||
|
#define PSET_MOD 11
|
||
|
|
||
|
//
|
||
|
// x(n)------>P(1)--P(2)--P(3)--->y(n)
|
||
|
// ^
|
||
|
// x(n)------>P(0)....:
|
||
|
|
||
|
#define PSET_MOD2 12
|
||
|
|
||
|
//
|
||
|
// x(n)-------P(1)-->y(n)
|
||
|
// ^
|
||
|
// x(n)-->P(0)..:
|
||
|
|
||
|
|
||
|
#define PSET_MOD3 13
|
||
|
|
||
|
//
|
||
|
// x(n)-------P(1)-->P(2)-->y(n)
|
||
|
// ^
|
||
|
// x(n)-->P(0)..:
|
||
|
|
||
|
|
||
|
#define CPSETS 64 // max number of presets simultaneously active
|
||
|
|
||
|
#define CPSET_PRCS 5 // max # of processors per dsp preset
|
||
|
#define CPSET_STATES (CPSET_PRCS+3) // # of internal states
|
||
|
|
||
|
// NOTE: do not reorder members of pset_t - g_psettemplates relies on it!!!
|
||
|
|
||
|
struct pset_t
|
||
|
{
|
||
|
int type; // preset configuration type
|
||
|
int cprcs; // number of processors for this preset
|
||
|
|
||
|
prc_t prcs[CPSET_PRCS]; // processor preset data
|
||
|
|
||
|
float mix_min; // min dsp mix at close range
|
||
|
float mix_max; // max dsp mix at long range
|
||
|
float db_min; // if sndlvl of a new sound is < db_min, reduce mix_min/max by db_mixdrop
|
||
|
float db_mixdrop; // reduce mix_min/max by n% if sndlvl of new sound less than db_min
|
||
|
float duration; // if > 0, duration of preset in seconds (duration 0 = infinite)
|
||
|
float fade; // fade out time, exponential fade
|
||
|
|
||
|
int csamp_duration; // duration counter # samples
|
||
|
|
||
|
int w[CPSET_STATES]; // internal states
|
||
|
int fused;
|
||
|
};
|
||
|
|
||
|
pset_t psets[CPSETS];
|
||
|
|
||
|
pset_t *g_psettemplates = NULL;
|
||
|
int g_cpsettemplates = 0;
|
||
|
|
||
|
// returns true if preset will expire after duration
|
||
|
|
||
|
bool PSET_IsOneShot( pset_t *ppset )
|
||
|
{
|
||
|
return ppset->duration > 0.0;
|
||
|
}
|
||
|
|
||
|
// return true if preset is no longer active - duration has expired
|
||
|
|
||
|
bool PSET_HasExpired( pset_t *ppset )
|
||
|
{
|
||
|
if (!PSET_IsOneShot( ppset ))
|
||
|
return false;
|
||
|
|
||
|
return ppset->csamp_duration <= 0;
|
||
|
}
|
||
|
|
||
|
// if preset is oneshot, update duration counter by SampleCount samples
|
||
|
|
||
|
void PSET_UpdateDuration( pset_t *ppset, int SampleCount )
|
||
|
{
|
||
|
if ( PSET_IsOneShot( ppset ) )
|
||
|
{
|
||
|
// if oneshot preset and not expired, decrement sample count
|
||
|
|
||
|
if (ppset->csamp_duration > 0)
|
||
|
ppset->csamp_duration -= SampleCount;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// A dsp processor (prc) performs a single-sample function, such as pitch shift, delay, reverb, filter
|
||
|
|
||
|
|
||
|
// init a preset - just clear state array
|
||
|
|
||
|
void PSET_Init( pset_t *ppset )
|
||
|
{
|
||
|
// clear state array
|
||
|
|
||
|
if (ppset)
|
||
|
Q_memset( ppset->w, 0, sizeof (int) * (CPSET_STATES) );
|
||
|
}
|
||
|
|
||
|
// clear runtime slots
|
||
|
|
||
|
void PSET_InitAll( void )
|
||
|
{
|
||
|
for (int i = 0; i < CPSETS; i++)
|
||
|
Q_memset( &psets[i], 0, sizeof(pset_t));
|
||
|
}
|
||
|
|
||
|
// free the preset - free all processors
|
||
|
|
||
|
void PSET_Free( pset_t *ppset )
|
||
|
{
|
||
|
if (ppset)
|
||
|
{
|
||
|
// free processors
|
||
|
|
||
|
PRC_FreeAll ( ppset->prcs, ppset->cprcs );
|
||
|
|
||
|
// clear
|
||
|
|
||
|
Q_memset( ppset, 0, sizeof (pset_t));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void PSET_FreeAll() { for (int i = 0; i < CPSETS; i++) PSET_Free( &psets[i] ); };
|
||
|
|
||
|
// return preset struct, given index into preset template array
|
||
|
// NOTE: should not ever be more than 2 or 3 of these active simultaneously
|
||
|
|
||
|
pset_t * PSET_Alloc ( int ipsettemplate )
|
||
|
{
|
||
|
pset_t *ppset;
|
||
|
bool fok;
|
||
|
|
||
|
// don't excede array bounds
|
||
|
|
||
|
if ( ipsettemplate >= g_cpsettemplates)
|
||
|
ipsettemplate = 0;
|
||
|
|
||
|
// find free slot
|
||
|
int i = 0;
|
||
|
for (i = 0; i < CPSETS; i++)
|
||
|
{
|
||
|
if ( !psets[i].fused )
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if ( i == CPSETS )
|
||
|
return NULL;
|
||
|
|
||
|
if (das_debug.GetInt())
|
||
|
{
|
||
|
int nSlots = 0;
|
||
|
for ( int j = 0; j < CPSETS; j++)
|
||
|
{
|
||
|
if ( psets[j].fused )
|
||
|
nSlots++;
|
||
|
}
|
||
|
DevMsg("total preset slots used: %d \n", nSlots );
|
||
|
}
|
||
|
|
||
|
|
||
|
ppset = &psets[i];
|
||
|
|
||
|
// clear preset
|
||
|
|
||
|
Q_memset(ppset, 0, sizeof(pset_t));
|
||
|
|
||
|
// copy template into preset
|
||
|
|
||
|
*ppset = g_psettemplates[ipsettemplate];
|
||
|
|
||
|
ppset->fused = true;
|
||
|
|
||
|
// clear state array
|
||
|
|
||
|
PSET_Init ( ppset );
|
||
|
|
||
|
// init all processors, set up processor function pointers
|
||
|
|
||
|
fok = PRC_InitAll( ppset->prcs, ppset->cprcs );
|
||
|
|
||
|
if ( !fok )
|
||
|
{
|
||
|
// failed to init one or more processors
|
||
|
Warning( "Sound DSP: preset failed to init.\n");
|
||
|
PRC_FreeAll ( ppset->prcs, ppset->cprcs );
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
// if preset has duration, setup duration sample counter
|
||
|
|
||
|
if ( PSET_IsOneShot( ppset ) )
|
||
|
{
|
||
|
ppset->csamp_duration = SEC_TO_SAMPS( ppset->duration );
|
||
|
}
|
||
|
|
||
|
return ppset;
|
||
|
}
|
||
|
|
||
|
// batch version of PSET_GetNext for linear array of processors. For performance.
|
||
|
|
||
|
// ppset - preset array
|
||
|
// pbuffer - input sample data
|
||
|
// SampleCount - size of input buffer
|
||
|
// OP: OP_LEFT - process left channel in place
|
||
|
// OP_RIGHT - process right channel in place
|
||
|
// OP_LEFT_DUPLICATe - process left channel, duplicate into right
|
||
|
|
||
|
inline void PSET_GetNextN( pset_t *ppset, portable_samplepair_t *pbuffer, int SampleCount, int op )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbuffer;
|
||
|
prc_t *pprc;
|
||
|
int count = ppset->cprcs;
|
||
|
|
||
|
switch ( ppset->type )
|
||
|
{
|
||
|
default:
|
||
|
case PSET_SIMPLE:
|
||
|
{
|
||
|
// x(n)--->P(0)--->y(n)
|
||
|
|
||
|
ppset->prcs[0].pfnGetNextN (ppset->prcs[0].pdata, pbf, SampleCount, op);
|
||
|
return;
|
||
|
}
|
||
|
case PSET_LINEAR:
|
||
|
{
|
||
|
|
||
|
// w0 w1 w2
|
||
|
// x(n)--->P(0)-->P(1)-->...P(count-1)--->y(n)
|
||
|
|
||
|
// w0 w1 w2 w3 w4 w5
|
||
|
// x(n)--->P(0)-->P(1)-->P(2)-->P(3)-->P(4)-->y(n)
|
||
|
|
||
|
// call batch processors in sequence - no internal state for batch processing
|
||
|
|
||
|
// point to first processor
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
for (int i = 0; i < count; i++)
|
||
|
{
|
||
|
pprc->pfnGetNextN (pprc->pdata, pbf, SampleCount, op);
|
||
|
pprc++;
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// Get next sample from this preset. called once for every sample in buffer
|
||
|
// ppset is pointer to preset
|
||
|
// x is input sample
|
||
|
|
||
|
inline int PSET_GetNext ( pset_t *ppset, int x )
|
||
|
{
|
||
|
|
||
|
// pset_simple and pset_linear have no internal state:
|
||
|
// this is REQUIRED for all presets that have a batch getnextN equivalent!
|
||
|
|
||
|
if ( ppset->type == PSET_SIMPLE )
|
||
|
{
|
||
|
// x(n)--->P(0)--->y(n)
|
||
|
|
||
|
return ppset->prcs[0].pfnGetNext (ppset->prcs[0].pdata, x);
|
||
|
}
|
||
|
|
||
|
prc_t *pprc;
|
||
|
int count = ppset->cprcs;
|
||
|
|
||
|
if ( ppset->type == PSET_LINEAR )
|
||
|
{
|
||
|
int y = x;
|
||
|
|
||
|
// w0 w1 w2
|
||
|
// x(n)--->P(0)-->P(1)-->...P(count-1)--->y(n)
|
||
|
|
||
|
// w0 w1 w2 w3 w4 w5
|
||
|
// x(n)--->P(0)-->P(1)-->P(2)-->P(3)-->P(4)-->y(n)
|
||
|
|
||
|
// call processors in reverse order, from count to 1
|
||
|
|
||
|
//for (int i = count; i > 0; i--, pprc--)
|
||
|
// w[i] = pprc->pfnGetNext (pprc->pdata, w[i-1]);
|
||
|
|
||
|
// return w[count];
|
||
|
|
||
|
|
||
|
// point to first processor, update sequentially, no state preserved
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
switch (count)
|
||
|
{
|
||
|
default:
|
||
|
case 5:
|
||
|
y = pprc->pfnGetNext (pprc->pdata, y);
|
||
|
pprc++;
|
||
|
case 4:
|
||
|
y = pprc->pfnGetNext (pprc->pdata, y);
|
||
|
pprc++;
|
||
|
case 3:
|
||
|
y = pprc->pfnGetNext (pprc->pdata, y);
|
||
|
pprc++;
|
||
|
case 2:
|
||
|
y = pprc->pfnGetNext (pprc->pdata, y);
|
||
|
pprc++;
|
||
|
case 1:
|
||
|
case 0:
|
||
|
y = pprc->pfnGetNext (pprc->pdata, y);
|
||
|
}
|
||
|
|
||
|
return y;
|
||
|
}
|
||
|
|
||
|
// all other preset types have internal state:
|
||
|
|
||
|
// initialize 0'th element of state array
|
||
|
|
||
|
int *w = ppset->w;
|
||
|
w[0] = x;
|
||
|
|
||
|
switch ( ppset->type )
|
||
|
{
|
||
|
default:
|
||
|
|
||
|
case PSET_PARALLEL2:
|
||
|
{ // w0 w1 w3
|
||
|
// x(n)--->P(0)-->(+)-->y(n)
|
||
|
// ^
|
||
|
// w0 w2 |
|
||
|
// x(n)--->P(1)-----
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
w[3] = w[1] + w[2];
|
||
|
|
||
|
w[1] = pprc->pfnGetNext( pprc->pdata, w[0] );
|
||
|
pprc++;
|
||
|
w[2] = pprc->pfnGetNext( pprc->pdata, w[0] );
|
||
|
|
||
|
return w[3];
|
||
|
}
|
||
|
|
||
|
case PSET_PARALLEL4:
|
||
|
{ // w0 w1 w2 w5
|
||
|
// x(n)--->P(0)-->P(1)-->(+)-->y(n)
|
||
|
// ^
|
||
|
// w0 w3 w4 |
|
||
|
// x(n)--->P(2)-->P(3)-----
|
||
|
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
w[5] = w[2] + w[4];
|
||
|
|
||
|
w[2] = pprc[1].pfnGetNext( pprc[1].pdata, w[1] );
|
||
|
w[4] = pprc[3].pfnGetNext( pprc[3].pdata, w[3] );
|
||
|
|
||
|
w[1] = pprc[0].pfnGetNext( pprc[0].pdata, w[0] );
|
||
|
w[3] = pprc[2].pfnGetNext( pprc[2].pdata, w[0] );
|
||
|
|
||
|
return w[5];
|
||
|
}
|
||
|
|
||
|
case PSET_PARALLEL5:
|
||
|
{ // w0 w1 w2 w5 w6
|
||
|
// x(n)--->P(0)-->P(1)-->(+)--P(4)-->y(n)
|
||
|
// ^
|
||
|
// w0 w3 w4 |
|
||
|
// x(n)--->P(2)-->P(3)-----
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
w[5] = w[2] + w[4];
|
||
|
|
||
|
w[2] = pprc[1].pfnGetNext( pprc[1].pdata, w[1] );
|
||
|
w[4] = pprc[3].pfnGetNext( pprc[3].pdata, w[3] );
|
||
|
|
||
|
w[1] = pprc[0].pfnGetNext( pprc[0].pdata, w[0] );
|
||
|
w[3] = pprc[2].pfnGetNext( pprc[2].pdata, w[0] );
|
||
|
|
||
|
return pprc[4].pfnGetNext( pprc[4].pdata, w[5] );
|
||
|
}
|
||
|
|
||
|
case PSET_FEEDBACK:
|
||
|
{
|
||
|
// w0 w1 w2 w3 w4 w7
|
||
|
// x(n)-P(0)--(+)-->P(1)-->P(2)-->---->y(n)
|
||
|
// ^ |
|
||
|
// | w6 w5 v
|
||
|
// -----P(4)<--P(3)--
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
// start with adders
|
||
|
|
||
|
w[2] = w[1] + w[6];
|
||
|
|
||
|
// evaluate in reverse order
|
||
|
|
||
|
w[6] = pprc[4].pfnGetNext( pprc[4].pdata, w[5] );
|
||
|
w[5] = pprc[3].pfnGetNext( pprc[3].pdata, w[4] );
|
||
|
|
||
|
w[4] = pprc[2].pfnGetNext( pprc[2].pdata, w[3] );
|
||
|
w[3] = pprc[1].pfnGetNext( pprc[1].pdata, w[2] );
|
||
|
w[1] = pprc[0].pfnGetNext( pprc[0].pdata, w[0] );
|
||
|
|
||
|
return w[4];
|
||
|
}
|
||
|
case PSET_FEEDBACK3:
|
||
|
{
|
||
|
// w0 w1 w2
|
||
|
// x(n)---(+)-->P(0)--------->y(n)
|
||
|
// ^ |
|
||
|
// | w4 w3 v
|
||
|
// -----P(2)<--P(1)--
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
// start with adders
|
||
|
|
||
|
w[1] = w[0] + w[4];
|
||
|
|
||
|
// evaluate in reverse order
|
||
|
|
||
|
w[4] = pprc[2].pfnGetNext( pprc[2].pdata, w[3] );
|
||
|
w[3] = pprc[1].pfnGetNext( pprc[1].pdata, w[2] );
|
||
|
w[2] = pprc[0].pfnGetNext( pprc[0].pdata, w[1] );
|
||
|
|
||
|
return w[2];
|
||
|
}
|
||
|
case PSET_FEEDBACK4:
|
||
|
{
|
||
|
// w0 w1 w2 w5
|
||
|
// x(n)---(+)-->P(0)-------->P(3)--->y(n)
|
||
|
// ^ |
|
||
|
// | w4 w3 v
|
||
|
// ---P(2)<--P(1)--
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
// start with adders
|
||
|
|
||
|
w[1] = w[0] + w[4];
|
||
|
|
||
|
// evaluate in reverse order
|
||
|
|
||
|
w[5] = pprc[3].pfnGetNext( pprc[3].pdata, w[2] );
|
||
|
w[4] = pprc[2].pfnGetNext( pprc[2].pdata, w[3] );
|
||
|
w[3] = pprc[1].pfnGetNext( pprc[1].pdata, w[2] );
|
||
|
w[2] = pprc[0].pfnGetNext( pprc[0].pdata, w[1] );
|
||
|
|
||
|
return w[2];
|
||
|
}
|
||
|
case PSET_MOD:
|
||
|
{
|
||
|
// w0 w1 w3 w4
|
||
|
// x(n)------>P(1)--P(2)--P(3)--->y(n)
|
||
|
// w0 w2 ^
|
||
|
// x(n)------>P(0)....:
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
w[4] = pprc[3].pfnGetNext( pprc[3].pdata, w[3] );
|
||
|
|
||
|
w[3] = pprc[2].pfnGetNext( pprc[2].pdata, w[1] );
|
||
|
|
||
|
// modulate processor 2
|
||
|
|
||
|
pprc[2].pfnMod( pprc[2].pdata, ((float)w[2] / (float)PMAX));
|
||
|
|
||
|
// get modulator output
|
||
|
|
||
|
w[2] = pprc[0].pfnGetNext( pprc[0].pdata, w[0] );
|
||
|
|
||
|
w[1] = pprc[1].pfnGetNext( pprc[1].pdata, w[0] );
|
||
|
|
||
|
return w[4];
|
||
|
}
|
||
|
case PSET_MOD2:
|
||
|
{
|
||
|
// w0 w2
|
||
|
// x(n)---------P(1)-->y(n)
|
||
|
// w0 w1 ^
|
||
|
// x(n)-->P(0)....:
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
// modulate processor 1
|
||
|
|
||
|
pprc[1].pfnMod( pprc[1].pdata, ((float)w[1] / (float)PMAX));
|
||
|
|
||
|
// get modulator output
|
||
|
|
||
|
w[1] = pprc[0].pfnGetNext( pprc[0].pdata, w[0] );
|
||
|
|
||
|
w[2] = pprc[1].pfnGetNext( pprc[1].pdata, w[0] );
|
||
|
|
||
|
return w[2];
|
||
|
|
||
|
}
|
||
|
case PSET_MOD3:
|
||
|
{
|
||
|
// w0 w2 w3
|
||
|
// x(n)----------P(1)-->P(2)-->y(n)
|
||
|
// w0 w1 ^
|
||
|
// x(n)-->P(0).....:
|
||
|
|
||
|
pprc = &ppset->prcs[0];
|
||
|
|
||
|
w[3] = pprc[2].pfnGetNext( pprc[2].pdata, w[2] );
|
||
|
|
||
|
// modulate processor 1
|
||
|
|
||
|
pprc[1].pfnMod( pprc[1].pdata, ((float)w[1] / (float)PMAX));
|
||
|
|
||
|
// get modulator output
|
||
|
|
||
|
w[1] = pprc[0].pfnGetNext( pprc[0].pdata, w[0] );
|
||
|
|
||
|
w[2] = pprc[1].pfnGetNext( pprc[1].pdata, w[0] );
|
||
|
|
||
|
return w[2];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
/////////////
|
||
|
// DSP system
|
||
|
/////////////
|
||
|
|
||
|
// Main interface
|
||
|
|
||
|
// Whenever the preset # changes on any of these processors, the old processor is faded out, new is faded in.
|
||
|
// dsp_chan is optionally set when a sound is played - a preset is sent with the start_static/dynamic sound.
|
||
|
//
|
||
|
// sound1---->dsp_chan--> -------------(+)---->dsp_water--->dsp_player--->out
|
||
|
// sound2---->dsp_chan--> | |
|
||
|
// sound3---------------> ----dsp_room---
|
||
|
// | |
|
||
|
// --dsp_indirect-
|
||
|
|
||
|
// dsp_room - set this cvar to a preset # to change the room dsp. room fx are more prevalent farther from player.
|
||
|
// use: when player moves into a new room, all sounds played in room take on its reverberant character
|
||
|
// dsp_water - set this cvar (once) to a preset # for serial underwater sound.
|
||
|
// use: when player goes under water, all sounds pass through this dsp (such as low pass filter)
|
||
|
// dsp_player - set this cvar to a preset # to cause all sounds to run through the effect (serial, in-line).
|
||
|
// use: player is deafened, player fires special weapon, player is hit by special weapon.
|
||
|
// dsp_facingaway- set this cvar to a preset # appropriate for sounds which are played facing away from player (weapon,voice)
|
||
|
//
|
||
|
// dsp_spatial - set by system to create modulated spatial delays for left/right/front/back ears - delay value
|
||
|
// modulates by distance to nearest l/r surface in world
|
||
|
|
||
|
// Dsp presets
|
||
|
|
||
|
|
||
|
ConVar dsp_room ("dsp_room", "0", FCVAR_DEMO ); // room dsp preset - sounds more distant from player (1ch)
|
||
|
ConVar dsp_water ("dsp_water", "14", FCVAR_DEMO ); // "14" underwater dsp preset - sound when underwater (1-2ch)
|
||
|
ConVar dsp_player ("dsp_player", "0", FCVAR_DEMO | FCVAR_SERVER_CAN_EXECUTE ); // dsp on player - sound when player hit by special device (1-2ch)
|
||
|
ConVar dsp_facingaway ("dsp_facingaway", "0", FCVAR_DEMO ); // "30" sounds that face away from player (weapons, voice) (1-4ch)
|
||
|
ConVar dsp_speaker ("dsp_speaker", "50", FCVAR_DEMO ); // "50" small distorted speaker sound (1ch)
|
||
|
ConVar dsp_spatial ("dsp_spatial", "40", FCVAR_DEMO ); // spatial delays for l/r front/rear ears
|
||
|
ConVar dsp_automatic ("dsp_automatic", "0", FCVAR_DEMO ); // automatic room type detection. if non zero, replaces dsp_room
|
||
|
|
||
|
int ipset_room_prev;
|
||
|
int ipset_water_prev;
|
||
|
int ipset_player_prev;
|
||
|
int ipset_facingaway_prev;
|
||
|
int ipset_speaker_prev;
|
||
|
int ipset_spatial_prev;
|
||
|
int ipset_automatic_prev;
|
||
|
|
||
|
// legacy room_type support
|
||
|
|
||
|
ConVar dsp_room_type ( "room_type", "0", FCVAR_DEMO );
|
||
|
int ipset_room_typeprev;
|
||
|
|
||
|
|
||
|
// DSP processors
|
||
|
|
||
|
int idsp_room;
|
||
|
int idsp_water;
|
||
|
int idsp_player;
|
||
|
int idsp_facingaway;
|
||
|
int idsp_speaker;
|
||
|
int idsp_spatial;
|
||
|
int idsp_automatic;
|
||
|
|
||
|
ConVar dsp_off ("dsp_off", "0", FCVAR_CHEAT | FCVAR_ALLOWED_IN_COMPETITIVE ); // set to 1 to disable all dsp processing
|
||
|
ConVar dsp_slow_cpu ("dsp_slow_cpu", "0", FCVAR_ARCHIVE|FCVAR_DEMO ); // set to 1 if cpu bound - ie: does not process dsp_room fx
|
||
|
ConVar snd_profile ("snd_profile", "0", FCVAR_DEMO ); // 1 - profile dsp, 2 - mix, 3 - load sound, 4 - all sound
|
||
|
ConVar dsp_volume ("dsp_volume", "1.0", FCVAR_ARCHIVE|FCVAR_DEMO ); // 0.0 - 2.0; master dsp volume control
|
||
|
ConVar dsp_vol_5ch ("dsp_vol_5ch", "0.5", FCVAR_DEMO ); // 0.0 - 1.0; attenuate master dsp volume for 5ch surround
|
||
|
ConVar dsp_vol_4ch ("dsp_vol_4ch", "0.5", FCVAR_DEMO ); // 0.0 - 1.0; attenuate master dsp volume for 4ch surround
|
||
|
ConVar dsp_vol_2ch ("dsp_vol_2ch", "1.0", FCVAR_DEMO ); // 0.0 - 1.0; attenuate master dsp volume for 2ch surround
|
||
|
|
||
|
ConVar dsp_enhance_stereo("dsp_enhance_stereo", "0", FCVAR_ARCHIVE ); // 1) use dsp_spatial delays on all reverb channels
|
||
|
|
||
|
// DSP preset executor
|
||
|
|
||
|
#define CDSPS 32 // max number dsp executors active
|
||
|
#define DSPCHANMAX 5 // max number of channels dsp can process (allocs a separte processor for each chan)
|
||
|
|
||
|
struct dsp_t
|
||
|
{
|
||
|
bool fused;
|
||
|
int cchan; // 1-5 channels, ie: mono, FrontLeft, FrontRight, RearLeft, RearRight, FrontCenter
|
||
|
|
||
|
pset_t *ppset[DSPCHANMAX]; // current preset (1-5 channels)
|
||
|
int ipset; // current ipreset
|
||
|
|
||
|
pset_t *ppsetprev[DSPCHANMAX]; // previous preset (1-5 channels)
|
||
|
int ipsetprev; // previous ipreset
|
||
|
|
||
|
float xfade; // crossfade time between previous preset and new
|
||
|
float xfade_default; // default xfade value, set in DSP_Alloc
|
||
|
bool bexpfade; // true if exponential crossfade
|
||
|
|
||
|
int ipsetsav_oneshot; // previous preset before one-shot preset was set
|
||
|
|
||
|
rmp_t xramp; // crossfade ramp
|
||
|
};
|
||
|
|
||
|
dsp_t dsps[CDSPS];
|
||
|
|
||
|
void DSP_Init( int idsp )
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
|
||
|
Assert( idsp < CDSPS );
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return;
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
Q_memset( pdsp, 0, sizeof (dsp_t) );
|
||
|
}
|
||
|
|
||
|
void DSP_Free( int idsp )
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
|
||
|
Assert( idsp < CDSPS );
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return;
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
for (int i = 0; i < pdsp->cchan; i++)
|
||
|
{
|
||
|
if ( pdsp->ppset[i] )
|
||
|
PSET_Free( pdsp->ppset[i] );
|
||
|
|
||
|
if ( pdsp->ppsetprev[i] )
|
||
|
PSET_Free( pdsp->ppsetprev[i] );
|
||
|
}
|
||
|
|
||
|
Q_memset( pdsp, 0, sizeof (dsp_t) );
|
||
|
}
|
||
|
|
||
|
// Init all dsp processors - called once, during engine startup
|
||
|
|
||
|
void DSP_InitAll ( bool bLoadPresetFile )
|
||
|
{
|
||
|
// only load template file on engine startup
|
||
|
|
||
|
if ( bLoadPresetFile )
|
||
|
DSP_LoadPresetFile();
|
||
|
|
||
|
// order is important, don't rearange.
|
||
|
|
||
|
FLT_InitAll();
|
||
|
DLY_InitAll();
|
||
|
RVA_InitAll();
|
||
|
LFOWAV_InitAll();
|
||
|
LFO_InitAll();
|
||
|
|
||
|
CRS_InitAll();
|
||
|
PTC_InitAll();
|
||
|
ENV_InitAll();
|
||
|
EFO_InitAll();
|
||
|
MDY_InitAll();
|
||
|
AMP_InitAll();
|
||
|
|
||
|
PSET_InitAll();
|
||
|
|
||
|
for (int idsp = 0; idsp < CDSPS; idsp++)
|
||
|
DSP_Init( idsp );
|
||
|
}
|
||
|
|
||
|
// free all resources associated with dsp - called once, during engine shutdown
|
||
|
|
||
|
void DSP_FreeAll (void)
|
||
|
{
|
||
|
// order is important, don't rearange.
|
||
|
|
||
|
for (int idsp = 0; idsp < CDSPS; idsp++)
|
||
|
DSP_Free( idsp );
|
||
|
|
||
|
AMP_FreeAll();
|
||
|
MDY_FreeAll();
|
||
|
EFO_FreeAll();
|
||
|
ENV_FreeAll();
|
||
|
PTC_FreeAll();
|
||
|
CRS_FreeAll();
|
||
|
|
||
|
LFO_FreeAll();
|
||
|
LFOWAV_FreeAll();
|
||
|
RVA_FreeAll();
|
||
|
DLY_FreeAll();
|
||
|
FLT_FreeAll();
|
||
|
}
|
||
|
|
||
|
|
||
|
// allocate a new dsp processor chain, kill the old processor. Called during dsp init only.
|
||
|
// ipset is new preset
|
||
|
// xfade is crossfade time when switching between presets (milliseconds)
|
||
|
// cchan is how many simultaneous preset channels to allocate (1-4)
|
||
|
// return index to new dsp
|
||
|
|
||
|
int DSP_Alloc( int ipset, float xfade, int cchan )
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
int i;
|
||
|
int idsp;
|
||
|
int cchans = clamp( cchan, 1, DSPCHANMAX);
|
||
|
|
||
|
// find free slot
|
||
|
|
||
|
for ( idsp = 0; idsp < CDSPS; idsp++ )
|
||
|
{
|
||
|
if ( !dsps[idsp].fused )
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if ( idsp >= CDSPS )
|
||
|
return -1;
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
DSP_Init ( idsp );
|
||
|
|
||
|
pdsp->fused = true;
|
||
|
|
||
|
pdsp->cchan = cchans;
|
||
|
|
||
|
// allocate a preset processor for each channel
|
||
|
|
||
|
pdsp->ipset = ipset;
|
||
|
pdsp->ipsetprev = 0;
|
||
|
pdsp->ipsetsav_oneshot = 0;
|
||
|
|
||
|
for (i = 0; i < pdsp->cchan; i++)
|
||
|
{
|
||
|
pdsp->ppset[i] = PSET_Alloc ( ipset );
|
||
|
pdsp->ppsetprev[i] = NULL;
|
||
|
}
|
||
|
|
||
|
// set up crossfade time in seconds
|
||
|
|
||
|
pdsp->xfade = xfade / 1000.0;
|
||
|
pdsp->xfade_default = pdsp->xfade;
|
||
|
|
||
|
RMP_SetEnd(&pdsp->xramp);
|
||
|
|
||
|
return idsp;
|
||
|
}
|
||
|
|
||
|
// call modulation function of specified processor within dsp preset
|
||
|
|
||
|
// idsp - dsp preset
|
||
|
// channel - channel 1-5 (l,r,rl,rr,fc)
|
||
|
// iproc - which processor to change (normally 0)
|
||
|
// value - new parameter value for processor
|
||
|
|
||
|
// NOTE: routine returns with no result or error if any parameter is invalid.
|
||
|
|
||
|
void DSP_ChangePresetValue( int idsp, int channel, int iproc, float value )
|
||
|
{
|
||
|
|
||
|
dsp_t *pdsp;
|
||
|
pset_t *ppset; // preset
|
||
|
prc_Mod_t pfnMod; // modulation function
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return;
|
||
|
|
||
|
if (channel >= DSPCHANMAX)
|
||
|
return;
|
||
|
|
||
|
if (iproc >= CPSET_PRCS)
|
||
|
return;
|
||
|
|
||
|
// get ptr to processor preset
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
// assert that this dsp processor has enough separate channels
|
||
|
|
||
|
Assert(channel <= pdsp->cchan);
|
||
|
|
||
|
ppset = pdsp->ppset[channel];
|
||
|
|
||
|
if (!ppset)
|
||
|
return;
|
||
|
|
||
|
// get ptr to modulation function
|
||
|
|
||
|
pfnMod = ppset->prcs[iproc].pfnMod;
|
||
|
|
||
|
if (!pfnMod)
|
||
|
return;
|
||
|
|
||
|
// call modulation function with new value
|
||
|
|
||
|
pfnMod (ppset->prcs[iproc].pdata, value);
|
||
|
}
|
||
|
|
||
|
|
||
|
#define DSP_AUTOMATIC 1 // corresponds to Generic preset
|
||
|
|
||
|
// if dsp_room == DSP_AUTOMATIC, then use dsp_automatic value for dsp
|
||
|
// any subsequent reset of dsp_room will disable automatic room detection.
|
||
|
|
||
|
// return true if automatic room detection is enabled
|
||
|
|
||
|
bool DSP_CheckDspAutoEnabled( void )
|
||
|
{
|
||
|
return (dsp_room.GetInt() == DSP_AUTOMATIC);
|
||
|
}
|
||
|
|
||
|
// set dsp_automatic preset, used in place of dsp_room when automatic room detection enabled
|
||
|
|
||
|
void DSP_SetDspAuto( int dsp_preset )
|
||
|
{
|
||
|
// set dsp_preset into dsp_automatic
|
||
|
|
||
|
dsp_automatic.SetValue( dsp_preset );
|
||
|
}
|
||
|
|
||
|
// wrapper on dsp_room GetInt so that dsp_automatic can override
|
||
|
|
||
|
int dsp_room_GetInt ( void )
|
||
|
{
|
||
|
// if dsp_automatic is not enabled, get room
|
||
|
|
||
|
if (! DSP_CheckDspAutoEnabled())
|
||
|
return dsp_room.GetInt();
|
||
|
|
||
|
// automatic room detection is on, get dsp_automatic instead of dsp_room
|
||
|
|
||
|
return dsp_automatic.GetInt();
|
||
|
}
|
||
|
|
||
|
// wrapper on idsp_room preset so that idsp_automatic can override
|
||
|
|
||
|
int Get_idsp_room ( void )
|
||
|
{
|
||
|
|
||
|
// if dsp_automatic is not enabled, get room
|
||
|
|
||
|
if ( !DSP_CheckDspAutoEnabled())
|
||
|
return idsp_room;
|
||
|
|
||
|
// automatic room detection is on, return dsp_automatic preset instead of dsp_room preset
|
||
|
|
||
|
return idsp_automatic;
|
||
|
}
|
||
|
|
||
|
|
||
|
// free previous preset if not 0
|
||
|
|
||
|
inline void DSP_FreePrevPreset( dsp_t *pdsp )
|
||
|
{
|
||
|
// free previous presets if non-null - ie: rapid change of preset just kills old without xfade
|
||
|
|
||
|
if ( pdsp->ipsetprev )
|
||
|
{
|
||
|
for (int i = 0; i < pdsp->cchan; i++)
|
||
|
{
|
||
|
if ( pdsp->ppsetprev[i] )
|
||
|
{
|
||
|
PSET_Free( pdsp->ppsetprev[i] );
|
||
|
pdsp->ppsetprev[i] = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
pdsp->ipsetprev = 0;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
extern ConVar dsp_mix_min;
|
||
|
extern ConVar dsp_mix_max;
|
||
|
extern ConVar dsp_db_min;
|
||
|
extern ConVar dsp_db_mixdrop;
|
||
|
|
||
|
// alloc new preset if different from current
|
||
|
// xfade from prev to new preset
|
||
|
// free previous preset, copy current into previous, set up xfade from previous to new
|
||
|
|
||
|
void DSP_SetPreset( int idsp, int ipsetnew)
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
pset_t *ppsetnew[DSPCHANMAX];
|
||
|
|
||
|
Assert (idsp >= 0 && idsp < CDSPS);
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
// validate new preset range
|
||
|
|
||
|
if ( ipsetnew >= g_cpsettemplates || ipsetnew < 0 )
|
||
|
return;
|
||
|
|
||
|
// ignore if new preset is same as current preset
|
||
|
|
||
|
if ( ipsetnew == pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
// alloc new presets (each channel is a duplicate preset)
|
||
|
|
||
|
Assert (pdsp->cchan <= DSPCHANMAX);
|
||
|
|
||
|
for (int i = 0; i < pdsp->cchan; i++)
|
||
|
{
|
||
|
ppsetnew[i] = PSET_Alloc ( ipsetnew );
|
||
|
if ( !ppsetnew[i] )
|
||
|
{
|
||
|
DevMsg("WARNING: DSP preset failed to allocate.\n");
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Assert (pdsp);
|
||
|
|
||
|
// free PREVIOUS previous preset if not 0
|
||
|
|
||
|
DSP_FreePrevPreset( pdsp );
|
||
|
|
||
|
for (int i = 0; i < pdsp->cchan; i++)
|
||
|
{
|
||
|
// current becomes previous
|
||
|
|
||
|
pdsp->ppsetprev[i] = pdsp->ppset[i];
|
||
|
|
||
|
// new becomes current
|
||
|
|
||
|
pdsp->ppset[i] = ppsetnew[i];
|
||
|
}
|
||
|
|
||
|
pdsp->ipsetprev = pdsp->ipset;
|
||
|
pdsp->ipset = ipsetnew;
|
||
|
|
||
|
if ( idsp == idsp_room || idsp == idsp_automatic )
|
||
|
{
|
||
|
// set up new dsp mix min & max, db_min & db_drop params so that new channels get new mix values
|
||
|
|
||
|
// NOTE: only new sounds will get the new mix min/max values set in their dspmix param
|
||
|
// NOTE: so - no crossfade is needed between dspmix and dspmix prev, but this also means
|
||
|
// NOTE: that currently playing ambients will not see changes to dspmix at all.
|
||
|
|
||
|
float mix_min = pdsp->ppset[0]->mix_min;
|
||
|
float mix_max = pdsp->ppset[0]->mix_max;
|
||
|
float db_min = pdsp->ppset[0]->db_min;
|
||
|
float db_mixdrop = pdsp->ppset[0]->db_mixdrop;
|
||
|
|
||
|
dsp_mix_min.SetValue( mix_min );
|
||
|
dsp_mix_max.SetValue( mix_max );
|
||
|
dsp_db_min.SetValue( db_min );
|
||
|
dsp_db_mixdrop.SetValue( db_mixdrop );
|
||
|
}
|
||
|
|
||
|
RMP_SetEnd( &pdsp->xramp );
|
||
|
|
||
|
// make sure previous dsp preset has data
|
||
|
|
||
|
Assert (pdsp->ppsetprev[0]);
|
||
|
|
||
|
// shouldn't be crossfading if current dsp preset == previous dsp preset
|
||
|
|
||
|
Assert (pdsp->ipset != pdsp->ipsetprev);
|
||
|
|
||
|
// if new preset is one-shot, keep previous preset to restore when one-shot times out
|
||
|
// but: don't restore previous one-shots!
|
||
|
|
||
|
pdsp->ipsetsav_oneshot = 0;
|
||
|
|
||
|
if ( PSET_IsOneShot( pdsp->ppset[0] ) && !PSET_IsOneShot( pdsp->ppsetprev[0] ) )
|
||
|
pdsp->ipsetsav_oneshot = pdsp->ipsetprev;
|
||
|
|
||
|
// get new xfade time from previous preset (ie: fade out time). if 0 use default. if < 0, use exponential xfade
|
||
|
|
||
|
if ( fabs(pdsp->ppsetprev[0]->fade) > 0.0 )
|
||
|
{
|
||
|
pdsp->xfade = fabs(pdsp->ppsetprev[0]->fade);
|
||
|
pdsp->bexpfade = pdsp->ppsetprev[0]->fade < 0 ? 1 : 0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// no previous preset - use defauts, set in DSP_Alloc
|
||
|
|
||
|
pdsp->xfade = pdsp->xfade_default;
|
||
|
pdsp->bexpfade = false;
|
||
|
}
|
||
|
|
||
|
RMP_Init( &(pdsp->xramp), pdsp->xfade, 0, PMAX, false );
|
||
|
}
|
||
|
|
||
|
|
||
|
#define DSP_AUTO_BASE 60 // presets 60-100 in g_psettemplates are reserved as autocreated presets
|
||
|
#define DSP_CAUTO_PRESETS 40 // must be same as DAS_CNODES!!!
|
||
|
|
||
|
// construct a dsp preset based on provided parameters,
|
||
|
// preset is constructed within g_psettemplates[] array.
|
||
|
// return preset #
|
||
|
|
||
|
// parameter batch
|
||
|
|
||
|
struct auto_params_t
|
||
|
{
|
||
|
// passed in params
|
||
|
|
||
|
bool bskyabove; // true if sky is mostly above player
|
||
|
int width; // max width of room in inches
|
||
|
int length; // max length of room in inches (length always > width)
|
||
|
int height; // max height of room in inches
|
||
|
float fdiffusion; // diffusion of room 0..1.0
|
||
|
float freflectivity; // average reflectivity of all surfaces in room 0..1.0
|
||
|
float surface_refl[6]; // reflectivity for left,right,front,back,ceiling,floor surfaces 0.0 for open surface (sky or no hit)
|
||
|
|
||
|
// derived params
|
||
|
|
||
|
int shape; // ADSP_ROOM, etc 0...4
|
||
|
int size; // ADSP_SIZE_SMALL, etc 0...3
|
||
|
int len; // ADSP_LENGTH_SHORT, etc 0...3
|
||
|
int wid; // ADSP_WIDTH_NARROW, etc 0...3
|
||
|
int ht; // ADSP_HEIGHT_LOW, etc 0...3
|
||
|
int reflectivity; // ADSP_DULL, etc 0..3
|
||
|
int diffusion; // ADSP_EMPTY, etc 0...3
|
||
|
};
|
||
|
|
||
|
|
||
|
// select type 1..5 based on params
|
||
|
// 1:simple reverb
|
||
|
// 2:diffusor + reverb
|
||
|
// 3:diffusor + delay + reverb
|
||
|
// 4:simple delay
|
||
|
// 5:diffusor + delay
|
||
|
|
||
|
#define AROOM_SMALL (10.0 * 12.0) // small room
|
||
|
#define AROOM_MEDIUM (20.0 * 12.0) // medium room
|
||
|
#define AROOM_LARGE (40.0 * 12.0) // large room
|
||
|
#define AROOM_HUGE (100.0 * 12.0) // huge room
|
||
|
#define AROOM_GIGANTIC (200.0 * 12.0) // gigantic room
|
||
|
|
||
|
#define AROOM_DUCT_WIDTH (4.0 * 12.0) // max width for duct
|
||
|
#define AROOM_DUCT_HEIGHT (6.0 * 12.0)
|
||
|
|
||
|
#define AROOM_HALL_WIDTH (8.0 * 12.0) // max width for hall
|
||
|
#define AROOM_HALL_HEIGHT (16.0 * 12.0) // max height for hall
|
||
|
|
||
|
#define AROOM_TUNNEL_WIDTH (20.0 * 12.0) // max width for tunnel
|
||
|
#define AROOM_TUNNEL_HEIGHT (30.0 * 12.0) // max height for tunnel
|
||
|
|
||
|
#define AROOM_STREET_WIDTH (12.0 * 12.0) // min width for street
|
||
|
|
||
|
#define AROOM_SHORT_LENGTH (12.0 * 12.0) // max length for short hall
|
||
|
#define AROOM_MEDIUM_LENGTH (24.0 * 12.0) // min length for medium hall
|
||
|
#define AROOM_LONG_LENGTH (48.0 * 12.0) // min length for long hall
|
||
|
#define AROOM_VLONG_LENGTH (96.0 * 12.0) // min length for very long hall
|
||
|
#define AROOM_XLONG_LENGTH (192.0 * 12.0) // min length for huge hall
|
||
|
|
||
|
#define AROOM_LOW_HEIGHT (4.0 * 12.0) // short ceiling
|
||
|
#define AROOM_MEDIUM_HEIGHT (128) // medium ceiling
|
||
|
#define AROOM_TALL_HEIGHT (18.0 * 12.0) // tall ceiling
|
||
|
#define AROOM_VTALL_HEIGHT (32.0 * 12.0) // very tall ceiling
|
||
|
#define AROOM_XTALL_HEIGHT (64.0 * 12.0) // huge tall ceiling
|
||
|
|
||
|
#define AROOM_NARROW_WIDTH (6.0 * 12.0) // narrow width
|
||
|
#define AROOM_MEDIUM_WIDTH (12.0 * 12.0) // medium width
|
||
|
#define AROOM_WIDE_WIDTH (24.0 * 12.0) // wide width
|
||
|
#define AROOM_VWIDE_WIDTH (48.0 * 12.0) // very wide
|
||
|
#define AROOM_XWIDE_WIDTH (96.0 * 12.0) // huge width
|
||
|
|
||
|
#define BETWEEN(a,b,c) ( ((a) > (b)) && ((a) <= (c)) )
|
||
|
|
||
|
#define ADSP_IsShaft(pa) (pa->height > (3.0 * pa->length))
|
||
|
#define ADSP_IsRoom(pa) (pa->length <= (2.5 * pa->width))
|
||
|
#define ADSP_IsHall(pa) ((pa->length > (2.5 * pa->width)) && (BETWEEN(pa->width, AROOM_DUCT_WIDTH, AROOM_HALL_WIDTH)))
|
||
|
#define ADSP_IsTunnel(pa) ((pa->length > (4.0 * pa->width)) && (pa->width > AROOM_HALL_WIDTH))
|
||
|
#define ADSP_IsDuct(pa) ((pa->length > (4.0 * pa->width)) && (pa->width <= AROOM_DUCT_WIDTH))
|
||
|
|
||
|
#define ADSP_IsCourtyard(pa) (pa->length <= (2.5 * pa->width))
|
||
|
#define ADSP_IsAlley(pa) ((pa->length > (2.5 * pa->width)) && (pa->width <= AROOM_STREET_WIDTH))
|
||
|
#define ADSP_IsStreet(pa) ((pa->length > (2.5 * pa->width)) && (pa->width > AROOM_STREET_WIDTH))
|
||
|
|
||
|
#define ADSP_IsSmallRoom(pa) (pa->length <= AROOM_SMALL)
|
||
|
#define ADSP_IsMediumRoom(pa) ((BETWEEN(pa->length, AROOM_SMALL, AROOM_MEDIUM)) ) // && (BETWEEN(pa->width, AROOM_SMALL, AROOM_MEDIUM)))
|
||
|
#define ADSP_IsLargeRoom(pa) (BETWEEN(pa->length, AROOM_MEDIUM, AROOM_LARGE) ) // && BETWEEN(pa->width, AROOM_MEDIUM, AROOM_LARGE))
|
||
|
#define ADSP_IsHugeRoom(pa) (BETWEEN(pa->length, AROOM_LARGE, AROOM_HUGE) ) // && BETWEEN(pa->width, AROOM_LARGE, AROOM_HUGE))
|
||
|
#define ADSP_IsGiganticRoom(pa) ((pa->length > AROOM_HUGE) ) // && (pa->width > AROOM_HUGE))
|
||
|
|
||
|
#define ADSP_IsShortLength(pa) (pa->length <= AROOM_SHORT_LENGTH)
|
||
|
#define ADSP_IsMediumLength(pa) (BETWEEN(pa->length, AROOM_SHORT_LENGTH, AROOM_MEDIUM_LENGTH))
|
||
|
#define ADSP_IsLongLength(pa) (BETWEEN(pa->length, AROOM_MEDIUM_LENGTH, AROOM_LONG_LENGTH))
|
||
|
#define ADSP_IsVLongLength(pa) (BETWEEN(pa->length, AROOM_LONG_LENGTH, AROOM_VLONG_LENGTH))
|
||
|
#define ADSP_IsXLongLength(pa) (pa->length > AROOM_VLONG_LENGTH)
|
||
|
|
||
|
#define ADSP_IsLowHeight(pa) (pa->height <= AROOM_LOW_HEIGHT)
|
||
|
#define ADSP_IsMediumHeight(pa) (BETWEEN(pa->height, AROOM_LOW_HEIGHT, AROOM_MEDIUM_HEIGHT))
|
||
|
#define ADSP_IsTallHeight(pa) (BETWEEN(pa->height, AROOM_MEDIUM_HEIGHT, AROOM_TALL_HEIGHT))
|
||
|
#define ADSP_IsVTallHeight(pa) (BETWEEN(pa->height, AROOM_TALL_HEIGHT, AROOM_VTALL_HEIGHT))
|
||
|
#define ADSP_IsXTallHeight(pa) (pa->height > AROOM_VTALL_HEIGHT)
|
||
|
|
||
|
#define ADSP_IsNarrowWidth(pa) (pa->width <= AROOM_NARROW_WIDTH)
|
||
|
#define ADSP_IsMediumWidth(pa) (BETWEEN(pa->width, AROOM_NARROW_WIDTH, AROOM_MEDIUM_WIDTH))
|
||
|
#define ADSP_IsWideWidth(pa) (BETWEEN(pa->width, AROOM_MEDIUM_WIDTH, AROOM_WIDE_WIDTH))
|
||
|
#define ADSP_IsVWideWidth(pa) (BETWEEN(pa->width, AROOM_WIDE_WIDTH, AROOM_VWIDE_WIDTH))
|
||
|
#define ADSP_IsXWideWidth(pa) (pa->width > AROOM_VWIDE_WIDTH)
|
||
|
|
||
|
#define ADSP_IsInside(pa) (!(pa->bskyabove))
|
||
|
|
||
|
// room diffusion
|
||
|
|
||
|
#define ADSP_EMPTY 0
|
||
|
#define ADSP_SPARSE 1
|
||
|
#define ADSP_CLUTTERED 2
|
||
|
#define ADSP_FULL 3
|
||
|
#define ADSP_DIFFUSION_MAX 4
|
||
|
|
||
|
#define AROOM_DIF_EMPTY 0.01 // 1% of space by volume is other objects
|
||
|
#define AROOM_DIF_SPARSE 0.1 // 10% "
|
||
|
#define AROOM_DIF_CLUTTERED 0.3 // 30% "
|
||
|
#define AROOM_DIF_FULL 0.5 // 50% "
|
||
|
|
||
|
#define ADSP_IsEmpty(pa) (pa->fdiffusion <= AROOM_DIF_EMPTY)
|
||
|
#define ADSP_IsSparse(pa) (BETWEEN(pa->fdiffusion, AROOM_DIF_EMPTY, AROOM_DIF_SPARSE))
|
||
|
#define ADSP_IsCluttered(pa) (BETWEEN(pa->fdiffusion, AROOM_DIF_SPARSE, AROOM_DIF_CLUTTERED))
|
||
|
#define ADSP_IsFull(pa) (pa->fdiffusion > AROOM_DIF_CLUTTERED)
|
||
|
|
||
|
#define ADSP_IsDiffuse(pa) (pa->diffusion > ADSP_SPARSE)
|
||
|
|
||
|
// room acoustic reflectivity
|
||
|
|
||
|
// tile 0.3 * 3.3 = 0.99
|
||
|
// metal 0.25 * 3.3 = 0.83
|
||
|
// concrete,rock,brick,glass,gravel 0.2 * 3.3 = 0.66
|
||
|
// metal panel/vent, wood, water 0.1 * 3.3 = 0.33
|
||
|
// carpet,sand,snow,dirt 0.01 * 3.3 = 0.03
|
||
|
|
||
|
#define ADSP_DULL 0
|
||
|
#define ADSP_FLAT 1
|
||
|
#define ADSP_REFLECTIVE 2
|
||
|
#define ADSP_BRIGHT 3
|
||
|
#define ADSP_REFLECTIVITY_MAX 4
|
||
|
|
||
|
#define AROOM_REF_DULL 0.04
|
||
|
#define AROOM_REF_FLAT 0.50
|
||
|
#define AROOM_REF_REFLECTIVE 0.80
|
||
|
#define AROOM_REF_BRIGHT 0.99
|
||
|
|
||
|
#define ADSP_IsDull(pa) (pa->freflectivity <= AROOM_REF_DULL)
|
||
|
#define ADSP_IsFlat(pa) (BETWEEN(pa->freflectivity, AROOM_REF_DULL, AROOM_REF_FLAT))
|
||
|
#define ADSP_IsReflective(pa) (BETWEEN(pa->freflectivity, AROOM_REF_FLAT, AROOM_REF_REFLECTIVE))
|
||
|
#define ADSP_IsBright(pa) (pa->freflectivity > AROOM_REF_REFLECTIVE)
|
||
|
|
||
|
#define ADSP_IsRefl(pa) (pa->reflectivity > ADSP_FLAT)
|
||
|
|
||
|
// room shapes
|
||
|
|
||
|
#define ADSP_ROOM 0
|
||
|
#define ADSP_DUCT 1
|
||
|
#define ADSP_HALL 2
|
||
|
#define ADSP_TUNNEL 3
|
||
|
#define ADSP_STREET 4
|
||
|
#define ADSP_ALLEY 5
|
||
|
#define ADSP_COURTYARD 6
|
||
|
#define ADSP_OPEN_SPACE 7 // NOTE: 7..10 must remain in order !!!
|
||
|
#define ADSP_OPEN_WALL 8
|
||
|
#define ADSP_OPEN_STREET 9
|
||
|
#define ADSP_OPEN_COURTYARD 10
|
||
|
|
||
|
// room sizes
|
||
|
|
||
|
#define ADSP_SIZE_SMALL 0 // NOTE: must remain 0..4!!!
|
||
|
#define ADSP_SIZE_MEDIUM 1
|
||
|
#define ADSP_SIZE_LARGE 2
|
||
|
#define ADSP_SIZE_HUGE 3
|
||
|
#define ADSP_SIZE_GIGANTIC 4
|
||
|
#define ADSP_SIZE_MAX 5
|
||
|
|
||
|
#define ADSP_LENGTH_SHORT 0
|
||
|
#define ADSP_LENGTH_MEDIUM 1
|
||
|
#define ADSP_LENGTH_LONG 2
|
||
|
#define ADSP_LENGTH_VLONG 3
|
||
|
#define ADSP_LENGTH_XLONG 4
|
||
|
#define ADSP_LENGTH_MAX 5
|
||
|
|
||
|
#define ADSP_WIDTH_NARROW 0
|
||
|
#define ADSP_WIDTH_MEDIUM 1
|
||
|
#define ADSP_WIDTH_WIDE 2
|
||
|
#define ADSP_WIDTH_VWIDE 3
|
||
|
#define ADSP_WIDTH_XWIDE 4
|
||
|
#define ADSP_WIDTH_MAX 5
|
||
|
|
||
|
#define ADSP_HEIGHT_LOW 0
|
||
|
#define ADSP_HEIGTH_MEDIUM 1
|
||
|
#define ADSP_HEIGHT_TALL 2
|
||
|
#define ADSP_HEIGHT_VTALL 3
|
||
|
#define ADSP_HEIGHT_XTALL 4
|
||
|
#define ADSP_HEIGHT_MAX 5
|
||
|
|
||
|
|
||
|
// convert numeric size params to #defined size params
|
||
|
|
||
|
void ADSP_GetSize( auto_params_t *pa )
|
||
|
{
|
||
|
pa->size = ((ADSP_IsSmallRoom(pa) ? 1 : 0) * ADSP_SIZE_SMALL) +
|
||
|
((ADSP_IsMediumRoom(pa) ? 1 : 0) * ADSP_SIZE_MEDIUM) +
|
||
|
((ADSP_IsLargeRoom(pa) ? 1 : 0) * ADSP_SIZE_LARGE) +
|
||
|
((ADSP_IsHugeRoom(pa) ? 1 : 0) * ADSP_SIZE_HUGE) +
|
||
|
((ADSP_IsGiganticRoom(pa) ? 1 : 0) * ADSP_SIZE_GIGANTIC);
|
||
|
|
||
|
pa->len = ((ADSP_IsShortLength(pa) ? 1 : 0) * ADSP_LENGTH_SHORT) +
|
||
|
((ADSP_IsMediumLength(pa) ? 1 : 0) * ADSP_LENGTH_MEDIUM) +
|
||
|
((ADSP_IsLongLength(pa) ? 1 : 0) * ADSP_LENGTH_LONG) +
|
||
|
((ADSP_IsVLongLength(pa) ? 1 : 0) * ADSP_LENGTH_VLONG) +
|
||
|
((ADSP_IsXLongLength(pa) ? 1 : 0) * ADSP_LENGTH_XLONG);
|
||
|
|
||
|
pa->wid = ((ADSP_IsNarrowWidth(pa) ? 1 : 0) * ADSP_WIDTH_NARROW) +
|
||
|
((ADSP_IsMediumWidth(pa) ? 1 : 0) * ADSP_WIDTH_MEDIUM) +
|
||
|
((ADSP_IsWideWidth(pa) ? 1 : 0) * ADSP_WIDTH_WIDE) +
|
||
|
((ADSP_IsVWideWidth(pa) ? 1 : 0) * ADSP_WIDTH_VWIDE) +
|
||
|
((ADSP_IsXWideWidth(pa) ? 1 : 0) * ADSP_WIDTH_XWIDE);
|
||
|
|
||
|
pa->ht = ((ADSP_IsLowHeight(pa) ? 1 : 0) * ADSP_HEIGHT_LOW) +
|
||
|
((ADSP_IsMediumHeight(pa) ? 1 : 0) * ADSP_HEIGTH_MEDIUM) +
|
||
|
((ADSP_IsTallHeight(pa) ? 1 : 0) * ADSP_HEIGHT_TALL) +
|
||
|
((ADSP_IsVTallHeight(pa) ? 1 : 0) * ADSP_HEIGHT_VTALL) +
|
||
|
((ADSP_IsXTallHeight(pa) ? 1 : 0) * ADSP_HEIGHT_XTALL);
|
||
|
|
||
|
pa->reflectivity =
|
||
|
((ADSP_IsDull(pa) ? 1 : 0) * ADSP_DULL) +
|
||
|
((ADSP_IsFlat(pa) ? 1 : 0) * ADSP_FLAT) +
|
||
|
((ADSP_IsReflective(pa) ? 1 : 0) * ADSP_REFLECTIVE) +
|
||
|
((ADSP_IsBright(pa) ? 1 : 0) * ADSP_BRIGHT);
|
||
|
|
||
|
pa->diffusion =
|
||
|
((ADSP_IsEmpty(pa) ? 1 : 0) * ADSP_EMPTY) +
|
||
|
((ADSP_IsSparse(pa) ? 1 : 0) * ADSP_SPARSE) +
|
||
|
((ADSP_IsCluttered(pa) ? 1 : 0) * ADSP_CLUTTERED) +
|
||
|
((ADSP_IsFull(pa) ? 1 : 0) * ADSP_FULL);
|
||
|
|
||
|
Assert(pa->size < ADSP_SIZE_MAX);
|
||
|
Assert(pa->len < ADSP_LENGTH_MAX);
|
||
|
Assert(pa->wid < ADSP_WIDTH_MAX);
|
||
|
Assert(pa->ht < ADSP_HEIGHT_MAX);
|
||
|
Assert(pa->reflectivity < ADSP_REFLECTIVITY_MAX);
|
||
|
Assert(pa->diffusion < ADSP_DIFFUSION_MAX);
|
||
|
|
||
|
if ( pa->shape != ADSP_COURTYARD && pa->shape != ADSP_OPEN_COURTYARD )
|
||
|
{
|
||
|
// fix up size for streets, alleys, halls, ducts, tunnelsy
|
||
|
|
||
|
if (pa->shape == ADSP_STREET || pa->shape == ADSP_ALLEY )
|
||
|
pa->size = pa->wid;
|
||
|
else
|
||
|
pa->size = (pa->len + pa->wid) / 2;
|
||
|
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
void ADSP_GetOutsideSize( auto_params_t *pa )
|
||
|
{
|
||
|
ADSP_GetSize( pa );
|
||
|
}
|
||
|
|
||
|
// return # of sides that had max length or sky hits (out of 6 sides).
|
||
|
|
||
|
int ADSP_COpenSides( auto_params_t *pa )
|
||
|
{
|
||
|
int count = 0;
|
||
|
|
||
|
// only look at left,right,front,back walls - ignore floor, ceiling
|
||
|
|
||
|
for (int i = 0; i < 4; i++)
|
||
|
{
|
||
|
if (pa->surface_refl[i] == 0.0)
|
||
|
count++;
|
||
|
}
|
||
|
|
||
|
return count;
|
||
|
}
|
||
|
|
||
|
// given auto params, return shape and size of room
|
||
|
|
||
|
void ADSP_GetAutoShape( auto_params_t *pa )
|
||
|
{
|
||
|
|
||
|
// INSIDE:
|
||
|
// shapes: duct, hall, tunnel, shaft (vertical duct, hall or tunnel)
|
||
|
// sizes: short->long, narrow->wide, low->tall
|
||
|
// shapes: room
|
||
|
// sizes: small->large, low->tall
|
||
|
|
||
|
// OUTSIDE:
|
||
|
// shapes: street, alley
|
||
|
// sizes: short->long, narrow->wide
|
||
|
// shapes: courtyard
|
||
|
// sizes: small->large
|
||
|
|
||
|
// shapes: open_space, wall, open_street, open_corner, open_courtyard
|
||
|
// sizes: open, narrow->wide
|
||
|
|
||
|
bool bshaft = false;
|
||
|
int t;
|
||
|
|
||
|
if (ADSP_IsInside(pa))
|
||
|
{
|
||
|
if (ADSP_IsShaft(pa))
|
||
|
{
|
||
|
// temp swap height and length
|
||
|
|
||
|
bshaft = true;
|
||
|
t = pa->height;
|
||
|
pa->height = pa->length;
|
||
|
pa->length = t;
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("VERTICAL SHAFT Detected \n");
|
||
|
}
|
||
|
|
||
|
// get shape
|
||
|
|
||
|
if (ADSP_IsDuct(pa))
|
||
|
{
|
||
|
pa->shape = ADSP_DUCT;
|
||
|
ADSP_GetSize( pa );
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("DUCT Detected \n");
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
|
||
|
if (ADSP_IsHall(pa))
|
||
|
{
|
||
|
// get size
|
||
|
pa->shape = ADSP_HALL;
|
||
|
ADSP_GetSize( pa );
|
||
|
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("HALL Detected \n");
|
||
|
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
|
||
|
if (ADSP_IsTunnel(pa))
|
||
|
{
|
||
|
// get size
|
||
|
pa->shape = ADSP_TUNNEL;
|
||
|
ADSP_GetSize( pa );
|
||
|
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("TUNNEL Detected \n");
|
||
|
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
|
||
|
// default
|
||
|
// (ADSP_IsRoom(pa))
|
||
|
{
|
||
|
// get size
|
||
|
pa->shape = ADSP_ROOM;
|
||
|
ADSP_GetSize( pa );
|
||
|
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("ROOM Detected \n");
|
||
|
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// outside:
|
||
|
|
||
|
if (ADSP_COpenSides(pa) > 0) // side hit sky, or side has max length
|
||
|
{
|
||
|
// get shape - courtyard, street, wall or open space
|
||
|
// 10..7
|
||
|
pa->shape = ADSP_OPEN_COURTYARD - (ADSP_COpenSides(pa) - 1);
|
||
|
ADSP_GetOutsideSize( pa );
|
||
|
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("OPEN SIDED OUTDOOR AREA Detected \n");
|
||
|
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
|
||
|
// all sides closed:
|
||
|
|
||
|
// get shape - closed street or alley or courtyard
|
||
|
|
||
|
if (ADSP_IsCourtyard(pa))
|
||
|
{
|
||
|
pa->shape = ADSP_COURTYARD;
|
||
|
ADSP_GetOutsideSize( pa );
|
||
|
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("OUTSIDE COURTYARD Detected \n");
|
||
|
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
|
||
|
if (ADSP_IsAlley(pa))
|
||
|
{
|
||
|
pa->shape = ADSP_ALLEY;
|
||
|
ADSP_GetOutsideSize( pa );
|
||
|
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("OUTSIDE ALLEY Detected \n");
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
|
||
|
// default to 'street' if sides are closed
|
||
|
|
||
|
// if (ADSP_IsStreet(pa))
|
||
|
{
|
||
|
pa->shape = ADSP_STREET;
|
||
|
ADSP_GetOutsideSize( pa );
|
||
|
if (das_debug.GetInt() > 1)
|
||
|
DevMsg("OUTSIDE STREET Detected \n");
|
||
|
goto autoshape_exit;
|
||
|
}
|
||
|
|
||
|
autoshape_exit:
|
||
|
|
||
|
// swap height & length if needed
|
||
|
|
||
|
if (bshaft)
|
||
|
{
|
||
|
t = pa->height;
|
||
|
pa->height = pa->length;
|
||
|
pa->length = t;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int MapReflectivityToDLYCutoff[] =
|
||
|
{
|
||
|
1000, // DULL
|
||
|
2000, // FLAT
|
||
|
4000, // REFLECTIVE
|
||
|
6000 // BRIGHT
|
||
|
};
|
||
|
|
||
|
float MapSizeToDLYFeedback[] =
|
||
|
{
|
||
|
0.9, // 0.6, // SMALL
|
||
|
0.8, // 0.5, // MEDIUM
|
||
|
0.7, // 0.4, // LARGE
|
||
|
0.6, // 0.3, // HUGE
|
||
|
0.5, // 0.2, // GIGANTIC
|
||
|
};
|
||
|
|
||
|
void ADSP_SetupAutoDelay( prc_t *pprc_dly, auto_params_t *pa )
|
||
|
{
|
||
|
// shapes:
|
||
|
// inside: duct, long hall, long tunnel, large room
|
||
|
// outside: open courtyard, street wall, space
|
||
|
// outside: closed courtyard, alley, street
|
||
|
|
||
|
// size 0..4
|
||
|
// len 0..3
|
||
|
// wid 0..3
|
||
|
// reflectivity: 0..3
|
||
|
// diffusion 0..3
|
||
|
|
||
|
// dtype: delay type DLY_PLAIN, DLY_LOWPASS, DLY_ALLPASS
|
||
|
// delay: delay in milliseconds (room max size in feet)
|
||
|
// feedback: feedback 0-1.0
|
||
|
// gain: final gain of output stage, 0-1.0
|
||
|
|
||
|
int size = pa->length * 2.0;
|
||
|
|
||
|
if (pa->shape == ADSP_ALLEY || pa->shape == ADSP_STREET || pa->shape == ADSP_OPEN_STREET)
|
||
|
size = pa->width * 2.0;
|
||
|
|
||
|
pprc_dly->type = PRC_DLY;
|
||
|
|
||
|
pprc_dly->prm[dly_idtype] = DLY_LOWPASS; // delay with feedback
|
||
|
|
||
|
pprc_dly->prm[dly_idelay] = clamp((size / 12.0), 5.0, 500.0);
|
||
|
|
||
|
pprc_dly->prm[dly_ifeedback] = MapSizeToDLYFeedback[pa->len];
|
||
|
|
||
|
// reduce gain based on distance reflection travels
|
||
|
// float g = 1.0 - ( clamp(pprc_dly->prm[dly_idelay], 10.0, 1000.0) / (1000.0 - 10.0) );
|
||
|
// pprc_dly->prm[dly_igain] = g;
|
||
|
|
||
|
pprc_dly->prm[dly_iftype] = FLT_LP;
|
||
|
if (ADSP_IsInside(pa))
|
||
|
pprc_dly->prm[dly_icutoff] = MapReflectivityToDLYCutoff[pa->reflectivity];
|
||
|
else
|
||
|
pprc_dly->prm[dly_icutoff] = (int)((float)(MapReflectivityToDLYCutoff[pa->reflectivity]) * 0.75);
|
||
|
|
||
|
pprc_dly->prm[dly_iqwidth] = 0;
|
||
|
|
||
|
pprc_dly->prm[dly_iquality] = QUA_LO;
|
||
|
|
||
|
float l = clamp((pa->length * 2.0 / 12.0), 14.0, 500.0);
|
||
|
float w = clamp((pa->width * 2.0 / 12.0), 14.0, 500.0);
|
||
|
|
||
|
// convert to multitap delay
|
||
|
|
||
|
pprc_dly->prm[dly_idtype] = DLY_LOWPASS_4TAP;
|
||
|
|
||
|
pprc_dly->prm[dly_idelay] = l;
|
||
|
pprc_dly->prm[dly_itap1] = w;
|
||
|
pprc_dly->prm[dly_itap2] = l; // max(7, l * 0.7 );
|
||
|
pprc_dly->prm[dly_itap3] = l; // max(7, w * 0.7 );
|
||
|
|
||
|
pprc_dly->prm[dly_igain] = 1.0;
|
||
|
}
|
||
|
|
||
|
int MapReflectivityToRVACutoff[] =
|
||
|
{
|
||
|
1000, // DULL
|
||
|
2000, // FLAT
|
||
|
4000, // REFLECTIVE
|
||
|
6000 // BRIGHT
|
||
|
};
|
||
|
|
||
|
float MapSizeToRVANumDelays[] =
|
||
|
{
|
||
|
3, // SMALL 3 reverbs
|
||
|
6, // MEDIUM 6 reverbs
|
||
|
6, // LARGE 6 reverbs
|
||
|
9, // HUGE 9 reverbs
|
||
|
12, // GIGANTIC 12 reverbs
|
||
|
};
|
||
|
|
||
|
float MapSizeToRVAFeedback[] =
|
||
|
{
|
||
|
0.75, // SMALL
|
||
|
0.8, // MEDIUM
|
||
|
0.9, // LARGE
|
||
|
0.95, // HUGE
|
||
|
0.98, // GIGANTIC
|
||
|
};
|
||
|
|
||
|
void ADSP_SetupAutoReverb( prc_t *pprc_rva, auto_params_t *pa )
|
||
|
{
|
||
|
// shape: hall, tunnel or room
|
||
|
// size 0..4
|
||
|
// reflectivity: 0..3
|
||
|
// diffusion 0..3
|
||
|
|
||
|
// size: 0-2.0 scales nominal delay parameters (18 to 47 ms * scale = delay)
|
||
|
// numdelays: 0-12 controls # of parallel or series delays
|
||
|
// decay: 0-2.0 scales feedback parameters (.7 to .9 * scale/2.0 = feedback)
|
||
|
// fparallel: if true, filters are built into delays, otherwise filter output only
|
||
|
// fmoddly: if true, all delays are modulating delays
|
||
|
float gain = 1.0;
|
||
|
|
||
|
pprc_rva->type = PRC_RVA;
|
||
|
|
||
|
pprc_rva->prm[rva_size_max] = 50.0;
|
||
|
pprc_rva->prm[rva_size_min] = 30.0;
|
||
|
|
||
|
if (ADSP_IsRoom(pa))
|
||
|
pprc_rva->prm[rva_inumdelays] = MapSizeToRVANumDelays[pa->size];
|
||
|
else
|
||
|
pprc_rva->prm[rva_inumdelays] = MapSizeToRVANumDelays[pa->len];
|
||
|
|
||
|
pprc_rva->prm[rva_ifeedback] = 0.9;
|
||
|
|
||
|
pprc_rva->prm[rva_icutoff] = MapReflectivityToRVACutoff[pa->reflectivity];
|
||
|
|
||
|
pprc_rva->prm[rva_ifparallel] = 1;
|
||
|
pprc_rva->prm[rva_imoddly] = ADSP_IsEmpty(pa) ? 0 : 4;
|
||
|
pprc_rva->prm[rva_imodrate] = 3.48;
|
||
|
|
||
|
pprc_rva->prm[rva_iftaps] = 0; // 0.1 // use extra delay taps to increase density
|
||
|
|
||
|
pprc_rva->prm[rva_width] = clamp( ((float)(pa->width) / 12.0), 6.0, 500.0); // in feet
|
||
|
pprc_rva->prm[rva_depth] = clamp( ((float)(pa->length) / 12.0), 6.0, 500.0);
|
||
|
pprc_rva->prm[rva_height] = clamp( ((float)(pa->height) / 12.0), 6.0, 500.0);
|
||
|
|
||
|
// room
|
||
|
pprc_rva->prm[rva_fbwidth] = 0.9; // MapSizeToRVAFeedback[pa->size]; // larger size = more feedback
|
||
|
pprc_rva->prm[rva_fbdepth] = 0.9; // MapSizeToRVAFeedback[pa->size];
|
||
|
pprc_rva->prm[rva_fbheight] = 0.5; // MapSizeToRVAFeedback[pa->size];
|
||
|
|
||
|
// feedback is based on size of room:
|
||
|
|
||
|
if (ADSP_IsInside(pa))
|
||
|
{
|
||
|
if (pa->shape == ADSP_HALL)
|
||
|
{
|
||
|
pprc_rva->prm[rva_fbwidth] = 0.7; //MapSizeToRVAFeedback[pa->wid];
|
||
|
pprc_rva->prm[rva_fbdepth] = -0.5; //MapSizeToRVAFeedback[pa->len];
|
||
|
pprc_rva->prm[rva_fbheight] = 0.3; //MapSizeToRVAFeedback[pa->ht];
|
||
|
}
|
||
|
|
||
|
if (pa->shape == ADSP_TUNNEL)
|
||
|
{
|
||
|
pprc_rva->prm[rva_fbwidth] = 0.9;
|
||
|
pprc_rva->prm[rva_fbdepth] = -0.8; // fixed pre-delay, no feedback
|
||
|
pprc_rva->prm[rva_fbheight] = 0.3;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (pa->shape == ADSP_ALLEY)
|
||
|
{
|
||
|
pprc_rva->prm[rva_fbwidth] = 0.9;
|
||
|
pprc_rva->prm[rva_fbdepth] = -0.8; // fixed pre-delay, no feedback
|
||
|
pprc_rva->prm[rva_fbheight] = 0.0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!ADSP_IsInside(pa))
|
||
|
pprc_rva->prm[rva_fbheight] = 0.0;
|
||
|
|
||
|
pprc_rva->prm[rva_igain] = gain;
|
||
|
}
|
||
|
|
||
|
// diffusor templates for auto create
|
||
|
|
||
|
// size: 0-1.0 scales all delays (13ms to 41ms * scale = delay)
|
||
|
// numdelays: 0-4.0 controls # of series delays
|
||
|
// decay: 0-1.0 scales all feedback parameters
|
||
|
|
||
|
// prctype size #dly feedback
|
||
|
|
||
|
#if 0
|
||
|
#define PRC_DFRA_S {PRC_DFR, {0.5, 2, 0.10}, NULL,NULL,NULL,NULL,NULL} // S room
|
||
|
#define PRC_DFRA_M {PRC_DFR, {0.75, 2, 0.12}, NULL,NULL,NULL,NULL,NULL} // M room
|
||
|
#define PRC_DFRA_L {PRC_DFR, {1.0, 3, 0.13}, NULL,NULL,NULL,NULL,NULL} // L room
|
||
|
#define PRC_DFRA_VL {PRC_DFR, {1.0, 3, 0.15}, NULL,NULL,NULL,NULL,NULL} // VL room
|
||
|
|
||
|
prc_t g_prc_dfr_auto[] = {PRC_DFRA_S, PRC_DFRA_M, PRC_DFRA_L, PRC_DFRA_VL, PRC_DFRA_VL};
|
||
|
|
||
|
//$BUGBUGBUG: I think this should be sizeof(prc_t), not sizeof(pset_t)...
|
||
|
#define CDFRTEMPLATES (sizeof(g_prc_dfr_auto)/sizeof(pset_t)) // number of diffusor templates
|
||
|
|
||
|
// copy diffusor template from preset list, based on room size
|
||
|
|
||
|
void ADSP_SetupAutoDiffusor( prc_t *pprc_dfr, auto_params_t *pa )
|
||
|
{
|
||
|
int i = clamp(pa->size, 0, (int)CDFRTEMPLATES - 1);
|
||
|
|
||
|
// copy diffusor preset based on size
|
||
|
|
||
|
*pprc_dfr = g_prc_dfr_auto[i];
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// return index to processor given processor type and preset
|
||
|
// skips N processors of similar type
|
||
|
// returns -1 if type not found
|
||
|
|
||
|
int ADSP_FindProc( pset_t *ppset, int proc_type, int skip )
|
||
|
{
|
||
|
int skipcount = skip;
|
||
|
|
||
|
for (int i = 0; i < ppset->cprcs; i++)
|
||
|
{
|
||
|
// look for match on processor type
|
||
|
|
||
|
if ( ppset->prcs[i].type == proc_type )
|
||
|
{
|
||
|
// skip first N procs of similar type,
|
||
|
|
||
|
// return index to processor
|
||
|
|
||
|
if (!skipcount)
|
||
|
return i;
|
||
|
|
||
|
skipcount--;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
// interpolate parameter:
|
||
|
// pnew - target preset
|
||
|
// pmin - preset with parameter with min value
|
||
|
// pmax - preset with parameter with max value
|
||
|
// proc_type - type of processor to look for ie: PRC_RVA or PRC_DLY
|
||
|
// skipprocs - skip n processors of type
|
||
|
// iparam - which parameter within processor to interpolate
|
||
|
// index -
|
||
|
// index_max: use index/index_max as interpolater between pmin param and pmax param
|
||
|
// if bexp is true, interpolate exponentially as (index/index_max)^2
|
||
|
|
||
|
// NOTE: returns with no result if processor type is not found in all presets.
|
||
|
|
||
|
void ADSP_InterpParam( pset_t *pnew, pset_t *pmin, pset_t *pmax, int proc_type, int skipprocs, int iparam, int index, int index_max, bool bexp )
|
||
|
{
|
||
|
// find processor index in pnew
|
||
|
int iproc_new = ADSP_FindProc( pnew, proc_type, skipprocs);
|
||
|
int iproc_min = ADSP_FindProc( pmin, proc_type, skipprocs);
|
||
|
int iproc_max = ADSP_FindProc( pmax, proc_type, skipprocs);
|
||
|
|
||
|
// make sure processor type found in all presets
|
||
|
|
||
|
if ( iproc_new < 0 || iproc_min < 0 || iproc_max < 0 )
|
||
|
return;
|
||
|
|
||
|
float findex = (float)index/(float)index_max;
|
||
|
float vmin = pmin->prcs[iproc_min].prm[iparam];
|
||
|
float vmax = pmax->prcs[iproc_max].prm[iparam];
|
||
|
float vinterp;
|
||
|
|
||
|
// interpolate
|
||
|
|
||
|
if (!bexp)
|
||
|
vinterp = vmin + (vmax - vmin) * findex;
|
||
|
else
|
||
|
vinterp = vmin + (vmax - vmin) * findex * findex;
|
||
|
|
||
|
pnew->prcs[iproc_new].prm[iparam] = vinterp;
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// directly set parameter
|
||
|
|
||
|
void ADSP_SetParam( pset_t *pnew, int proc_type, int skipprocs, int iparam, float value )
|
||
|
{
|
||
|
int iproc_new = ADSP_FindProc( pnew, proc_type, skipprocs);
|
||
|
|
||
|
if (iproc_new >= 0)
|
||
|
pnew->prcs[iproc_new].prm[iparam] = value;
|
||
|
}
|
||
|
|
||
|
// directly set parameter if min or max is negative
|
||
|
|
||
|
void ADSP_SetParamIfNegative( pset_t *pnew, pset_t *pmin, pset_t *pmax, int proc_type, int skipprocs, int iparam, int index, int index_max, bool bexp, float value )
|
||
|
{
|
||
|
// find processor index in pnew
|
||
|
int iproc_new = ADSP_FindProc( pnew, proc_type, skipprocs);
|
||
|
int iproc_min = ADSP_FindProc( pmin, proc_type, skipprocs);
|
||
|
int iproc_max = ADSP_FindProc( pmax, proc_type, skipprocs);
|
||
|
|
||
|
// make sure processor type found in all presets
|
||
|
|
||
|
if ( iproc_new < 0 || iproc_min < 0 || iproc_max < 0 )
|
||
|
return;
|
||
|
|
||
|
float vmin = pmin->prcs[iproc_min].prm[iparam];
|
||
|
float vmax = pmax->prcs[iproc_max].prm[iparam];
|
||
|
|
||
|
if ( vmin < 0.0 || vmax < 0.0 )
|
||
|
ADSP_SetParam( pnew, proc_type, skipprocs, iparam, value );
|
||
|
else
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, proc_type, skipprocs, iparam, index, index_max, bexp);
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// given min and max preset and auto parameters, create new preset
|
||
|
// NOTE: the # and type of processors making up pmin and pmax presets must be identical!
|
||
|
|
||
|
void ADSP_InterpolatePreset( pset_t *pnew, pset_t *pmin, pset_t *pmax, auto_params_t *pa, int iskip )
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
// if size > mid size, then copy basic processors from MAX preset,
|
||
|
// otherwise, copy from MIN preset
|
||
|
|
||
|
if ( !iskip )
|
||
|
{
|
||
|
// only copy on 1st call
|
||
|
|
||
|
if ( pa->size > ADSP_SIZE_MEDIUM )
|
||
|
{
|
||
|
*pnew = *pmax;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
*pnew = *pmin;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// DFR
|
||
|
|
||
|
// interpolate all DFR params on size
|
||
|
|
||
|
for (i = 0; i < dfr_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_DFR, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
// RVA
|
||
|
|
||
|
// interpolate size_max, size_min, feedback, #delays, moddly, imodrate, based on ap size
|
||
|
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_ifeedback, pa->size, ADSP_SIZE_MAX, 0);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_size_min, pa->size, ADSP_SIZE_MAX, 1);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_size_max, pa->size, ADSP_SIZE_MAX, 1);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_igain, pa->size, ADSP_SIZE_MAX, 0);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_inumdelays, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_imoddly, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_imodrate, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
// interpolate width,depth,height based on ap width length & height - exponential interpolation
|
||
|
// if pmin or pmax parameters are < 0, directly set value from w/l/h
|
||
|
|
||
|
float w = clamp( ((float)(pa->width) / 12.0), 6.0, 500.0); // in feet
|
||
|
float l = clamp( ((float)(pa->length) / 12.0), 6.0, 500.0);
|
||
|
float h = clamp( ((float)(pa->height) / 12.0), 6.0, 500.0);
|
||
|
|
||
|
ADSP_SetParamIfNegative( pnew, pmin, pmax, PRC_RVA, iskip, rva_width, pa->wid, ADSP_WIDTH_MAX, 1, w);
|
||
|
ADSP_SetParamIfNegative( pnew, pmin, pmax, PRC_RVA, iskip, rva_depth, pa->len, ADSP_LENGTH_MAX, 1, l);
|
||
|
ADSP_SetParamIfNegative( pnew, pmin, pmax, PRC_RVA, iskip, rva_height, pa->ht, ADSP_HEIGHT_MAX, 1, h);
|
||
|
|
||
|
// interpolate w/d/h feedback based on ap w/d/f
|
||
|
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_fbwidth, pa->wid, ADSP_WIDTH_MAX , 0);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_fbdepth, pa->len, ADSP_LENGTH_MAX , 0);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_RVA, iskip, rva_fbheight, pa->ht, ADSP_HEIGHT_MAX , 0);
|
||
|
|
||
|
// interpolate cutoff based on ap reflectivity
|
||
|
// NOTE: cutoff goes from max to min! ie: small bright - large dull
|
||
|
|
||
|
ADSP_InterpParam( pnew, pmax, pmin, PRC_RVA, iskip, rva_icutoff, pa->reflectivity, ADSP_REFLECTIVITY_MAX , 0);
|
||
|
|
||
|
// don't interpolate: fparallel, ftaps
|
||
|
|
||
|
// DLY
|
||
|
|
||
|
// directly set delay value from pa->length if pmin or pmax value is < 0
|
||
|
|
||
|
l = clamp((pa->length * 2.0 / 12.0), 14.0, 500.0);
|
||
|
w = clamp((pa->width * 2.0 / 12.0), 14.0, 500.0);
|
||
|
|
||
|
ADSP_SetParamIfNegative( pnew, pmin, pmax, PRC_DLY, iskip, dly_idelay, pa->len, ADSP_LENGTH_MAX, 1, l);
|
||
|
|
||
|
// interpolate feedback, gain, based on max size (length)
|
||
|
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_DLY, iskip, dly_ifeedback, pa->len, ADSP_LENGTH_MAX , 0);
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_DLY, iskip, dly_igain, pa->len, ADSP_LENGTH_MAX , 0);
|
||
|
|
||
|
// directly set tap value from pa->width if pmin or pmax value is < 0
|
||
|
|
||
|
ADSP_SetParamIfNegative( pnew, pmin, pmax, PRC_DLY, iskip, dly_itap1, pa->len, ADSP_LENGTH_MAX, 1, w);
|
||
|
ADSP_SetParamIfNegative( pnew, pmin, pmax, PRC_DLY, iskip, dly_itap2, pa->len, ADSP_LENGTH_MAX, 1, l);
|
||
|
ADSP_SetParamIfNegative( pnew, pmin, pmax, PRC_DLY, iskip, dly_itap3, pa->len, ADSP_LENGTH_MAX, 1, l);
|
||
|
|
||
|
// interpolate cutoff and qwidth based on reflectivity NOTE: this can affect gain!
|
||
|
// NOTE: cutoff goes from max to min! ie: small bright - large dull
|
||
|
|
||
|
ADSP_InterpParam( pnew, pmax, pmin, PRC_DLY, iskip, dly_icutoff, pa->len, ADSP_LENGTH_MAX , 0);
|
||
|
ADSP_InterpParam( pnew, pmax, pmin, PRC_DLY, iskip, dly_iqwidth, pa->len, ADSP_LENGTH_MAX , 0);
|
||
|
|
||
|
// interpolate all other parameters for all other processor types based on size
|
||
|
|
||
|
// PRC_MDY, PRC_AMP, PRC_FLT, PTC, CRS, ENV, EFO, LFO
|
||
|
|
||
|
for (i = 0; i < mdy_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_MDY, iskip, i, pa->len, ADSP_LENGTH_MAX , 0);
|
||
|
|
||
|
for (i = 0; i < amp_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_AMP, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
for (i = 0; i < flt_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_FLT, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
for (i = 0; i < ptc_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_PTC, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
for (i = 0; i < crs_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_CRS, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
for (i = 0; i < env_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_ENV, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
for (i = 0; i < efo_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_EFO, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
for (i = 0; i < lfo_cparam; i++)
|
||
|
ADSP_InterpParam( pnew, pmin, pmax, PRC_LFO, iskip, i, pa->size, ADSP_SIZE_MAX , 0);
|
||
|
|
||
|
}
|
||
|
|
||
|
// these convars store the index to the first preset for each shape type in dsp_presets.txt
|
||
|
|
||
|
ConVar adsp_room_min ("adsp_room_min", "102");
|
||
|
ConVar adsp_duct_min ("adsp_duct_min", "106");
|
||
|
ConVar adsp_hall_min ("adsp_hall_min", "110");
|
||
|
ConVar adsp_tunnel_min ("adsp_tunnel_min", "114");
|
||
|
ConVar adsp_street_min ("adsp_street_min", "118");
|
||
|
ConVar adsp_alley_min ("adsp_alley_min", "122");
|
||
|
ConVar adsp_courtyard_min ("adsp_courtyard_min", "126");
|
||
|
ConVar adsp_openspace_min ("adsp_openspace_min", "130");
|
||
|
ConVar adsp_openwall_min ("adsp_openwall_min", "130");
|
||
|
ConVar adsp_openstreet_min ("adsp_openstreet_min", "118");
|
||
|
ConVar adsp_opencourtyard_min ("adsp_opencourtyard_min", "126");
|
||
|
|
||
|
// given room parameters, construct and return a dsp preset representing the room.
|
||
|
// bskyabove, width, length, height, fdiffusion, freflectivity are all passed-in room parameters
|
||
|
// psurf_refl is a passed-in array of reflectivity values for 6 surfaces
|
||
|
// inode is the location within g_psettemplates[] that the dsp preset will be constructed (inode = dsp preset#)
|
||
|
// cnode should always = DSP_CAUTO_PRESETS
|
||
|
// returns idsp preset.
|
||
|
|
||
|
int DSP_ConstructPreset( bool bskyabove, int width, int length, int height, float fdiffusion, float freflectivity, float *psurf_refl, int inode, int cnodes )
|
||
|
{
|
||
|
auto_params_t ap;
|
||
|
auto_params_t *pa;
|
||
|
|
||
|
pset_t new_pset; // preset
|
||
|
pset_t pset_min;
|
||
|
pset_t pset_max;
|
||
|
|
||
|
int ipreset;
|
||
|
int ipset_min;
|
||
|
int ipset_max;
|
||
|
|
||
|
if (inode >= DSP_CAUTO_PRESETS)
|
||
|
{
|
||
|
Assert(false); // check DAS_CNODES == DSP_CAUTO_PRESETS!!!
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
// fill parameter struct
|
||
|
|
||
|
ap.bskyabove = bskyabove;
|
||
|
ap.width = width;
|
||
|
ap.length = length;
|
||
|
ap.height = height;
|
||
|
ap.fdiffusion = fdiffusion;
|
||
|
ap.freflectivity = freflectivity;
|
||
|
|
||
|
for (int i = 0; i < 6; i++)
|
||
|
ap.surface_refl[i] = psurf_refl[i];
|
||
|
|
||
|
if (ap.bskyabove)
|
||
|
ap.surface_refl[4] = 0.0;
|
||
|
|
||
|
// select shape, size based on params
|
||
|
|
||
|
ADSP_GetAutoShape( &ap );
|
||
|
|
||
|
// set up min/max presets based on shape
|
||
|
|
||
|
switch ( ap.shape )
|
||
|
{
|
||
|
default:
|
||
|
case ADSP_ROOM: ipset_min = adsp_room_min.GetInt(); break;
|
||
|
case ADSP_DUCT: ipset_min = adsp_duct_min.GetInt(); break;
|
||
|
case ADSP_HALL: ipset_min = adsp_hall_min.GetInt(); break;
|
||
|
case ADSP_TUNNEL: ipset_min = adsp_tunnel_min.GetInt(); break;
|
||
|
case ADSP_STREET: ipset_min = adsp_street_min.GetInt(); break;
|
||
|
case ADSP_ALLEY: ipset_min = adsp_alley_min.GetInt(); break;
|
||
|
case ADSP_COURTYARD: ipset_min = adsp_courtyard_min.GetInt(); break;
|
||
|
case ADSP_OPEN_SPACE: ipset_min = adsp_openspace_min.GetInt(); break;
|
||
|
case ADSP_OPEN_WALL: ipset_min = adsp_openwall_min.GetInt(); break;
|
||
|
case ADSP_OPEN_STREET: ipset_min = adsp_openstreet_min.GetInt(); break;
|
||
|
case ADSP_OPEN_COURTYARD: ipset_min = adsp_opencourtyard_min.GetInt(); break;
|
||
|
}
|
||
|
|
||
|
// presets in dsp_presets.txt are ordered as:
|
||
|
|
||
|
// <shape><empty><min>
|
||
|
// <shape><empty><max>
|
||
|
// <shape><diffuse><min>
|
||
|
// <shape><diffuse><max>
|
||
|
pa = ≈
|
||
|
if ( ADSP_IsDiffuse(pa) )
|
||
|
ipset_min += 2;
|
||
|
|
||
|
ipset_max = ipset_min + 1;
|
||
|
|
||
|
pset_min = g_psettemplates[ipset_min];
|
||
|
pset_max = g_psettemplates[ipset_max];
|
||
|
|
||
|
// given min and max preset and auto parameters, create new preset
|
||
|
|
||
|
// interpolate between 1st instances of each processor type (ie: PRC_DLY) appearing in preset
|
||
|
|
||
|
ADSP_InterpolatePreset( &new_pset, &pset_min, &pset_max, &ap, 0 );
|
||
|
|
||
|
// interpolate between 2nd instances of each processor type (ie: PRC_DLY) appearing in preset
|
||
|
|
||
|
ADSP_InterpolatePreset( &new_pset, &pset_min, &pset_max, &ap, 1 );
|
||
|
|
||
|
// copy constructed preset back into node's template location
|
||
|
|
||
|
ipreset = DSP_AUTO_BASE + inode;
|
||
|
|
||
|
g_psettemplates[ipreset] = new_pset;
|
||
|
|
||
|
return ipreset;
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////
|
||
|
// Helpers: called only from DSP_Process
|
||
|
///////////////////////////////////////
|
||
|
|
||
|
|
||
|
// return true if batch processing version of preset exists
|
||
|
|
||
|
inline bool FBatchPreset( pset_t *ppset )
|
||
|
{
|
||
|
|
||
|
switch (ppset->type)
|
||
|
{
|
||
|
case PSET_LINEAR:
|
||
|
return true;
|
||
|
case PSET_SIMPLE:
|
||
|
return true;
|
||
|
default:
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Helper: called only from DSP_Process
|
||
|
// mix front stereo buffer to mono buffer, apply dsp fx
|
||
|
|
||
|
inline void DSP_ProcessStereoToMono(dsp_t *pdsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, int sampleCount, bool bcrossfading )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbfront; // pointer to buffer of front stereo samples to process
|
||
|
int count = sampleCount;
|
||
|
int av;
|
||
|
int x;
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
{
|
||
|
if ( !pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
if ( FBatchPreset(pdsp->ppset[0]))
|
||
|
{
|
||
|
// convert Stereo to Mono in place, then batch process fx: perf KDB
|
||
|
|
||
|
// front->left + front->right / 2 into front->left, front->right duplicated.
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
pbf->left = (pbf->left + pbf->right) >> 1;
|
||
|
pbf++;
|
||
|
}
|
||
|
|
||
|
// process left (mono), duplicate output into right
|
||
|
|
||
|
PSET_GetNextN( pdsp->ppset[0], pbfront, sampleCount, OP_LEFT_DUPLICATE);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// avg left and right -> mono fx -> duplcate out left and right
|
||
|
while ( count-- )
|
||
|
{
|
||
|
av = ( ( pbf->left + pbf->right ) >> 1 );
|
||
|
x = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
x = CLIP_DSP( x );
|
||
|
pbf->left = pbf->right = x;
|
||
|
pbf++;
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// crossfading to current preset from previous preset
|
||
|
|
||
|
if ( bcrossfading )
|
||
|
{
|
||
|
int r;
|
||
|
int fl;
|
||
|
int fr;
|
||
|
int flp;
|
||
|
int frp;
|
||
|
int xf_fl;
|
||
|
int xf_fr;
|
||
|
bool bexp = pdsp->bexpfade;
|
||
|
bool bfadetostereo = (pdsp->ipset == 0);
|
||
|
bool bfadefromstereo = (pdsp->ipsetprev == 0);
|
||
|
|
||
|
Assert ( !(bfadetostereo && bfadefromstereo) ); // don't call if ipset & ipsetprev both 0!
|
||
|
|
||
|
if ( bfadetostereo || bfadefromstereo )
|
||
|
{
|
||
|
// special case if fading to or from preset 0, stereo passthrough
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
av = ( ( pbf->left + pbf->right ) >> 1 );
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
if ( pdsp->ipset )
|
||
|
{
|
||
|
fl = fr = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fl = pbf->left;
|
||
|
fr = pbf->right;
|
||
|
}
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
if ( pdsp->ipsetprev )
|
||
|
{
|
||
|
frp = flp = PSET_GetNext( pdsp->ppsetprev[0], av );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
flp = pbf->left;
|
||
|
frp = pbf->right;
|
||
|
}
|
||
|
|
||
|
fl = CLIP_DSP(fl);
|
||
|
fr = CLIP_DSP(fr);
|
||
|
flp = CLIP_DSP(flp);
|
||
|
frp = CLIP_DSP(frp);
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
|
||
|
pbf->left = xf_fl; // crossfaded front left, duplicate in right channel
|
||
|
pbf->right = xf_fr;
|
||
|
|
||
|
pbf++;
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// crossfade mono to mono preset
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
av = ( ( pbf->left + pbf->right ) >> 1 );
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = PSET_GetNext( pdsp->ppsetprev[0], av );
|
||
|
|
||
|
fl = CLIP_DSP(fl);
|
||
|
flp = CLIP_DSP(flp);
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
|
||
|
if (!bexp)
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
else
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
|
||
|
pbf->left = xf_fl; // crossfaded front left, duplicate in right channel
|
||
|
pbf->right = xf_fl;
|
||
|
|
||
|
pbf++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Helper: called only from DSP_Process
|
||
|
// DSP_Process stereo in to stereo out (if more than 2 procs, ignore them)
|
||
|
|
||
|
inline void DSP_ProcessStereoToStereo(dsp_t *pdsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, int sampleCount, bool bcrossfading )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbfront; // pointer to buffer of front stereo samples to process
|
||
|
int count = sampleCount;
|
||
|
int fl, fr;
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
{
|
||
|
|
||
|
if ( !pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
if ( FBatchPreset(pdsp->ppset[0]) && FBatchPreset(pdsp->ppset[1]) )
|
||
|
{
|
||
|
|
||
|
// process left & right
|
||
|
|
||
|
PSET_GetNextN( pdsp->ppset[0], pbfront, sampleCount, OP_LEFT );
|
||
|
PSET_GetNextN( pdsp->ppset[1], pbfront, sampleCount, OP_RIGHT );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// left -> left fx, right -> right fx
|
||
|
while ( count-- )
|
||
|
{
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], pbf->left );
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], pbf->right );
|
||
|
|
||
|
fl = CLIP_DSP( fl );
|
||
|
fr = CLIP_DSP( fr );
|
||
|
|
||
|
pbf->left = fl;
|
||
|
pbf->right = fr;
|
||
|
pbf++;
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// crossfading to current preset from previous preset
|
||
|
|
||
|
if ( bcrossfading )
|
||
|
{
|
||
|
int r;
|
||
|
int flp, frp;
|
||
|
int xf_fl, xf_fr;
|
||
|
bool bexp = pdsp->bexpfade;
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
// get current preset values
|
||
|
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], pbf->left );
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], pbf->right );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = PSET_GetNext( pdsp->ppsetprev[0], pbf->left );
|
||
|
frp = PSET_GetNext( pdsp->ppsetprev[1], pbf->right );
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
fl = CLIP_DSP( fl );
|
||
|
fr = CLIP_DSP( fr );
|
||
|
flp = CLIP_DSP( flp );
|
||
|
frp = CLIP_DSP( frp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r);
|
||
|
}
|
||
|
|
||
|
pbf->left = xf_fl; // crossfaded front left
|
||
|
pbf->right = xf_fr;
|
||
|
|
||
|
pbf++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Helper: called only from DSP_Process
|
||
|
// DSP_Process quad in to mono out (front left = front right)
|
||
|
|
||
|
inline void DSP_ProcessQuadToMono(dsp_t *pdsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, int sampleCount, bool bcrossfading )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbfront; // pointer to buffer of front stereo samples to process
|
||
|
portable_samplepair_t *pbr = pbrear; // pointer to buffer of rear stereo samples to process
|
||
|
int count = sampleCount;
|
||
|
int x;
|
||
|
int av;
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
{
|
||
|
if ( !pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
if ( FBatchPreset(pdsp->ppset[0]) )
|
||
|
{
|
||
|
|
||
|
// convert Quad to Mono in place, then batch process fx: perf KDB
|
||
|
|
||
|
// left front + rear -> left, right front + rear -> right
|
||
|
while ( count-- )
|
||
|
{
|
||
|
pbf->left = ((pbf->left + pbf->right + pbr->left + pbr->right) >> 2);
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
|
||
|
// process left (mono), duplicate into right
|
||
|
|
||
|
PSET_GetNextN( pdsp->ppset[0], pbfront, sampleCount, OP_LEFT_DUPLICATE);
|
||
|
|
||
|
// copy processed front to rear
|
||
|
|
||
|
count = sampleCount;
|
||
|
|
||
|
pbf = pbfront;
|
||
|
pbr = pbrear;
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
pbr->left = pbf->left;
|
||
|
pbr->right = pbf->right;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// avg fl,fr,rl,rr into mono fx, duplicate on all channels
|
||
|
while ( count-- )
|
||
|
{
|
||
|
av = ((pbf->left + pbf->right + pbr->left + pbr->right) >> 2);
|
||
|
x = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
x = CLIP_DSP( x );
|
||
|
pbr->left = pbr->right = pbf->left = pbf->right = x;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( bcrossfading )
|
||
|
{
|
||
|
int r;
|
||
|
int fl, fr, rl, rr;
|
||
|
int flp, frp, rlp, rrp;
|
||
|
int xf_fl, xf_fr, xf_rl, xf_rr;
|
||
|
bool bexp = pdsp->bexpfade;
|
||
|
bool bfadetoquad = (pdsp->ipset == 0);
|
||
|
bool bfadefromquad = (pdsp->ipsetprev == 0);
|
||
|
|
||
|
if ( bfadetoquad || bfadefromquad )
|
||
|
{
|
||
|
// special case if previous or current preset is 0 (quad passthrough)
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
av = ((pbf->left + pbf->right + pbr->left + pbr->right) >> 2);
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
// current preset is 0, which implies fading to passthrough quad output
|
||
|
// need to fade from mono to quad
|
||
|
|
||
|
if ( pdsp->ipset )
|
||
|
{
|
||
|
rl = rr = fl = fr = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fl = pbf->left;
|
||
|
fr = pbf->right;
|
||
|
rl = pbr->left;
|
||
|
rr = pbr->right;
|
||
|
}
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
if ( pdsp->ipsetprev )
|
||
|
{
|
||
|
rrp = rlp = frp = flp = PSET_GetNext( pdsp->ppsetprev[0], av );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
flp = pbf->left;
|
||
|
frp = pbf->right;
|
||
|
rlp = pbr->left;
|
||
|
rrp = pbr->right;
|
||
|
}
|
||
|
|
||
|
fl = CLIP_DSP(fl);
|
||
|
fr = CLIP_DSP(fr);
|
||
|
flp = CLIP_DSP(flp);
|
||
|
frp = CLIP_DSP(frp);
|
||
|
rl = CLIP_DSP(rl);
|
||
|
rr = CLIP_DSP(rr);
|
||
|
rlp = CLIP_DSP(rlp);
|
||
|
rrp = CLIP_DSP(rrp);
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r); // crossfade front left previous to front left
|
||
|
xf_rl = XFADE(rl, rlp, r); // crossfade front left previous to front left
|
||
|
xf_rr = XFADE(rr, rrp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r); // crossfade front left previous to front left
|
||
|
xf_rl = XFADE_EXP(rl, rlp, r); // crossfade front left previous to front left
|
||
|
xf_rr = XFADE_EXP(rr, rrp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
|
||
|
pbf->left = xf_fl;
|
||
|
pbf->right = xf_fr;
|
||
|
pbr->left = xf_rl;
|
||
|
pbr->right = xf_rr;
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
|
||
|
av = ((pbf->left + pbf->right + pbr->left + pbr->right) >> 2);
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = PSET_GetNext( pdsp->ppsetprev[0], av );
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
fl = CLIP_DSP( fl );
|
||
|
flp = CLIP_DSP( flp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
if (!bexp)
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
else
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
|
||
|
pbf->left = xf_fl; // crossfaded front left, duplicated to all channels
|
||
|
pbf->right = xf_fl;
|
||
|
pbr->left = xf_fl;
|
||
|
pbr->right = xf_fl;
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Helper: called only from DSP_Process
|
||
|
// DSP_Process quad in to stereo out (preserve stereo spatialization, throw away front/rear)
|
||
|
|
||
|
inline void DSP_ProcessQuadToStereo(dsp_t *pdsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, int sampleCount, bool bcrossfading )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbfront; // pointer to buffer of front stereo samples to process
|
||
|
portable_samplepair_t *pbr = pbrear; // pointer to buffer of rear stereo samples to process
|
||
|
int count = sampleCount;
|
||
|
int fl, fr;
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
{
|
||
|
if ( !pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
if ( FBatchPreset(pdsp->ppset[0]) && FBatchPreset(pdsp->ppset[1]) )
|
||
|
{
|
||
|
|
||
|
// convert Quad to Stereo in place, then batch process fx: perf KDB
|
||
|
|
||
|
// left front + rear -> left, right front + rear -> right
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
pbf->left = (pbf->left + pbr->left) >> 1;
|
||
|
pbf->right = (pbf->right + pbr->right) >> 1;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
|
||
|
// process left & right
|
||
|
|
||
|
PSET_GetNextN( pdsp->ppset[0], pbfront, sampleCount, OP_LEFT);
|
||
|
PSET_GetNextN( pdsp->ppset[1], pbfront, sampleCount, OP_RIGHT );
|
||
|
|
||
|
// copy processed front to rear
|
||
|
|
||
|
count = sampleCount;
|
||
|
|
||
|
pbf = pbfront;
|
||
|
pbr = pbrear;
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
pbr->left = pbf->left;
|
||
|
pbr->right = pbf->right;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// left front + rear -> left fx, right front + rear -> right fx
|
||
|
while ( count-- )
|
||
|
{
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], (pbf->left + pbr->left) >> 1);
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], (pbf->right + pbr->right) >> 1);
|
||
|
fl = CLIP_DSP( fl );
|
||
|
fr = CLIP_DSP( fr );
|
||
|
|
||
|
pbr->left = pbf->left = fl;
|
||
|
pbr->right = pbf->right = fr;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// crossfading to current preset from previous preset
|
||
|
|
||
|
if ( bcrossfading )
|
||
|
{
|
||
|
int r;
|
||
|
int rl, rr;
|
||
|
int flp, frp, rlp, rrp;
|
||
|
int xf_fl, xf_fr, xf_rl, xf_rr;
|
||
|
int avl, avr;
|
||
|
bool bexp = pdsp->bexpfade;
|
||
|
bool bfadetoquad = (pdsp->ipset == 0);
|
||
|
bool bfadefromquad = (pdsp->ipsetprev == 0);
|
||
|
|
||
|
if ( bfadetoquad || bfadefromquad )
|
||
|
{
|
||
|
// special case if previous or current preset is 0 (quad passthrough)
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
avl = (pbf->left + pbr->left) >> 1;
|
||
|
avr = (pbf->right + pbr->right) >> 1;
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
// current preset is 0, which implies fading to passthrough quad output
|
||
|
// need to fade from stereo to quad
|
||
|
|
||
|
if ( pdsp->ipset )
|
||
|
{
|
||
|
rl = fl = PSET_GetNext( pdsp->ppset[0], avl );
|
||
|
rr = fr = PSET_GetNext( pdsp->ppset[0], avr );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fl = pbf->left;
|
||
|
fr = pbf->right;
|
||
|
rl = pbr->left;
|
||
|
rr = pbr->right;
|
||
|
}
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
if ( pdsp->ipsetprev )
|
||
|
{
|
||
|
rlp = flp = PSET_GetNext( pdsp->ppsetprev[0], avl );
|
||
|
rrp = frp = PSET_GetNext( pdsp->ppsetprev[0], avr );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
flp = pbf->left;
|
||
|
frp = pbf->right;
|
||
|
rlp = pbr->left;
|
||
|
rrp = pbr->right;
|
||
|
}
|
||
|
|
||
|
fl = CLIP_DSP(fl);
|
||
|
fr = CLIP_DSP(fr);
|
||
|
flp = CLIP_DSP(flp);
|
||
|
frp = CLIP_DSP(frp);
|
||
|
rl = CLIP_DSP(rl);
|
||
|
rr = CLIP_DSP(rr);
|
||
|
rlp = CLIP_DSP(rlp);
|
||
|
rrp = CLIP_DSP(rrp);
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r); // crossfade front left previous to front left
|
||
|
xf_rl = XFADE(rl, rlp, r); // crossfade front left previous to front left
|
||
|
xf_rr = XFADE(rr, rrp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r); // crossfade front left previous to front left
|
||
|
xf_rl = XFADE_EXP(rl, rlp, r); // crossfade front left previous to front left
|
||
|
xf_rr = XFADE_EXP(rr, rrp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
|
||
|
pbf->left = xf_fl;
|
||
|
pbf->right = xf_fr;
|
||
|
pbr->left = xf_rl;
|
||
|
pbr->right = xf_rr;
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
avl = (pbf->left + pbr->left) >> 1;
|
||
|
avr = (pbf->right + pbr->right) >> 1;
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], avl );
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], avr );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = PSET_GetNext( pdsp->ppsetprev[0], avl );
|
||
|
frp = PSET_GetNext( pdsp->ppsetprev[1], avr );
|
||
|
|
||
|
|
||
|
fl = CLIP_DSP( fl );
|
||
|
fr = CLIP_DSP( fr );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = CLIP_DSP( flp );
|
||
|
frp = CLIP_DSP( frp );
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r);
|
||
|
}
|
||
|
|
||
|
pbf->left = xf_fl; // crossfaded front left
|
||
|
pbf->right = xf_fr;
|
||
|
|
||
|
pbr->left = xf_fl; // duplicate front channel to rear channel
|
||
|
pbr->right = xf_fr;
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Helper: called only from DSP_Process
|
||
|
// DSP_Process quad in to quad out
|
||
|
|
||
|
inline void DSP_ProcessQuadToQuad(dsp_t *pdsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, int sampleCount, bool bcrossfading )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbfront; // pointer to buffer of front stereo samples to process
|
||
|
portable_samplepair_t *pbr = pbrear; // pointer to buffer of rear stereo samples to process
|
||
|
int count = sampleCount;
|
||
|
int fl, fr, rl, rr;
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
{
|
||
|
if ( !pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
// each channel gets its own processor
|
||
|
|
||
|
if ( FBatchPreset(pdsp->ppset[0]) && FBatchPreset(pdsp->ppset[1]) && FBatchPreset(pdsp->ppset[2]) && FBatchPreset(pdsp->ppset[3]))
|
||
|
{
|
||
|
// batch process fx front & rear, left & right: perf KDB
|
||
|
|
||
|
PSET_GetNextN( pdsp->ppset[0], pbfront, sampleCount, OP_LEFT);
|
||
|
PSET_GetNextN( pdsp->ppset[1], pbfront, sampleCount, OP_RIGHT );
|
||
|
PSET_GetNextN( pdsp->ppset[2], pbrear, sampleCount, OP_LEFT );
|
||
|
PSET_GetNextN( pdsp->ppset[3], pbrear, sampleCount, OP_RIGHT );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
while ( count-- )
|
||
|
{
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], pbf->left );
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], pbf->right );
|
||
|
rl = PSET_GetNext( pdsp->ppset[2], pbr->left );
|
||
|
rr = PSET_GetNext( pdsp->ppset[3], pbr->right );
|
||
|
|
||
|
pbf->left = CLIP_DSP( fl );
|
||
|
pbf->right = CLIP_DSP( fr );
|
||
|
pbr->left = CLIP_DSP( rl );
|
||
|
pbr->right = CLIP_DSP( rr );
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// crossfading to current preset from previous preset
|
||
|
|
||
|
if ( bcrossfading )
|
||
|
{
|
||
|
int r;
|
||
|
int flp, frp, rlp, rrp;
|
||
|
int xf_fl, xf_fr, xf_rl, xf_rr;
|
||
|
bool bexp = pdsp->bexpfade;
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
// get current preset values
|
||
|
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], pbf->left );
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], pbf->right );
|
||
|
rl = PSET_GetNext( pdsp->ppset[2], pbr->left );
|
||
|
rr = PSET_GetNext( pdsp->ppset[3], pbr->right );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = PSET_GetNext( pdsp->ppsetprev[0], pbf->left );
|
||
|
frp = PSET_GetNext( pdsp->ppsetprev[1], pbf->right );
|
||
|
rlp = PSET_GetNext( pdsp->ppsetprev[2], pbr->left );
|
||
|
rrp = PSET_GetNext( pdsp->ppsetprev[3], pbr->right );
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r);
|
||
|
xf_rl = XFADE(rl, rlp, r);
|
||
|
xf_rr = XFADE(rr, rrp, r);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r);
|
||
|
xf_rl = XFADE_EXP(rl, rlp, r);
|
||
|
xf_rr = XFADE_EXP(rr, rrp, r);
|
||
|
}
|
||
|
|
||
|
pbf->left = CLIP_DSP(xf_fl); // crossfaded front left
|
||
|
pbf->right = CLIP_DSP(xf_fr);
|
||
|
pbr->left = CLIP_DSP(xf_rl);
|
||
|
pbr->right = CLIP_DSP(xf_rr);
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// Helper: called only from DSP_Process
|
||
|
// DSP_Process quad + center in to mono out (front left = front right)
|
||
|
|
||
|
inline void DSP_Process5To1(dsp_t *pdsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, portable_samplepair_t *pbcenter, int sampleCount, bool bcrossfading )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbfront; // pointer to buffer of front stereo samples to process
|
||
|
portable_samplepair_t *pbr = pbrear; // pointer to buffer of rear stereo samples to process
|
||
|
portable_samplepair_t *pbc = pbcenter; // pointer to buffer of center mono samples to process
|
||
|
int count = sampleCount;
|
||
|
int x;
|
||
|
int av;
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
{
|
||
|
if ( !pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
if ( FBatchPreset(pdsp->ppset[0]) )
|
||
|
{
|
||
|
|
||
|
// convert Quad + Center to Mono in place, then batch process fx: perf KDB
|
||
|
|
||
|
// left front + rear -> left, right front + rear -> right
|
||
|
while ( count-- )
|
||
|
{
|
||
|
// pbf->left = ((pbf->left + pbf->right + pbr->left + pbr->right + pbc->left) / 5);
|
||
|
|
||
|
av = (pbf->left + pbf->right + pbr->left + pbr->right + pbc->left) * 51; // 51/255 = 1/5
|
||
|
av >>= 8;
|
||
|
pbf->left = av;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
pbc++;
|
||
|
}
|
||
|
|
||
|
// process left (mono), duplicate into right
|
||
|
|
||
|
PSET_GetNextN( pdsp->ppset[0], pbfront, sampleCount, OP_LEFT_DUPLICATE);
|
||
|
|
||
|
// copy processed front to rear & center
|
||
|
|
||
|
count = sampleCount;
|
||
|
|
||
|
pbf = pbfront;
|
||
|
pbr = pbrear;
|
||
|
pbc = pbcenter;
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
pbr->left = pbf->left;
|
||
|
pbr->right = pbf->right;
|
||
|
pbc->left = pbf->left;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
pbc++;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// avg fl,fr,rl,rr,fc into mono fx, duplicate on all channels
|
||
|
while ( count-- )
|
||
|
{
|
||
|
// av = ((pbf->left + pbf->right + pbr->left + pbr->right + pbc->left) / 5);
|
||
|
av = (pbf->left + pbf->right + pbr->left + pbr->right + pbc->left) * 51; // 51/255 = 1/5
|
||
|
av >>= 8;
|
||
|
x = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
x = CLIP_DSP( x );
|
||
|
pbr->left = pbr->right = pbf->left = pbf->right = pbc->left = x;
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
pbc++;
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( bcrossfading )
|
||
|
{
|
||
|
int r;
|
||
|
int fl, fr, rl, rr, fc;
|
||
|
int flp, frp, rlp, rrp, fcp;
|
||
|
int xf_fl, xf_fr, xf_rl, xf_rr, xf_fc;
|
||
|
bool bexp = pdsp->bexpfade;
|
||
|
bool bfadetoquad = (pdsp->ipset == 0);
|
||
|
bool bfadefromquad = (pdsp->ipsetprev == 0);
|
||
|
|
||
|
if ( bfadetoquad || bfadefromquad )
|
||
|
{
|
||
|
// special case if previous or current preset is 0 (quad passthrough)
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
// av = ((pbf->left + pbf->right + pbr->left + pbr->right) >> 2);
|
||
|
|
||
|
av = (pbf->left + pbf->right + pbr->left + pbr->right + pbc->left) * 51; // 51/255 = 1/5
|
||
|
av >>= 8;
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
// current preset is 0, which implies fading to passthrough quad output
|
||
|
// need to fade from mono to quad
|
||
|
|
||
|
if ( pdsp->ipset )
|
||
|
{
|
||
|
fc = rl = rr = fl = fr = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fl = pbf->left;
|
||
|
fr = pbf->right;
|
||
|
rl = pbr->left;
|
||
|
rr = pbr->right;
|
||
|
fc = pbc->left;
|
||
|
}
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
if ( pdsp->ipsetprev )
|
||
|
{
|
||
|
fcp = rrp = rlp = frp = flp = PSET_GetNext( pdsp->ppsetprev[0], av );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
flp = pbf->left;
|
||
|
frp = pbf->right;
|
||
|
rlp = pbr->left;
|
||
|
rrp = pbr->right;
|
||
|
fcp = pbc->left;
|
||
|
}
|
||
|
|
||
|
fl = CLIP_DSP(fl);
|
||
|
fr = CLIP_DSP(fr);
|
||
|
flp = CLIP_DSP(flp);
|
||
|
frp = CLIP_DSP(frp);
|
||
|
rl = CLIP_DSP(rl);
|
||
|
rr = CLIP_DSP(rr);
|
||
|
rlp = CLIP_DSP(rlp);
|
||
|
rrp = CLIP_DSP(rrp);
|
||
|
fc = CLIP_DSP(fc);
|
||
|
fcp = CLIP_DSP(fcp);
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r); // crossfade front left previous to front left
|
||
|
xf_rl = XFADE(rl, rlp, r); // crossfade front left previous to front left
|
||
|
xf_rr = XFADE(rr, rrp, r); // crossfade front left previous to front left
|
||
|
xf_fc = XFADE(fc, fcp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r); // crossfade front left previous to front left
|
||
|
xf_rl = XFADE_EXP(rl, rlp, r); // crossfade front left previous to front left
|
||
|
xf_rr = XFADE_EXP(rr, rrp, r); // crossfade front left previous to front left
|
||
|
xf_fc = XFADE_EXP(fc, fcp, r); // crossfade front left previous to front left
|
||
|
}
|
||
|
|
||
|
pbf->left = xf_fl;
|
||
|
pbf->right = xf_fr;
|
||
|
pbr->left = xf_rl;
|
||
|
pbr->right = xf_rr;
|
||
|
pbc->left = xf_fc;
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
pbc++;
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
|
||
|
// av = ((pbf->left + pbf->right + pbr->left + pbr->right) >> 2);
|
||
|
av = (pbf->left + pbf->right + pbr->left + pbr->right + pbc->left) * 51; // 51/255 = 1/5
|
||
|
av >>= 8;
|
||
|
|
||
|
// get current preset values
|
||
|
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], av );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = PSET_GetNext( pdsp->ppsetprev[0], av );
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
fl = CLIP_DSP( fl );
|
||
|
flp = CLIP_DSP( flp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
if (!bexp)
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
else
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
|
||
|
pbf->left = xf_fl; // crossfaded front left, duplicated to all channels
|
||
|
pbf->right = xf_fl;
|
||
|
pbr->left = xf_fl;
|
||
|
pbr->right = xf_fl;
|
||
|
pbc->left = xf_fl;
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
pbc++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Helper: called only from DSP_Process
|
||
|
// DSP_Process quad + center in to quad + center out
|
||
|
|
||
|
inline void DSP_Process5To5(dsp_t *pdsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, portable_samplepair_t *pbcenter, int sampleCount, bool bcrossfading )
|
||
|
{
|
||
|
portable_samplepair_t *pbf = pbfront; // pointer to buffer of front stereo samples to process
|
||
|
portable_samplepair_t *pbr = pbrear; // pointer to buffer of rear stereo samples to process
|
||
|
portable_samplepair_t *pbc = pbcenter; // pointer to buffer of center mono samples to process
|
||
|
|
||
|
int count = sampleCount;
|
||
|
int fl, fr, rl, rr, fc;
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
{
|
||
|
if ( !pdsp->ipset )
|
||
|
return;
|
||
|
|
||
|
// each channel gets its own processor
|
||
|
|
||
|
if ( FBatchPreset(pdsp->ppset[0]) && FBatchPreset(pdsp->ppset[1]) && FBatchPreset(pdsp->ppset[2]) && FBatchPreset(pdsp->ppset[3]))
|
||
|
{
|
||
|
// batch process fx front & rear, left & right: perf KDB
|
||
|
|
||
|
PSET_GetNextN( pdsp->ppset[0], pbfront, sampleCount, OP_LEFT);
|
||
|
PSET_GetNextN( pdsp->ppset[1], pbfront, sampleCount, OP_RIGHT );
|
||
|
PSET_GetNextN( pdsp->ppset[2], pbrear, sampleCount, OP_LEFT );
|
||
|
PSET_GetNextN( pdsp->ppset[3], pbrear, sampleCount, OP_RIGHT );
|
||
|
PSET_GetNextN( pdsp->ppset[4], pbcenter, sampleCount, OP_LEFT );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
while ( count-- )
|
||
|
{
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], pbf->left );
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], pbf->right );
|
||
|
rl = PSET_GetNext( pdsp->ppset[2], pbr->left );
|
||
|
rr = PSET_GetNext( pdsp->ppset[3], pbr->right );
|
||
|
fc = PSET_GetNext( pdsp->ppset[4], pbc->left );
|
||
|
|
||
|
pbf->left = CLIP_DSP( fl );
|
||
|
pbf->right = CLIP_DSP( fr );
|
||
|
pbr->left = CLIP_DSP( rl );
|
||
|
pbr->right = CLIP_DSP( rr );
|
||
|
pbc->left = CLIP_DSP( fc );
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
pbc++;
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// crossfading to current preset from previous preset
|
||
|
|
||
|
if ( bcrossfading )
|
||
|
{
|
||
|
int r;
|
||
|
int flp, frp, rlp, rrp, fcp;
|
||
|
int xf_fl, xf_fr, xf_rl, xf_rr, xf_fc;
|
||
|
bool bexp = pdsp->bexpfade;
|
||
|
|
||
|
while ( count-- )
|
||
|
{
|
||
|
// get current preset values
|
||
|
|
||
|
fl = PSET_GetNext( pdsp->ppset[0], pbf->left );
|
||
|
fr = PSET_GetNext( pdsp->ppset[1], pbf->right );
|
||
|
rl = PSET_GetNext( pdsp->ppset[2], pbr->left );
|
||
|
rr = PSET_GetNext( pdsp->ppset[3], pbr->right );
|
||
|
fc = PSET_GetNext( pdsp->ppset[4], pbc->left );
|
||
|
|
||
|
// get previous preset values
|
||
|
|
||
|
flp = PSET_GetNext( pdsp->ppsetprev[0], pbf->left );
|
||
|
frp = PSET_GetNext( pdsp->ppsetprev[1], pbf->right );
|
||
|
rlp = PSET_GetNext( pdsp->ppsetprev[2], pbr->left );
|
||
|
rrp = PSET_GetNext( pdsp->ppsetprev[3], pbr->right );
|
||
|
fcp = PSET_GetNext( pdsp->ppsetprev[4], pbc->left );
|
||
|
|
||
|
// get current ramp value
|
||
|
|
||
|
r = RMP_GetNext( &pdsp->xramp );
|
||
|
|
||
|
// crossfade from previous to current preset
|
||
|
if (!bexp)
|
||
|
{
|
||
|
xf_fl = XFADE(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE(fr, frp, r);
|
||
|
xf_rl = XFADE(rl, rlp, r);
|
||
|
xf_rr = XFADE(rr, rrp, r);
|
||
|
xf_fc = XFADE(fc, fcp, r);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
xf_fl = XFADE_EXP(fl, flp, r); // crossfade front left previous to front left
|
||
|
xf_fr = XFADE_EXP(fr, frp, r);
|
||
|
xf_rl = XFADE_EXP(rl, rlp, r);
|
||
|
xf_rr = XFADE_EXP(rr, rrp, r);
|
||
|
xf_fc = XFADE_EXP(fc, fcp, r);
|
||
|
}
|
||
|
|
||
|
pbf->left = CLIP_DSP(xf_fl); // crossfaded front left
|
||
|
pbf->right = CLIP_DSP(xf_fr);
|
||
|
pbr->left = CLIP_DSP(xf_rl);
|
||
|
pbr->right = CLIP_DSP(xf_rr);
|
||
|
pbc->left = CLIP_DSP(xf_fc);
|
||
|
|
||
|
pbf++;
|
||
|
pbr++;
|
||
|
pbc++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// This is an evil hack, but we need to restore the old presets after letting the sound system update for a few frames, so we just
|
||
|
// "defer" the restore until the top of the next call to CheckNewDspPresets. I put in a bit of warning in case we ever have code
|
||
|
// outside of this time period modifying any of the dsp convars. It doesn't seem to be an issue just save/loading between levels
|
||
|
static bool g_bNeedPresetRestore = false;
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
struct PreserveDSP_t
|
||
|
{
|
||
|
ConVar *cvar;
|
||
|
float oldvalue;
|
||
|
};
|
||
|
|
||
|
static PreserveDSP_t g_PreserveDSP[] =
|
||
|
{
|
||
|
{ &dsp_room },
|
||
|
{ &dsp_water },
|
||
|
{ &dsp_player },
|
||
|
{ &dsp_facingaway },
|
||
|
{ &dsp_speaker },
|
||
|
{ &dsp_spatial },
|
||
|
{ &dsp_automatic }
|
||
|
};
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Called at the top of CheckNewDspPresets to restore ConVars to real values
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void DSP_CheckRestorePresets()
|
||
|
{
|
||
|
if ( !g_bNeedPresetRestore )
|
||
|
return;
|
||
|
|
||
|
g_bNeedPresetRestore = false;
|
||
|
|
||
|
int i;
|
||
|
int c = ARRAYSIZE( g_PreserveDSP );
|
||
|
|
||
|
// Restore
|
||
|
for ( i = 0 ; i < c; ++i )
|
||
|
{
|
||
|
PreserveDSP_t& slot = g_PreserveDSP[ i ];
|
||
|
|
||
|
ConVar *cv = slot.cvar;
|
||
|
Assert( cv );
|
||
|
if ( cv->GetFloat() != 0.0f )
|
||
|
{
|
||
|
// NOTE: dsp_speaker is being (correctly) save/restored by maps, which would trigger this warning
|
||
|
//Warning( "DSP_CheckRestorePresets: Value of %s was changed between DSP_ClearState and CheckNewDspPresets, not restoring to old value\n", cv->GetName() );
|
||
|
continue;
|
||
|
}
|
||
|
cv->SetValue( slot.oldvalue );
|
||
|
}
|
||
|
|
||
|
// reinit all dsp processors (only load preset file on engine init, however)
|
||
|
|
||
|
AllocDsps( false );
|
||
|
|
||
|
// flush dsp automatic nodes
|
||
|
|
||
|
g_bdas_init_nodes = 0;
|
||
|
g_bdas_room_init = 0;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void DSP_ClearState()
|
||
|
{
|
||
|
// if we already cleared dsp state, and a restore is pending,
|
||
|
// don't clear again
|
||
|
|
||
|
if ( g_bNeedPresetRestore )
|
||
|
return;
|
||
|
|
||
|
// always save a cleared dsp automatic value to force reset of all adsp code
|
||
|
|
||
|
dsp_automatic.SetValue(0);
|
||
|
|
||
|
// Tracker 7155: YWB: This is a pretty ugly hack to zero out all of the dsp convars and bootstrap the dsp system into using them for a few frames
|
||
|
|
||
|
int i;
|
||
|
int c = ARRAYSIZE( g_PreserveDSP );
|
||
|
|
||
|
for ( i = 0 ; i < c; ++i )
|
||
|
{
|
||
|
PreserveDSP_t& slot = g_PreserveDSP[ i ];
|
||
|
|
||
|
ConVar *cv = slot.cvar;
|
||
|
Assert( cv );
|
||
|
slot.oldvalue = cv->GetFloat();
|
||
|
cv->SetValue( 0 );
|
||
|
}
|
||
|
|
||
|
// force all dsp presets to end crossfades, end one-shot presets, & release and reset all resources
|
||
|
// immediately.
|
||
|
|
||
|
FreeDsps( false ); // free all dsp states, but don't discard preset templates
|
||
|
|
||
|
// This forces the ConVars which we set to zero above to be reloaded to their old values at the time we issue the CheckNewDspPresets
|
||
|
// command. This seems to happen early enough in level changes were we don't appear to be trying to stomp real settings...
|
||
|
|
||
|
g_bNeedPresetRestore = true;
|
||
|
}
|
||
|
|
||
|
// return true if dsp's preset is one-shot and it has expired
|
||
|
|
||
|
bool DSP_HasExpired( int idsp )
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
|
||
|
Assert( idsp < CDSPS );
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return false;
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
// if first preset has expired, dsp has expired
|
||
|
|
||
|
if ( PSET_IsOneShot( pdsp->ppset[0] ) )
|
||
|
return PSET_HasExpired( pdsp->ppset[0] );
|
||
|
else
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// returns true if dsp is crossfading from previous dsp preset
|
||
|
|
||
|
bool DSP_IsCrossfading( int idsp )
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
|
||
|
Assert( idsp < CDSPS );
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return false;
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
return !RMP_HitEnd( &pdsp->xramp );
|
||
|
|
||
|
}
|
||
|
|
||
|
// returns previous preset # before oneshot preset was set
|
||
|
|
||
|
int DSP_OneShotPrevious( int idsp )
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
int idsp_prev;
|
||
|
|
||
|
Assert( idsp < CDSPS );
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return 0;
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
idsp_prev = pdsp->ipsetsav_oneshot;
|
||
|
|
||
|
return idsp_prev;
|
||
|
}
|
||
|
|
||
|
// given idsp (processor index), return true if
|
||
|
// both current and previous presets are 0 for this processor
|
||
|
|
||
|
bool DSP_PresetIsOff( int idsp )
|
||
|
{
|
||
|
dsp_t *pdsp;
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return true;
|
||
|
|
||
|
Assert ( idsp < CDSPS ); // make sure idsp is valid
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
// if current and previous preset 0, return - preset 0 is 'off'
|
||
|
|
||
|
return ( !pdsp->ipset && !pdsp->ipsetprev );
|
||
|
}
|
||
|
|
||
|
// returns true if dsp is off for room effects
|
||
|
|
||
|
bool DSP_RoomDSPIsOff()
|
||
|
{
|
||
|
return DSP_PresetIsOff( Get_idsp_room() );
|
||
|
}
|
||
|
|
||
|
// Main DSP processing routine:
|
||
|
// process samples in buffers using pdsp processor
|
||
|
// continue crossfade between 2 dsp processors if crossfading on switch
|
||
|
// pfront - front stereo buffer to process
|
||
|
// prear - rear stereo buffer to process (may be NULL)
|
||
|
// pcenter - front center mono buffer (may be NULL)
|
||
|
// sampleCount - number of samples in pbuf to process
|
||
|
// This routine also maps the # processing channels in the pdsp to the number of channels
|
||
|
// supplied. ie: if the pdsp has 4 channels and pbfront and pbrear are both non-null, the channels
|
||
|
// map 1:1 through the processors.
|
||
|
|
||
|
void DSP_Process( int idsp, portable_samplepair_t *pbfront, portable_samplepair_t *pbrear, portable_samplepair_t *pbcenter, int sampleCount )
|
||
|
{
|
||
|
bool bcrossfading;
|
||
|
int cchan_in; // input channels (2,4 or 5)
|
||
|
int cprocs; // output cannels (1, 2 or 4)
|
||
|
dsp_t *pdsp;
|
||
|
|
||
|
if (idsp < 0 || idsp >= CDSPS)
|
||
|
return;
|
||
|
|
||
|
// Don't pull dsp data in if player is not connected (during load/level change)
|
||
|
if ( !g_pSoundServices->IsConnected() )
|
||
|
return;
|
||
|
|
||
|
Assert ( idsp < CDSPS ); // make sure idsp is valid
|
||
|
|
||
|
pdsp = &dsps[idsp];
|
||
|
|
||
|
Assert (pbfront);
|
||
|
|
||
|
// return right away if fx processing is turned off
|
||
|
|
||
|
if ( dsp_off.GetInt() )
|
||
|
return;
|
||
|
|
||
|
// if current and previous preset 0, return - preset 0 is 'off'
|
||
|
|
||
|
if ( !pdsp->ipset && !pdsp->ipsetprev )
|
||
|
return;
|
||
|
|
||
|
if ( sampleCount < 0 )
|
||
|
return;
|
||
|
|
||
|
bcrossfading = !RMP_HitEnd( &pdsp->xramp );
|
||
|
|
||
|
// if not crossfading, and previous channel is not null, free previous
|
||
|
|
||
|
if ( !bcrossfading )
|
||
|
DSP_FreePrevPreset( pdsp );
|
||
|
|
||
|
// if current and previous preset 0 (ie: just freed previous), return - preset 0 is 'off'
|
||
|
|
||
|
if ( !pdsp->ipset && !pdsp->ipsetprev )
|
||
|
return;
|
||
|
|
||
|
cchan_in = (pbrear ? 4 : 2) + (pbcenter ? 1 : 0);
|
||
|
cprocs = pdsp->cchan;
|
||
|
|
||
|
Assert(cchan_in == 2 || cchan_in == 4 || cchan_in == 5 );
|
||
|
|
||
|
// if oneshot preset, update the duration counter (only update front left counter)
|
||
|
|
||
|
PSET_UpdateDuration( pdsp->ppset[0], sampleCount );
|
||
|
|
||
|
// NOTE: when mixing between different channel sizes,
|
||
|
// always AVERAGE down to fewer channels and DUPLICATE up more channels.
|
||
|
// The following routines always process cchan_in channels.
|
||
|
// ie: QuadToMono still updates 4 values in buffer
|
||
|
|
||
|
// DSP_Process stereo in to mono out (ie: left and right are averaged)
|
||
|
|
||
|
if ( cchan_in == 2 && cprocs == 1)
|
||
|
{
|
||
|
DSP_ProcessStereoToMono( pdsp, pbfront, pbrear, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// DSP_Process stereo in to stereo out (if more than 2 procs, ignore them)
|
||
|
|
||
|
if ( cchan_in == 2 && cprocs >= 2)
|
||
|
{
|
||
|
DSP_ProcessStereoToStereo( pdsp, pbfront, pbrear, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
// DSP_Process quad in to mono out
|
||
|
|
||
|
if ( cchan_in == 4 && cprocs == 1)
|
||
|
{
|
||
|
DSP_ProcessQuadToMono( pdsp, pbfront, pbrear, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
// DSP_Process quad in to stereo out (preserve stereo spatialization, loose front/rear)
|
||
|
|
||
|
if ( cchan_in == 4 && cprocs == 2)
|
||
|
{
|
||
|
DSP_ProcessQuadToStereo( pdsp, pbfront, pbrear, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
// DSP_Process quad in to quad out
|
||
|
|
||
|
if ( cchan_in == 4 && cprocs == 4)
|
||
|
{
|
||
|
DSP_ProcessQuadToQuad( pdsp, pbfront, pbrear, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// DSP_Process quad + center in to mono out
|
||
|
|
||
|
if ( cchan_in == 5 && cprocs == 1)
|
||
|
{
|
||
|
DSP_Process5To1( pdsp, pbfront, pbrear, pbcenter, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( cchan_in == 5 && cprocs == 2)
|
||
|
{
|
||
|
// undone: not used in AllocDsps
|
||
|
Assert(false);
|
||
|
//DSP_Process5to2( pdsp, pbfront, pbrear, pbcenter, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( cchan_in == 5 && cprocs == 4)
|
||
|
{
|
||
|
// undone: not used in AllocDsps
|
||
|
Assert(false);
|
||
|
//DSP_Process5to4( pdsp, pbfront, pbrear, pbcenter, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// DSP_Process quad + center in to quad + center out
|
||
|
|
||
|
if ( cchan_in == 5 && cprocs == 5)
|
||
|
{
|
||
|
DSP_Process5To5( pdsp, pbfront, pbrear, pbcenter, sampleCount, bcrossfading );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
// DSP helpers
|
||
|
|
||
|
// free all dsp processors
|
||
|
|
||
|
void FreeDsps( bool bReleaseTemplateMemory )
|
||
|
{
|
||
|
|
||
|
DSP_Free(idsp_room);
|
||
|
DSP_Free(idsp_water);
|
||
|
DSP_Free(idsp_player);
|
||
|
DSP_Free(idsp_facingaway);
|
||
|
DSP_Free(idsp_speaker);
|
||
|
DSP_Free(idsp_spatial);
|
||
|
DSP_Free(idsp_automatic);
|
||
|
|
||
|
idsp_room = 0;
|
||
|
idsp_water = 0;
|
||
|
idsp_player = 0;
|
||
|
idsp_facingaway = 0;
|
||
|
idsp_speaker = 0;
|
||
|
idsp_spatial = 0;
|
||
|
idsp_automatic = 0;
|
||
|
|
||
|
for ( int i = SOUND_BUFFER_SPECIAL_START; i < g_paintBuffers.Count(); ++i )
|
||
|
{
|
||
|
paintbuffer_t *pSpecialBuffer = MIX_GetPPaintFromIPaint( i );
|
||
|
if ( pSpecialBuffer->nSpecialDSP != 0 )
|
||
|
{
|
||
|
DSP_Free( pSpecialBuffer->idsp_specialdsp );
|
||
|
pSpecialBuffer->idsp_specialdsp = 0;
|
||
|
pSpecialBuffer->nPrevSpecialDSP = 0;
|
||
|
pSpecialBuffer->nSpecialDSP = 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
DSP_FreeAll();
|
||
|
|
||
|
// only unlock and free psettemplate memory on engine shutdown
|
||
|
|
||
|
if ( bReleaseTemplateMemory )
|
||
|
DSP_ReleaseMemory();
|
||
|
}
|
||
|
|
||
|
// alloc dsp processors, load dsp preset array from file on engine init only
|
||
|
|
||
|
bool AllocDsps( bool bLoadPresetFile )
|
||
|
{
|
||
|
int csurround = (g_AudioDevice->IsSurround() ? 2: 0); // surround channels to allocate
|
||
|
int ccenter = (g_AudioDevice->IsSurroundCenter() ? 1 : 0); // center channels to allocate
|
||
|
|
||
|
DSP_InitAll( bLoadPresetFile );
|
||
|
|
||
|
idsp_room = -1;
|
||
|
idsp_water = -1;
|
||
|
idsp_player = -1;
|
||
|
idsp_facingaway = -1;
|
||
|
idsp_speaker = -1;
|
||
|
idsp_spatial = -1;
|
||
|
idsp_automatic = -1;
|
||
|
|
||
|
// alloc dsp room channel (mono, stereo if dsp_stereo is 1)
|
||
|
|
||
|
// dsp room is mono, 300ms default fade time
|
||
|
|
||
|
idsp_room = DSP_Alloc( dsp_room.GetInt(), 200, 1 );
|
||
|
|
||
|
// dsp automatic overrides dsp_room, if dsp_room set to DSP_AUTOMATIC (1)
|
||
|
|
||
|
idsp_automatic = DSP_Alloc( dsp_automatic.GetInt(), 200, 1 ) ;
|
||
|
|
||
|
// alloc stereo or quad series processors for player or water
|
||
|
|
||
|
// water and player presets are mono
|
||
|
|
||
|
idsp_water = DSP_Alloc( dsp_water.GetInt(), 100, 1 );
|
||
|
idsp_player = DSP_Alloc( dsp_player.GetInt(), 100, 1 );
|
||
|
|
||
|
// alloc facing away filters (stereo, quad or 5ch)
|
||
|
|
||
|
idsp_facingaway = DSP_Alloc( dsp_facingaway.GetInt(), 100, 2 + csurround + ccenter );
|
||
|
|
||
|
// alloc speaker preset (mono)
|
||
|
|
||
|
idsp_speaker = DSP_Alloc( dsp_speaker.GetInt(), 300, 1 );
|
||
|
|
||
|
// alloc spatial preset (2-5 chan)
|
||
|
|
||
|
idsp_spatial = DSP_Alloc( dsp_spatial.GetInt(), 300, 2 + csurround + ccenter );
|
||
|
|
||
|
// init prev values
|
||
|
|
||
|
ipset_room_prev = dsp_room.GetInt();
|
||
|
ipset_water_prev = dsp_water.GetInt();
|
||
|
ipset_player_prev = dsp_player.GetInt();
|
||
|
ipset_facingaway_prev = dsp_facingaway.GetInt();
|
||
|
ipset_room_typeprev = dsp_room_type.GetInt();
|
||
|
ipset_speaker_prev = dsp_speaker.GetInt();
|
||
|
ipset_spatial_prev = dsp_spatial.GetInt();
|
||
|
ipset_automatic_prev = dsp_automatic.GetInt();
|
||
|
|
||
|
if (idsp_room < 0 || idsp_water < 0 || idsp_player < 0 || idsp_facingaway < 0 || idsp_speaker < 0 || idsp_spatial < 0 || idsp_automatic < 0)
|
||
|
{
|
||
|
DevMsg ("WARNING: DSP processor failed to initialize! \n" );
|
||
|
|
||
|
FreeDsps( true );
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// count number of dsp presets specified in preset file
|
||
|
// counts outer {} pairs, ignoring inner {} pairs.
|
||
|
|
||
|
int DSP_CountFilePresets( const char *pstart )
|
||
|
{
|
||
|
int cpresets = 0;
|
||
|
bool binpreset = false;
|
||
|
bool blookleft = false;
|
||
|
|
||
|
while ( 1 )
|
||
|
{
|
||
|
pstart = COM_Parse( pstart );
|
||
|
|
||
|
if ( strlen(com_token) <= 0)
|
||
|
break;
|
||
|
|
||
|
if ( com_token[0] == '{' ) // left paren
|
||
|
{
|
||
|
if (!binpreset)
|
||
|
{
|
||
|
cpresets++; // found preset:
|
||
|
blookleft = true; // look for another left
|
||
|
binpreset = true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
blookleft = false; // inside preset: next, look for matching right paren
|
||
|
}
|
||
|
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
if ( com_token[0] == '}' ) // right paren
|
||
|
{
|
||
|
if (binpreset)
|
||
|
{
|
||
|
if (!blookleft) // looking for right paren
|
||
|
{
|
||
|
blookleft = true; // found it, now look for another left
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// expected inner left paren, found outer right - end of preset definition
|
||
|
binpreset = false;
|
||
|
blookleft = true;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// error - unexpected } paren
|
||
|
DevMsg("PARSE ERROR!!! dsp_presets.txt: unexpected '}' \n");
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
return cpresets;
|
||
|
}
|
||
|
|
||
|
struct dsp_stringmap_t
|
||
|
{
|
||
|
char sz[33];
|
||
|
int i;
|
||
|
};
|
||
|
|
||
|
// token map for dsp_preset.txt
|
||
|
|
||
|
dsp_stringmap_t gdsp_stringmap[] =
|
||
|
{
|
||
|
// PROCESSOR TYPE:
|
||
|
{"NULL", PRC_NULL},
|
||
|
{"DLY", PRC_DLY},
|
||
|
{"RVA", PRC_RVA},
|
||
|
{"FLT", PRC_FLT},
|
||
|
{"CRS", PRC_CRS},
|
||
|
{"PTC", PRC_PTC},
|
||
|
{"ENV", PRC_ENV},
|
||
|
{"LFO", PRC_LFO},
|
||
|
{"EFO", PRC_EFO},
|
||
|
{"MDY", PRC_MDY},
|
||
|
{"DFR", PRC_DFR},
|
||
|
{"AMP", PRC_AMP},
|
||
|
|
||
|
// FILTER TYPE:
|
||
|
{"LP", FLT_LP},
|
||
|
{"HP", FLT_HP},
|
||
|
{"BP", FLT_BP},
|
||
|
|
||
|
// FILTER QUALITY:
|
||
|
{"LO", QUA_LO},
|
||
|
{"MED", QUA_MED},
|
||
|
{"HI", QUA_HI},
|
||
|
{"VHI", QUA_VHI},
|
||
|
|
||
|
// DELAY TYPE:
|
||
|
{"PLAIN", DLY_PLAIN},
|
||
|
{"ALLPASS", DLY_ALLPASS},
|
||
|
{"LOWPASS", DLY_LOWPASS},
|
||
|
{"DLINEAR", DLY_LINEAR},
|
||
|
{"FLINEAR", DLY_FLINEAR},
|
||
|
{"LOWPASS_4TAP",DLY_LOWPASS_4TAP},
|
||
|
{"PLAIN_4TAP", DLY_PLAIN_4TAP},
|
||
|
|
||
|
// LFO TYPE:
|
||
|
{"SIN", LFO_SIN},
|
||
|
{"TRI", LFO_TRI},
|
||
|
{"SQR", LFO_SQR},
|
||
|
{"SAW", LFO_SAW},
|
||
|
{"RND", LFO_RND},
|
||
|
{"LOG_IN", LFO_LOG_IN},
|
||
|
{"LOG_OUT", LFO_LOG_OUT},
|
||
|
{"LIN_IN", LFO_LIN_IN},
|
||
|
{"LIN_OUT", LFO_LIN_OUT},
|
||
|
|
||
|
// ENVELOPE TYPE:
|
||
|
{"LIN", ENV_LIN},
|
||
|
{"EXP", ENV_EXP},
|
||
|
|
||
|
// PRESET CONFIGURATION TYPE:
|
||
|
{"SIMPLE", PSET_SIMPLE},
|
||
|
{"LINEAR", PSET_LINEAR},
|
||
|
{"PARALLEL2", PSET_PARALLEL2},
|
||
|
{"PARALLEL4", PSET_PARALLEL4},
|
||
|
{"PARALLEL5", PSET_PARALLEL5},
|
||
|
{"FEEDBACK", PSET_FEEDBACK},
|
||
|
{"FEEDBACK3", PSET_FEEDBACK3},
|
||
|
{"FEEDBACK4", PSET_FEEDBACK4},
|
||
|
{"MOD1", PSET_MOD},
|
||
|
{"MOD2", PSET_MOD2},
|
||
|
{"MOD3", PSET_MOD3}
|
||
|
};
|
||
|
|
||
|
int gcdsp_stringmap = sizeof(gdsp_stringmap) / sizeof (dsp_stringmap_t);
|
||
|
|
||
|
#define isnumber(c) (c == '+' || c == '-' || c == '0' || c == '1' || c == '2' || c == '3' || c == '4' || c == '5' || c == '6' || c == '7'|| c == '8' || c == '9')\
|
||
|
|
||
|
// given ptr to null term. string, return integer or float value from g_dsp_stringmap
|
||
|
|
||
|
float DSP_LookupStringToken( char *psz, int ipset )
|
||
|
{
|
||
|
int i;
|
||
|
float fipset = (float)ipset;
|
||
|
|
||
|
if (isnumber(psz[0]))
|
||
|
return atof(psz);
|
||
|
|
||
|
for (i = 0; i < gcdsp_stringmap; i++)
|
||
|
{
|
||
|
if (!strcmpi(gdsp_stringmap[i].sz, psz))
|
||
|
return gdsp_stringmap[i].i;
|
||
|
}
|
||
|
|
||
|
// not found
|
||
|
|
||
|
DevMsg("DSP PARSE ERROR! token not found in dsp_presets.txt. Preset: %3.0f \n", fipset );
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
// load dsp preset file, parse presets into g_psettemplate array
|
||
|
// format for each preset:
|
||
|
// { <preset #> <preset type> <#processors> <gain> { <processor type> <param0>...<param15> } {...} {...} }
|
||
|
|
||
|
#define CHAR_LEFT_PAREN '{'
|
||
|
#define CHAR_RIGHT_PAREN '}'
|
||
|
|
||
|
// free preset template memory
|
||
|
|
||
|
void DSP_ReleaseMemory( void )
|
||
|
{
|
||
|
if (g_psettemplates)
|
||
|
{
|
||
|
delete[] g_psettemplates;
|
||
|
g_psettemplates = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool DSP_LoadPresetFile( void )
|
||
|
{
|
||
|
char szFile[ MAX_OSPATH ];
|
||
|
char *pbuffer;
|
||
|
const char *pstart;
|
||
|
bool bResult = false;
|
||
|
int cpresets;
|
||
|
int ipreset;
|
||
|
int itype;
|
||
|
int cproc;
|
||
|
float mix_min;
|
||
|
float mix_max;
|
||
|
float db_min;
|
||
|
float db_mixdrop;
|
||
|
int j;
|
||
|
bool fdone;
|
||
|
float duration;
|
||
|
float fadeout;
|
||
|
|
||
|
Q_snprintf( szFile, sizeof( szFile ), "scripts/dsp_presets.txt" );
|
||
|
|
||
|
MEM_ALLOC_CREDIT();
|
||
|
|
||
|
CUtlBuffer buf;
|
||
|
|
||
|
if ( !g_pFullFileSystem->ReadFile( szFile, "GAME", buf ) )
|
||
|
{
|
||
|
Error( "DSP_LoadPresetFile: unable to open '%s'\n", szFile );
|
||
|
return bResult;
|
||
|
}
|
||
|
pbuffer = (char *)buf.PeekGet(); // Use malloc - free at end of this routine
|
||
|
|
||
|
pstart = pbuffer;
|
||
|
|
||
|
// figure out how many presets we're loading - count outer parens.
|
||
|
|
||
|
cpresets = DSP_CountFilePresets( pstart );
|
||
|
|
||
|
g_cpsettemplates = cpresets;
|
||
|
|
||
|
g_psettemplates = new pset_t[cpresets];
|
||
|
if (!g_psettemplates)
|
||
|
{
|
||
|
Warning( "DSP Preset Loader: Out of memory.\n");
|
||
|
goto load_exit;
|
||
|
}
|
||
|
memset (g_psettemplates, 0, cpresets * sizeof(pset_t));
|
||
|
|
||
|
|
||
|
// parse presets into g_psettemplates array
|
||
|
|
||
|
pstart = pbuffer;
|
||
|
|
||
|
// for each preset...
|
||
|
|
||
|
for ( j = 0; j < cpresets; j++)
|
||
|
{
|
||
|
// check for end of file or next CHAR_LEFT_PAREN
|
||
|
|
||
|
while (1)
|
||
|
{
|
||
|
pstart = COM_Parse( pstart );
|
||
|
|
||
|
if ( strlen(com_token) <= 0)
|
||
|
break;
|
||
|
|
||
|
if ( com_token[0] != CHAR_LEFT_PAREN )
|
||
|
continue;
|
||
|
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// found start of a new preset definition
|
||
|
|
||
|
// get preset #, type, cprocessors, gain
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
ipreset = atoi( com_token );
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
itype = (int)DSP_LookupStringToken( com_token , ipreset);
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
mix_min = atof( com_token );
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
mix_max = atof( com_token );
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
duration = atof( com_token );
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
fadeout = atof( com_token );
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
db_min = atof( com_token );
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
db_mixdrop = atof( com_token );
|
||
|
|
||
|
|
||
|
g_psettemplates[ipreset].fused = true;
|
||
|
g_psettemplates[ipreset].mix_min = mix_min;
|
||
|
g_psettemplates[ipreset].mix_max = mix_max;
|
||
|
g_psettemplates[ipreset].duration = duration;
|
||
|
g_psettemplates[ipreset].fade = fadeout;
|
||
|
g_psettemplates[ipreset].db_min = db_min;
|
||
|
g_psettemplates[ipreset].db_mixdrop = db_mixdrop;
|
||
|
|
||
|
// parse each processor for this preset
|
||
|
|
||
|
fdone = false;
|
||
|
cproc = 0;
|
||
|
|
||
|
while (1)
|
||
|
{
|
||
|
// find CHAR_LEFT_PAREN - start of new processor
|
||
|
|
||
|
while (1)
|
||
|
{
|
||
|
pstart = COM_Parse( pstart );
|
||
|
|
||
|
if ( strlen(com_token) <= 0)
|
||
|
break;
|
||
|
|
||
|
if (com_token[0] == CHAR_LEFT_PAREN)
|
||
|
break;
|
||
|
|
||
|
if (com_token[0] == CHAR_RIGHT_PAREN)
|
||
|
{
|
||
|
// if found right paren, no more processors: done with this preset
|
||
|
fdone = true;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( fdone )
|
||
|
break;
|
||
|
|
||
|
// get processor type
|
||
|
|
||
|
pstart = COM_Parse( pstart );
|
||
|
g_psettemplates[ipreset].prcs[cproc].type = (int)DSP_LookupStringToken( com_token, ipreset );
|
||
|
|
||
|
// get param 0..n or stop when hit closing CHAR_RIGHT_PAREN
|
||
|
|
||
|
int ip = 0;
|
||
|
|
||
|
while (1)
|
||
|
{
|
||
|
pstart = COM_Parse( pstart );
|
||
|
|
||
|
if ( strlen(com_token) <= 0)
|
||
|
break;
|
||
|
|
||
|
if ( com_token[0] == CHAR_RIGHT_PAREN )
|
||
|
break;
|
||
|
|
||
|
g_psettemplates[ipreset].prcs[cproc].prm[ip++] = DSP_LookupStringToken( com_token, ipreset );
|
||
|
|
||
|
// cap at max params
|
||
|
|
||
|
ip = min(ip, CPRCPARAMS);
|
||
|
}
|
||
|
|
||
|
cproc++;
|
||
|
if (cproc > CPSET_PRCS)
|
||
|
DevMsg("DSP PARSE ERROR!!! dsp_presets.txt: missing } or too many processors in preset #: %d \n", ipreset);
|
||
|
cproc = min(cproc, CPSET_PRCS); // don't overflow # procs
|
||
|
}
|
||
|
|
||
|
// if cproc == 1, type is always SIMPLE
|
||
|
|
||
|
if ( cproc == 1)
|
||
|
itype = PSET_SIMPLE;
|
||
|
|
||
|
g_psettemplates[ipreset].type = itype;
|
||
|
g_psettemplates[ipreset].cprcs = cproc;
|
||
|
|
||
|
}
|
||
|
|
||
|
bResult = true;
|
||
|
|
||
|
load_exit:
|
||
|
return bResult;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Called by client on level shutdown to clear ear ringing dsp effects
|
||
|
// could be extended to other stuff
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void DSP_FastReset( int dspType )
|
||
|
{
|
||
|
int c = ARRAYSIZE( g_PreserveDSP );
|
||
|
|
||
|
// Restore
|
||
|
for ( int i = 0 ; i < c; ++i )
|
||
|
{
|
||
|
PreserveDSP_t& slot = g_PreserveDSP[ i ];
|
||
|
|
||
|
if ( slot.cvar == &dsp_player )
|
||
|
{
|
||
|
slot.oldvalue = dspType;
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Helper to check for change in preset of any of 4 processors
|
||
|
// if switching to a new preset, alloc new preset, simulate both presets in DSP_Process & xfade,
|
||
|
// called a few times per frame.
|
||
|
|
||
|
void CheckNewDspPresets( void )
|
||
|
{
|
||
|
bool b_slow_cpu = dsp_slow_cpu.GetInt() == 0 ? false : true;
|
||
|
|
||
|
DSP_CheckRestorePresets();
|
||
|
|
||
|
// room fx are on only if cpu is not slow
|
||
|
|
||
|
int iroom = b_slow_cpu ? 0 : dsp_room.GetInt() ;
|
||
|
int ifacingaway = b_slow_cpu ? 0 : dsp_facingaway.GetInt();
|
||
|
int iroomtype = b_slow_cpu ? 0 : dsp_room_type.GetInt();
|
||
|
int ispatial = b_slow_cpu ? 0 : dsp_spatial.GetInt();
|
||
|
int iautomatic = b_slow_cpu ? 0 : dsp_automatic.GetInt();
|
||
|
|
||
|
// always use dsp to process these
|
||
|
|
||
|
int iwater = dsp_water.GetInt();
|
||
|
int iplayer = dsp_player.GetInt();
|
||
|
int ispeaker = dsp_speaker.GetInt();
|
||
|
|
||
|
// check for expired one-shot presets on player and room.
|
||
|
// Only check if a) no new preset has been set and b) not crossfading from previous preset (ie; previous is null)
|
||
|
|
||
|
if ( iplayer == ipset_player_prev && !DSP_IsCrossfading( idsp_player ) )
|
||
|
{
|
||
|
if ( DSP_HasExpired ( idsp_player ) )
|
||
|
{
|
||
|
iplayer = DSP_OneShotPrevious( idsp_player); // preset has expired - revert to previous preset before one-shot
|
||
|
dsp_player.SetValue(iplayer);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( iroom == ipset_room_prev && !DSP_IsCrossfading( idsp_room ) )
|
||
|
{
|
||
|
if ( DSP_HasExpired ( idsp_room ) )
|
||
|
{
|
||
|
iroom = DSP_OneShotPrevious( idsp_room ); // preset has expired - revert to previous preset before one-shot
|
||
|
dsp_room.SetValue(iroom);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// legacy code support for "room_type" Cvar
|
||
|
|
||
|
if ( iroomtype != ipset_room_typeprev )
|
||
|
{
|
||
|
// force dsp_room = room_type
|
||
|
|
||
|
ipset_room_typeprev = iroomtype;
|
||
|
dsp_room.SetValue(iroomtype);
|
||
|
}
|
||
|
|
||
|
// NOTE: don't change presets if currently crossfading from a previous preset
|
||
|
|
||
|
if ( iroom != ipset_room_prev && !DSP_IsCrossfading( idsp_room) )
|
||
|
{
|
||
|
DSP_SetPreset( idsp_room, iroom );
|
||
|
ipset_room_prev = iroom;
|
||
|
|
||
|
// force room_type = dsp_room
|
||
|
|
||
|
dsp_room_type.SetValue(iroom);
|
||
|
ipset_room_typeprev = iroom;
|
||
|
}
|
||
|
|
||
|
if ( iwater != ipset_water_prev && !DSP_IsCrossfading( idsp_water) )
|
||
|
{
|
||
|
DSP_SetPreset( idsp_water, iwater );
|
||
|
ipset_water_prev = iwater;
|
||
|
}
|
||
|
|
||
|
if ( iplayer != ipset_player_prev && !DSP_IsCrossfading( idsp_player))
|
||
|
{
|
||
|
DSP_SetPreset( idsp_player, iplayer );
|
||
|
ipset_player_prev = iplayer;
|
||
|
}
|
||
|
|
||
|
if ( ifacingaway != ipset_facingaway_prev && !DSP_IsCrossfading( idsp_facingaway) )
|
||
|
{
|
||
|
DSP_SetPreset( idsp_facingaway, ifacingaway );
|
||
|
ipset_facingaway_prev = ifacingaway;
|
||
|
}
|
||
|
|
||
|
if ( ispeaker != ipset_speaker_prev && !DSP_IsCrossfading( idsp_speaker) )
|
||
|
{
|
||
|
DSP_SetPreset( idsp_speaker, ispeaker );
|
||
|
ipset_speaker_prev = ispeaker;
|
||
|
}
|
||
|
|
||
|
if ( ispatial != ipset_spatial_prev && !DSP_IsCrossfading( idsp_spatial) )
|
||
|
{
|
||
|
DSP_SetPreset( idsp_spatial, ispatial );
|
||
|
ipset_spatial_prev = ispatial;
|
||
|
}
|
||
|
|
||
|
if ( iautomatic != ipset_automatic_prev && !DSP_IsCrossfading( idsp_automatic) )
|
||
|
{
|
||
|
DSP_SetPreset( idsp_automatic, iautomatic );
|
||
|
ipset_automatic_prev = iautomatic;
|
||
|
}
|
||
|
|
||
|
for ( int i = SOUND_BUFFER_SPECIAL_START; i < g_paintBuffers.Count(); ++i )
|
||
|
{
|
||
|
paintbuffer_t *pSpecialBuffer = MIX_GetPPaintFromIPaint( i );
|
||
|
if ( pSpecialBuffer->nSpecialDSP != pSpecialBuffer->nPrevSpecialDSP && !DSP_IsCrossfading( pSpecialBuffer->idsp_specialdsp ) )
|
||
|
{
|
||
|
DSP_SetPreset( pSpecialBuffer->idsp_specialdsp, pSpecialBuffer->nSpecialDSP );
|
||
|
pSpecialBuffer->nPrevSpecialDSP = pSpecialBuffer->nSpecialDSP;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// create idsp_room preset from set of values, reload the preset.
|
||
|
// modifies psettemplates in place.
|
||
|
|
||
|
// ipreset is the preset # ie: 40
|
||
|
// iproc is the processor to modify within the preset (typically 0)
|
||
|
// pvalues is an array of floating point parameters
|
||
|
// cparams is the # of elements in pvalues
|
||
|
|
||
|
// USED FOR DEBUG ONLY.
|
||
|
|
||
|
void DSP_DEBUGSetParams(int ipreset, int iproc, float *pvalues, int cparams)
|
||
|
{
|
||
|
pset_t new_pset; // preset
|
||
|
int cparam = clamp (cparams, 0, CPRCPARAMS);
|
||
|
prc_t *pprct;
|
||
|
|
||
|
// copy template preset from template array
|
||
|
|
||
|
new_pset = g_psettemplates[ipreset];
|
||
|
|
||
|
// get iproc processor
|
||
|
|
||
|
pprct = &(new_pset.prcs[iproc]);
|
||
|
|
||
|
// copy parameters in to processor
|
||
|
|
||
|
for (int i = 0; i < cparam; i++)
|
||
|
{
|
||
|
pprct->prm[i] = pvalues[i];
|
||
|
}
|
||
|
|
||
|
// copy constructed preset back into template location
|
||
|
|
||
|
g_psettemplates[ipreset] = new_pset;
|
||
|
|
||
|
// setup new preset
|
||
|
|
||
|
dsp_room.SetValue( 0 );
|
||
|
|
||
|
CheckNewDspPresets();
|
||
|
|
||
|
dsp_room.SetValue( ipreset );
|
||
|
|
||
|
CheckNewDspPresets();
|
||
|
}
|
||
|
|
||
|
// reload entire preset file, reset all current dsp presets
|
||
|
// NOTE: this is debug code only. It doesn't do all mem free work correctly!
|
||
|
|
||
|
void DSP_DEBUGReloadPresetFile( void )
|
||
|
{
|
||
|
int iroom = dsp_room.GetInt();
|
||
|
int iwater = dsp_water.GetInt();
|
||
|
int iplayer = dsp_player.GetInt();
|
||
|
// int ifacingaway = dsp_facingaway.GetInt();
|
||
|
// int iroomtype = dsp_room_type.GetInt();
|
||
|
int ispeaker = dsp_speaker.GetInt();
|
||
|
int ispatial = dsp_spatial.GetInt();
|
||
|
// int iautomatic = dsp_automatic.GetInt();
|
||
|
|
||
|
// reload template array
|
||
|
|
||
|
DSP_ReleaseMemory();
|
||
|
|
||
|
DSP_LoadPresetFile();
|
||
|
|
||
|
// force presets to reload
|
||
|
|
||
|
dsp_room.SetValue( 0 );
|
||
|
dsp_water.SetValue( 0 );
|
||
|
dsp_player.SetValue( 0 );
|
||
|
//dsp_facingaway.SetValue( 0 );
|
||
|
//dsp_room_type.SetValue( 0 );
|
||
|
dsp_speaker.SetValue( 0 );
|
||
|
dsp_spatial.SetValue( 0 );
|
||
|
//dsp_automatic.SetValue( 0 );
|
||
|
|
||
|
CUtlVector< int > specialDSPs;
|
||
|
for ( int i = SOUND_BUFFER_SPECIAL_START; i < g_paintBuffers.Count(); ++i )
|
||
|
{
|
||
|
paintbuffer_t *pSpecialBuffer = MIX_GetPPaintFromIPaint( i );
|
||
|
|
||
|
specialDSPs.AddToTail( pSpecialBuffer->nSpecialDSP );
|
||
|
pSpecialBuffer->nSpecialDSP = 0;
|
||
|
}
|
||
|
|
||
|
CheckNewDspPresets();
|
||
|
|
||
|
dsp_room.SetValue( iroom );
|
||
|
dsp_water.SetValue( iwater );
|
||
|
dsp_player.SetValue( iplayer );
|
||
|
//dsp_facingaway.SetValue( ifacingaway );
|
||
|
//dsp_room_type.SetValue( iroomtype );
|
||
|
dsp_speaker.SetValue( ispeaker );
|
||
|
dsp_spatial.SetValue( ispatial );
|
||
|
//dsp_automatic.SetValue( iautomatic );
|
||
|
|
||
|
int nSpecialDSPNum = 0;
|
||
|
for ( int i = SOUND_BUFFER_SPECIAL_START; i < g_paintBuffers.Count(); ++i )
|
||
|
{
|
||
|
paintbuffer_t *pSpecialBuffer = MIX_GetPPaintFromIPaint( i );
|
||
|
|
||
|
pSpecialBuffer->nSpecialDSP = specialDSPs[ nSpecialDSPNum ];
|
||
|
nSpecialDSPNum++;
|
||
|
}
|
||
|
|
||
|
CheckNewDspPresets();
|
||
|
|
||
|
// flush dsp automatic nodes
|
||
|
|
||
|
g_bdas_init_nodes = 0;
|
||
|
g_bdas_room_init = 0;
|
||
|
}
|
||
|
|
||
|
// UNDONE: stock reverb presets:
|
||
|
|
||
|
// carpet hallway
|
||
|
// tile hallway
|
||
|
// wood hallway
|
||
|
// metal hallway
|
||
|
|
||
|
// train tunnel
|
||
|
// sewer main tunnel
|
||
|
// concrete access tunnel
|
||
|
// cave tunnel
|
||
|
// sand floor cave tunnel
|
||
|
|
||
|
// metal duct shaft
|
||
|
// elevator shaft
|
||
|
// large elevator shaft
|
||
|
|
||
|
// parking garage
|
||
|
// aircraft hangar
|
||
|
// cathedral
|
||
|
// train station
|
||
|
|
||
|
// small cavern
|
||
|
// large cavern
|
||
|
// huge cavern
|
||
|
// watery cavern
|
||
|
// long, low cavern
|
||
|
|
||
|
// wood warehouse
|
||
|
// metal warehouse
|
||
|
// concrete warehouse
|
||
|
|
||
|
// small closet room
|
||
|
// medium drywall room
|
||
|
// medium wood room
|
||
|
// medium metal room
|
||
|
|
||
|
// elevator
|
||
|
// small metal room
|
||
|
// medium metal room
|
||
|
// large metal room
|
||
|
// huge metal room
|
||
|
|
||
|
// small metal room dense
|
||
|
// medium metal room dense
|
||
|
// large metal room dense
|
||
|
// huge metal room dense
|
||
|
|
||
|
// small concrete room
|
||
|
// medium concrete room
|
||
|
// large concrete room
|
||
|
// huge concrete room
|
||
|
|
||
|
// small concrete room dense
|
||
|
// medium concrete room dense
|
||
|
// large concrete room dense
|
||
|
// huge concrete room dense
|
||
|
|
||
|
// soundproof room
|
||
|
// carpet lobby
|
||
|
// swimming pool
|
||
|
// open park
|
||
|
// open courtyard
|
||
|
// wide parkinglot
|
||
|
// narrow street
|
||
|
// wide street, short buildings
|
||
|
// wide street, tall buildings
|
||
|
// narrow canyon
|
||
|
// wide canyon
|
||
|
// huge canyon
|
||
|
// small valley
|
||
|
// wide valley
|
||
|
// wreckage & rubble
|
||
|
// small building cluster
|
||
|
// wide open plain
|
||
|
// high vista
|
||
|
|
||
|
// alien interior small
|
||
|
// alien interior medium
|
||
|
// alien interior large
|
||
|
// alien interior huge
|
||
|
|
||
|
// special fx presets:
|
||
|
|
||
|
// alien citadel
|
||
|
|
||
|
// teleport aftershock (these presets all ADSR timeout and reset the dsp_* to 0)
|
||
|
// on target teleport
|
||
|
// off target teleport
|
||
|
// death fade
|
||
|
// beam stasis
|
||
|
// scatterbrain
|
||
|
// pulse only
|
||
|
// slomo
|
||
|
// hypersensitive
|
||
|
// supershocker
|
||
|
// physwhacked
|
||
|
// forcefieldfry
|
||
|
// juiced
|
||
|
// zoomed in
|
||
|
// crabbed
|
||
|
// barnacle gut
|
||
|
// bad transmission
|
||
|
|
||
|
////////////////////////
|
||
|
// Dynamics processing
|
||
|
////////////////////////
|
||
|
|
||
|
// compressor defines
|
||
|
#define COMP_MAX_AMP 32767 // abs max amplitude
|
||
|
#define COMP_THRESH 20000 // start compressing at this threshold
|
||
|
|
||
|
// compress input value - smoothly limit output y to -32767 <= y <= 32767
|
||
|
// UNDONE: not tested or used
|
||
|
|
||
|
inline int S_Compress( int xin )
|
||
|
{
|
||
|
|
||
|
return CLIP( xin >> 2 ); // DEBUG - disabled
|
||
|
|
||
|
|
||
|
float Yn, Xn, Cn, Fn;
|
||
|
float C0 = 20000; // threshold
|
||
|
float p = .3; // compression ratio
|
||
|
float g = 1; // gain after compression
|
||
|
|
||
|
Xn = (float)xin;
|
||
|
|
||
|
// Compressor formula:
|
||
|
// Cn = l*Cn-1 + (1-l)*|Xn| // peak detector with memory
|
||
|
// f(Cn) = (Cn/C0)^(p-1) for Cn > C0 // gain function above threshold
|
||
|
// f(Cn) = 1 for C <= C0 // unity gain below threshold
|
||
|
// Yn = f(Cn) * Xn // compressor output
|
||
|
|
||
|
// UNDONE: curves discontinuous at threshold, causes distortion, try catmul-rom
|
||
|
|
||
|
//float l = .5; // compressor memory
|
||
|
//Cn = l * (*pCnPrev) + (1 - l) * fabs((float)xin);
|
||
|
//*pCnPrev = Cn;
|
||
|
|
||
|
Cn = fabs((float)xin);
|
||
|
|
||
|
if (Cn < C0)
|
||
|
Fn = 1;
|
||
|
else
|
||
|
Fn = powf((Cn / C0),(p - 1));
|
||
|
|
||
|
Yn = Fn * Xn * g;
|
||
|
|
||
|
//if (Cn > 0)
|
||
|
// Msg("%d -> %d\n", xin, (int)Yn); // DEBUG
|
||
|
|
||
|
//if (fabs(Yn) > 32767)
|
||
|
// Yn = Yn; // DEBUG
|
||
|
|
||
|
return (CLIP((int)Yn));
|
||
|
}
|
||
|
|