ADSR.h

// ADSR.h
// ofxPDSP
// Nicola Pisanti, MIT License, 2016

#ifndef PDSP_ENV_ADSRLEG_H_INCLUDED
#define PDSP_ENV_ADSRLEG_H_INCLUDED

#include "../pdspCore.h"
#include "stages/EnvelopeStage.h"
#include "stages/AttackStage.h"
#include "stages/DecayStage.h"
#include "stages/RiseStage.h"
#include "stages/SustainStage.h"
#include "stages/ReleaseStage.h"

namespace pdsp{
 
class ADSR :    public Unit,
                public virtual EnvelopeStage,
                public virtual AttackStage,
                public virtual DecayStage, 
                public virtual RiseStage,
                public virtual SustainStage,
                public virtual ReleaseStage 
{

public:
    ADSR();

    Patchable& set(float attackTimeMs, float decayTimeMs, float sustainLevel, float releaseTimeMs, float velocity = 1.0f );


    void setAttackCurve(float hardness); 
 
    void setReleaseCurve(float hardness); 

    void setCurve(float hardness);


    void enableDBTriggering(float dBmin, float dBmax=0.0f);
    
    void disableDBTriggering();

    Patchable& in_trig();
    
    Patchable& in_attack();
    
    Patchable& in_decay();
    
    Patchable& in_sustain();
    
    Patchable& in_release();
    
    Patchable& in_velocity();    

    Patchable& out_signal();

    Patchable& out_bias();

    float meter_output() const;

    int meter_triggers() const;

private:

    void process(int bufferSize) noexcept override;
    void prepareUnit( int expectedBufferSize, double sampleRate) override;
    void releaseResources() override;

    inline_f void doEnvelope() {
            switch (stageSwitch){
            case off         : envelopeOutput = 0.0; break;
            case attackStage : Attack(stageSwitch, decayStage); break;
            case decayStage  : Decay(stageSwitch, sustainStage); break;
            case sustainStage: Sustain(); break;
            case releaseStage: Release(stageSwitch, off); break;
            case riseStage   : Rise(stageSwitch, decayStage); break;
            }
    };

    void onRetrigger(float triggerValue, int n);
    
    void process_run(int bufferSize);
    void process_T( const float* &trigBuffer, const int &bufferSize);
    
    InputNode input_trig;
    OutputNode output;
    InputNode input_attack;
    InputNode input_decay;
    InputNode input_sustain;
    InputNode input_release;
    InputNode input_velocity;

    std::atomic<int> trigcount;
    std::atomic<bool> dBtrig;
    float dBmin;
    float dBmax;    
    
    int              stageSwitch;
    
    static const int off          = 0;
    static const int attackStage  = 1;
    static const int decayStage   = 2;
    static const int sustainStage = 3;
    static const int releaseStage = 4;
    static const int riseStage    = 5;
    
    std::atomic<float> meter;
};

} // pdsp namespace end

#endif  // PDSP_ENV_ADSRLEG_H_INCLUDED