AREnvelopeFollowerBase.h

Go to the documentation of this file.

/*
 *  File:       AREnveloperFollowerBase.h
 *
 *  Created:    27/05/2017
 *
 *  This file is part of WECore.
 *
 *  WECore is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  WECore is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with WECore.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "AREnvelopeFollowerParameters.h"
#include "ModulationSource.h"
#include "TPTSVFilter.h"
 
namespace WECore::AREnv {
    class AREnvelopeFollowerBase : public ModulationSource<double> {
    public:
        AREnvelopeFollowerBase() : _attackTimeMs(Parameters::ATTACK_MS.defaultValue),
                                   _releaseTimeMs(Parameters::RELEASE_MS.defaultValue),
                                   _filterEnabled(Parameters::FILTER_ENABLED.defaultValue) {
            // call this here rather than setting it in initialiser list so that the coefficients get
            // setup
            reset();
            setSampleRate(44100);
 
            _lowCutFilter.setCutoff(Parameters::LOW_CUT.defaultValue);
            _highCutFilter.setCutoff(Parameters::HIGH_CUT.defaultValue);
            _lowCutFilter.setMode(TPTSVF::Parameters::FILTER_MODE.HIGHPASS);
            _highCutFilter.setMode(TPTSVF::Parameters::FILTER_MODE.LOWPASS);
        }
 
        virtual ~AREnvelopeFollowerBase() override = default;
 
        inline void setSampleRate(double sampleRate);
 
        inline void setAttackTimeMs(double time);
 
        inline void setReleaseTimeMs(double time);
 
        void setFilterEnabled(bool isEnabled) { _filterEnabled = isEnabled; }
 
        void setLowCutHz(double freq) { _lowCutFilter.setCutoff(freq); }
 
        void setHighCutHz(double freq) { _highCutFilter.setCutoff(freq); }
        double getAttackTimeMs() const { return _attackTimeMs; }
 
        double getReleaseTimeMs() const { return _releaseTimeMs; }
 
        bool getFilterEnabled() const { return _filterEnabled; }
 
        double getLowCutHz() const { return _lowCutFilter.getCutoff(); }
 
        double getHighCutHz() const { return _highCutFilter.getCutoff(); }
    protected:
        double _envVal;
 
        double _attackTimeMs;
        double _releaseTimeMs;
 
        double _attackCoef;
        double _releaseCoef;
 
        bool _filterEnabled;
        TPTSVF::TPTSVFilter<double> _lowCutFilter;
        TPTSVF::TPTSVFilter<double> _highCutFilter;
 
        double _sampleRate;
 
        inline double _getNextOutputImpl(double inSample) override;
 
        virtual inline double _envGetNextOutputImpl(double inSample) = 0;
 
        inline void _resetImpl() override;
 
        double _calcCoef(double timeMs) {
            return exp(log(0.01) / (timeMs * _sampleRate * 0.001));
        }
    };
 
    void AREnvelopeFollowerBase::setSampleRate(double sampleRate) {
        _sampleRate = sampleRate;
        _attackCoef = _calcCoef(_attackTimeMs);
        _releaseCoef = _calcCoef(_releaseTimeMs);
 
        _lowCutFilter.setSampleRate(sampleRate);
        _highCutFilter.setSampleRate(sampleRate);
    }
 
    void AREnvelopeFollowerBase::setAttackTimeMs(double time) {
        _attackTimeMs = Parameters::ATTACK_MS.BoundsCheck(time);
        _attackCoef = _calcCoef(_attackTimeMs);
    }
 
    void AREnvelopeFollowerBase::setReleaseTimeMs(double time) {
        _releaseTimeMs = Parameters::RELEASE_MS.BoundsCheck(time);
        _releaseCoef = _calcCoef(_releaseTimeMs);
    }
 
    double AREnvelopeFollowerBase::_getNextOutputImpl(double inSample) {
        if (_filterEnabled) {
            _lowCutFilter.processBlock(&inSample, 1);
            _highCutFilter.processBlock(&inSample, 1);
        }
 
        return _envGetNextOutputImpl(inSample);
    }
 
    void AREnvelopeFollowerBase::_resetImpl() {
        _envVal = 0;
        _lowCutFilter.reset();
        _highCutFilter.reset();
    }
}