Public Member Functions
void	sf_advancecomp (int rate, float pregain, float threshold, float knee, float ratio, float attack, float release, float predelay, float releasezone1, float releasezone2, float releasezone3, float releasezone4, float postgain, float wet)

Public Attributes
float	metergain

float	meterrelease

float	threshold

float	knee

float	linearpregain

float	linearthreshold

float	slope

float	attacksamplesinv

float	satreleasesamplesinv

float	wet

float	dry

float	k

float	kneedboffset

float	linearthresholdknee

float	mastergain

float	a

float	b

float	c

float	d

float	detectoravg

float	compgain

float	maxcompdiffdb

int	delaybufsize

int	delaywritepos

int	delayreadpos

float	delaybuf [AUDIOCOMPRESSORSND_SF_COMPRESSOR_MAXDELAY]

Detailed Description

Definition at line 169 of file audiocompressorsnd.h.

Member Function Documentation

◆ sf_advancecomp()

void AudioCompressorSnd::CompressorState::sf_advancecomp	(	int	rate,
		float	pregain,
		float	threshold,
		float	knee,
		float	ratio,
		float	attack,
		float	release,
		float	predelay,
		float	releasezone1,
		float	releasezone2,
		float	releasezone3,
		float	releasezone4,
		float	postgain,
		float	wet
	)

Definition at line 76 of file audiocompressorsnd.cpp.

References AUDIOCOMPRESSORSND_SF_COMPRESSOR_MAXDELAY, AudioCompressorSnd::compcurve(), AudioCompressorSnd::db2lin(), i, AudioCompressorSnd::kneecurve(), AudioCompressorSnd::kneeslope(), and AudioCompressorSnd::lin2db().

Referenced by AudioCompressorSnd::initState().

 {
     // setup the predelay buffer
     int delaybufsize = rate * predelay;
 
     if (delaybufsize < 1)
     {
         delaybufsize = 1;
     }
     else if (delaybufsize > AUDIOCOMPRESSORSND_SF_COMPRESSOR_MAXDELAY)
     {
         delaybufsize = AUDIOCOMPRESSORSND_SF_COMPRESSOR_MAXDELAY;
         std::fill(delaybuf, delaybuf+delaybufsize, 0.0f);
     }
 
     // useful values
     float linearpregain = db2lin(pregain);
     float linearthreshold = db2lin(threshold);
     float slope = 1.0f / ratio;
     float attacksamples = rate * attack;
     float attacksamplesinv = 1.0f / attacksamples;
     float releasesamples = rate * release;
     float satrelease = 0.0025f; // seconds
     float satreleasesamplesinv = 1.0f / ((float)rate * satrelease);
     float dry = 1.0f - wet;
 
     // metering values (not used in core algorithm, but used to output a meter if desired)
     float metergain = 1.0f; // gets overwritten immediately because gain will always be negative
     float meterfalloff = 0.325f; // seconds
     float meterrelease = 1.0f - expf(-1.0f / ((float)rate * meterfalloff));
 
     // calculate knee curve parameters
     float k = 5.0f; // initial guess
     float kneedboffset = 0.0f;
     float linearthresholdknee = 0.0f;
 
     if (knee > 0.0f) // if a knee exists, search for a good k value
     {
         float xknee = db2lin(threshold + knee);
         float mink = 0.1f;
         float maxk = 10000.0f;
 
         // search by comparing the knee slope at the current k guess, to the ideal slope
         for (int i = 0; i < 15; i++)
         {
             if (kneeslope(xknee, k, linearthreshold) < slope) {
                 maxk = k;
             } else {
                 mink = k;
             }
 
             k = sqrtf(mink * maxk);
         }
 
         kneedboffset = lin2db(kneecurve(xknee, k, linearthreshold));
         linearthresholdknee = db2lin(threshold + knee);
     }
 
     // calculate a master gain based on what sounds good
     float fulllevel = compcurve(1.0f, k, slope, linearthreshold, linearthresholdknee, threshold, knee, kneedboffset);
     float mastergain = db2lin(postgain) * powf(1.0f / fulllevel, 0.6f);
 
     // calculate the adaptive release curve parameters
     // solve a,b,c,d in `y = a*x^3 + b*x^2 + c*x + d`
     // interescting points (0, y1), (1, y2), (2, y3), (3, y4)
     float y1 = releasesamples * releasezone1;
     float y2 = releasesamples * releasezone2;
     float y3 = releasesamples * releasezone3;
     float y4 = releasesamples * releasezone4;
     float a = (-y1 + 3.0f * y2 - 3.0f * y3 + y4) / 6.0f;
     float b = y1 - 2.5f * y2 + 2.0f * y3 - 0.5f * y4;
     float c = (-11.0f * y1 + 18.0f * y2 - 9.0f * y3 + 2.0f * y4) / 6.0f;
     float d = y1;
 
     // save everything
     this->metergain            = 1.0f; // large value overwritten immediately since it's always < 0
     this->meterrelease         = meterrelease;
     this->threshold            = threshold;
     this->knee                 = knee;
     this->wet                  = wet;
     this->linearpregain        = linearpregain;
     this->linearthreshold      = linearthreshold;
     this->slope                = slope;
     this->attacksamplesinv     = attacksamplesinv;
     this->satreleasesamplesinv = satreleasesamplesinv;
     this->dry                  = dry;
     this->k                    = k;
     this->kneedboffset         = kneedboffset;
     this->linearthresholdknee  = linearthresholdknee;
     this->mastergain           = mastergain;
     this->a                    = a;
     this->b                    = b;
     this->c                    = c;
     this->d                    = d;
     this->detectoravg          = 0.0f;
     this->compgain             = 1.0f;
     this->maxcompdiffdb        = -1.0f;
     this->delaybufsize         = delaybufsize;
     this->delaywritepos        = 0;
     this->delayreadpos         = delaybufsize > 1 ? 1 : 0;
 }