Saturation.h

Go to the documentation of this file.

namespace krotos
{
    //==============================================================================
    class Saturation
    {
      public:
        enum FunctionType
        {
            diodic = 0,
            hyperbolicTangent,
            saturation1,
            saturation2,
            saturation3
        };
 
        const std::map<FunctionType, float (*)(float)> functions{
                {diodic, &Function::diodic},           {hyperbolicTangent, &Function::hyperbolicTangent},
                {saturation1, &Function::saturation1}, {saturation2, &Function::saturation1},
                {saturation3, &Function::saturation1},
        };
 
        Saturation();
        ~Saturation();
 
        void prepareToPlay(double sampleRate, int blockSize);
        float processSample(float sample, int channel);
 
        void setFunctionType(FunctionType function);
 
        void setInputGainDb(float gainInDb);
        void setOutputGainDb(float gainInDb);
 
        void setLowCutFrequency(float newCutoffFrequency);
        void setHighCutFrequency(float newCutoffFrequency);
 
        void setMix(float newMixValue);
 
      private:
        enum ParameterList
        {
            preGain = 0,
            postGain,
            lowCut,
            hiCut,
            mix
        };
 
        enum Channel
        {
            left = 0,
            right
        };
 
        struct Function
        {
            static float hyperbolicTangent(float x) { return dsp::FastMathApproximations::tanh(x); }
 
            static float anhystericTapeRecordingErf(float x) { return std::erf(x); }
 
            static float diodic(float x) { return sign(x) * (2.0f * std::abs(x) - x * x); }
 
            static float saturation1(float x)
            {
                float a = 1.5f;
                return x * (std::abs(x) + a) / (x * x + (a - 1.0f) * std::abs(x) + 1.0f);
            }
 
            static float saturation2(float x)
            {
                return std::sin(MathConstants<float>::halfPi * jlimit(-1.0f, 1.0f, x));
            }
 
            static float saturation3(float x)
            {
                float k = 1.3f;
                float sgn = static_cast<float>(sign(x));
                x = std::pow(std::abs(x), k);
                x = std::pow(std::atan(x), (1.0f / k));
                return sgn * x;
            }
        };
 
        template <typename T> static int sign(T val);
 
        const int NUM_CHANNELS_MAX{2};
 
        double m_sampleRate{0.0};
 
        float m_outputGain{1.0f};
        float m_inputGain{1.0f};
        float m_mix{1.0f};
 
        dsp::WaveShaper<float> m_waveshaper;
 
        OwnedArray<IIRFilter> m_lowCutFilters;
        OwnedArray<IIRFilter> m_highCutFilters;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Saturation)
    };
} // namespace krotos