//========= 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<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: // // // // 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: // { <#processors> { ... } {...} {...} } #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)); }