limiter.h

Go to the documentation of this file.

#pragma once

#include "synthbase.h"
#include "synthconstants.h"

// -----------------------------
//  --- SynthLab SDK File --- // 
//  ----------------------------
// -----------------------------------------------------------------------------
namespace SynthLab
{
    class SimpleLPF
    {
    public:
        SimpleLPF(void) {}  /* C-TOR */
        ~SimpleLPF(void) {} /* D-TOR */

    public:
        virtual bool reset(double _sampleRate)
        {
            state = 0.0;
            return true;
        }

        void setLPF_g(double _lpf_g) { lpf_g = _lpf_g; }

        virtual double processAudioSample(double xn)
        {
            double yn = (1.0 - lpf_g)*xn + lpf_g*state;
            state = yn;
            return yn;
        }

    private:
        double lpf_g = 0.8; 
        double state = 0.0; 
    };

    class LogPeakDetector
    {
    public:
        LogPeakDetector(void) {}    /* C-TOR */
        ~LogPeakDetector(void) {}   /* D-TOR */

    public:
        virtual bool reset(double _sampleRate)
        {
            // --- store the sample rate
            sampleRate = _sampleRate;
            samplePeriod_T = 1.0 / sampleRate;

            // --- storage to hold peak value
            peakStore = 0.0;

            // --- setup simple one-pole LPF to smooth detector output
            lpf.reset(sampleRate);

            return true;
        }

        virtual double processAudioSample(double xn)
        {
            // --- all modes do Full Wave Rectification
            double input = fabs(xn);

            // --- output variable is output of peak storage
            double rn = peakStore;

            // --- we are recursive so need to check underflow
            checkFloatUnderflow(rn);

            // --- can not be (-)
            rn = fmax(rn, 0.0);

            // --- setup inputs to the peak store register
            double attackValue = 0.0;
            double releaseValue = 0.0;

            // --- form difference
            double diff = input - peakStore;
            if (diff > 0.0)
                attackValue = attackTime;

            // --- attack branch accumultes with peak store
            attackValue += peakStore;

            // --- release branch multiplies with output
            releaseValue = rn * releaseTime;

            // --- sum of branches
            peakStore = attackValue - releaseValue;

            // --- filtering to smooth response
            double yn = lpf.processAudioSample(rn);

            // --- setup for log( )
            if (yn <= 0)
                return -96.0; // should only get called for string of 0's

            // --- true log output in dB, can go above 0dBFS!
            return 20.0 * log10(yn);
        }

        inline void setAttackReleaseTimes(double attack_in_ms, double release_in_ms)
        {
            // --- cook parameters here
            setAttackTime(attack_in_ms);
            setReleaseTime(release_in_ms);
        }

        const double kSmallestPositiveFloatValue = 1.175494351e-38;         /* min positive value */
        const double kSmallestNegativeFloatValue = -1.175494351e-38;         /* min negative value */

        inline bool checkFloatUnderflow(double& value)
        {
            bool retValue = false;
            if (value > 0.0 && value < kSmallestPositiveFloatValue)
            {
                value = 0;
                retValue = true;
            }
            else if (value < 0.0 && value > kSmallestNegativeFloatValue)
            {
                value = 0;
                retValue = true;
            }
            return retValue;
        }
    private:
        SimpleLPF lpf;              
        double attackTime = 0.0;    
        double releaseTime = 0.0;   
        double sampleRate = 44100;  
        double samplePeriod_T = 1.0;    
        double lastEnvelope = 0.0;  
        double peakStore = 0.0;     

        void setAttackTime(double attack_in_ms)
        {
            // --- calculate 10% - 90% risetime
            attackTime = 1.0 - exp((-2.2*samplePeriod_T) / (attack_in_ms * 0.001));
        }

        void setReleaseTime(double release_in_ms)
        {
            // --- calculate 10% - 90% falltime
            releaseTime = 1.0 - exp((-2.2*samplePeriod_T) / (release_in_ms * 0.001));
        }
    };


    class LinPeakDetector
    {
    public:
        LinPeakDetector(void) {}    /* C-TOR */
        ~LinPeakDetector(void) {}   /* D-TOR */

    public:
        virtual bool reset(double _sampleRate)
        {
            // --- store the sample rate
            sampleRate = _sampleRate;
            samplePeriod_T = 1.0 / sampleRate;

            // --- storage to hold peak value
            peakStore = 0.0;

            // --- setup simple one-pole LPF to smooth detector output
            lpf.reset(sampleRate);

            return true;
        }

        virtual double processAudioSample(double xn)
        {
            // --- all modes do Full Wave Rectification
            double input = fabs(xn);

            // --- output variable is output of peak storage
            double rn = peakStore;

            // --- we are recursive so need to check underflow
            checkFloatUnderflow(rn);

            // --- can not be (-)
            rn = fmax(rn, 0.0);

            // --- setup inputs to the peak store register
            double attackValue = 0.0;
            double releaseValue = 0.0;

            // --- form difference
            double diff = input - peakStore;
            if (diff > 0.0)
                attackValue = attackTime;

            // --- attack branch accumultes with peak store
            attackValue += peakStore;

            // --- release branch multiplies with output
            releaseValue = rn * releaseTime;

            // --- sum of branches
            peakStore = attackValue - releaseValue;

            // --- filtering to smooth response
            double yn = lpf.processAudioSample(rn);

            return yn;
        }

        inline void setAttackReleaseTimes(double attack_in_ms, double release_in_ms)
        {
            // --- cook parameters here
            setAttackTime(attack_in_ms);
            setReleaseTime(release_in_ms);
        }

        const double kSmallestPositiveFloatValue = 1.175494351e-38;         /* min positive value */
        const double kSmallestNegativeFloatValue = -1.175494351e-38;         /* min negative value */

        inline bool checkFloatUnderflow(double& value)
        {
            bool retValue = false;
            if (value > 0.0 && value < kSmallestPositiveFloatValue)
            {
                value = 0;
                retValue = true;
            }
            else if (value < 0.0 && value > kSmallestNegativeFloatValue)
            {
                value = 0;
                retValue = true;
            }
            return retValue;
        }
    private:
        SimpleLPF lpf;              
        double attackTime = 0.0;    
        double releaseTime = 0.0;   
        double sampleRate = 44100;  
        double samplePeriod_T = 1.0;    
        double lastEnvelope = 0.0;  
        double peakStore = 0.0;     

        void setAttackTime(double attack_in_ms)
        {
            // --- calculate 10% - 90% risetime
            attackTime = 1.0 - exp((-2.2*samplePeriod_T) / (attack_in_ms * 0.001));
        }

        void setReleaseTime(double release_in_ms)
        {
            // --- calculate 10% - 90% falltime
            releaseTime = 1.0 - exp((-2.2*samplePeriod_T) / (release_in_ms * 0.001));
        }
    };

    // --- 

    class Limiter
    {
    public:
        Limiter() {}
        ~Limiter() {}

        void reset(double _sampleRate)
        {
            // --- reset detector (always first)
            linDetector.reset(_sampleRate);
            logDetector.reset(_sampleRate);

            // --- init;
            linDetector.setAttackReleaseTimes(
                10.0,   /* attack time mSec*/
                200.0   /* release time mSec*/);
            logDetector.setAttackReleaseTimes(
                10.0,   /* attack time mSec*/
                200.0   /* release time mSec*/);
        }

        void setThreshold_dB(double _threshold_dB) { threshold_dB = _threshold_dB; }

        void setThreshold(double _threshold) { threshold = _threshold; }

        double calcLimiterGaindB(float fDetectorValue, float fThreshold)
        {
            // --- slope variable // limiting is infinite ratio thus CS->1.0
            //                       you can play with this for compression CS < 1.0
            double CS = 1.0; // 1.0;

            // --- compute gain; threshold and detection values are in dB
            double yG = CS*(fThreshold - fDetectorValue);  // [Eq. 13.1]

            // --- clamp; this allows ratios of 1:1 to still operate
            yG = fmin(0.0, yG);

            // --- convert back to linear
            return pow(10.0, yG / 20.0);
        }

        double calcLimiterGain(float fDetectorValue, float fThreshold)
        {
            // --- slope variable // limiting is infinite ratio thus CS->1.0
            //                       you can play with this for compression CS < 1.0
            double CS = 1.0; // 1.0;

            // --- compute gain; threshold and detection values are in raw form
            double yG = (fThreshold - fDetectorValue);  // [Eq. 13.1]

            // --- clamp; this allows ratios of 1:1 to still operate
            yG = yG > 0.0 ? 1.0 : CS*(fThreshold / fDetectorValue);

            // --- already linear
            return yG;
        }

        double process(double input)
        {
            //double detectedValue_dB = logDetector.processAudioSample(input);
            //double gain = calcLimiterGaindB(detectedValue_dB, threshold_dB);
            double detectedValue = linDetector.processAudioSample(input);
            double gain = calcLimiterGain(detectedValue, threshold);
            return input*gain;
        }

    protected:
        LogPeakDetector logDetector;    
        double threshold_dB = -1.5; 
        
        LinPeakDetector linDetector;    
        double threshold = 0.8413;  
    };

} // namespace