ADSR.h

/*
 * ADSR.h
 *
 * This file is part of Mozzi.
 *
 * Copyright 2012-2024 Tim Barrass and the Mozzi Team
 *
 * Mozzi is licensed under the GNU Lesser General Public Licence (LGPL) Version 2.1 or later.
 *
 */
 
#ifndef ADSR_H_
#define ADSR_H_
 
#include <Arduino.h>
#include "Line.h"
#include "mozzi_fixmath.h"
 
 
template <unsigned int CONTROL_UPDATE_RATE, unsigned int LERP_RATE, typename T = unsigned int>
class ADSR
{
private:
 
    const unsigned int LERPS_PER_CONTROL;
 
    T update_step_counter;
    T num_update_steps;
 
    enum {ATTACK,DECAY,SUSTAIN,RELEASE,IDLE};
 
 
    struct phase{
        byte phase_type;
        T update_steps;
        long lerp_steps; // signed, to match params to transition (line) type Q15n16, below
        Q8n0 level;
    }attack,decay,sustain,release,idle;
 
    phase * current_phase;
 
    // Linear audio rate transitions for envelope
    //Line <unsigned long> transition;
    Line <Q15n16> transition; // scale up unsigned char levels for better accuracy, then scale down again for output
 
    inline
    T convertMsecToControlUpdateSteps(unsigned int msec){
        return (T) (((uint32_t)msec*CONTROL_UPDATE_RATE)>>10); // approximate /1000 with shift
    }
 
 
    inline
    void setPhase(phase * next_phase) {
        update_step_counter = 0;
        num_update_steps = next_phase->update_steps;
        transition.set(Q8n0_to_Q15n16(next_phase->level),next_phase->lerp_steps);
        current_phase = next_phase;
    }
 
 
    inline
    void checkForAndSetNextPhase(phase * next_phase) {
        if (++update_step_counter >= num_update_steps){
            setPhase(next_phase);
        }
    }
 
 
 
    inline
    void setTime(phase * p, unsigned int msec)
    {
        p->update_steps = convertMsecToControlUpdateSteps(msec);
        p->lerp_steps = (long) p->update_steps * LERPS_PER_CONTROL;
    }
 
 
    inline
    void setUpdateSteps(phase * p, unsigned int steps)
    {
        p->update_steps = steps;
        p->lerp_steps = (long) steps * LERPS_PER_CONTROL;
    }
 
 
 
public:
 
    ADSR():LERPS_PER_CONTROL(LERP_RATE/CONTROL_UPDATE_RATE)
    {
        attack.phase_type = ATTACK;
        decay.phase_type = DECAY;
        sustain.phase_type = SUSTAIN;
        release.phase_type = RELEASE;
        idle.phase_type = IDLE;
        release.level = 0;
        adsr_playing = false;
        current_phase = &idle;
    }
 
 
 
    void update(){ // control rate
 
        switch(current_phase->phase_type) {
 
        case ATTACK:
            checkForAndSetNextPhase(&decay);
            break;
 
        case DECAY:
            checkForAndSetNextPhase(&sustain);
            break;
 
        case SUSTAIN:
            checkForAndSetNextPhase(&release);
            break;
 
        case RELEASE:
            checkForAndSetNextPhase(&idle);
            break;
 
        case IDLE:
            adsr_playing = false;
            break;
        }
    }
 
 
 
    inline
    unsigned char next()
    {
        unsigned char out = 0;
        if (adsr_playing) out = Q15n16_to_Q8n0(transition.next());
        return out;
    }
 
 
 
    inline
    void noteOn(bool reset=false){
        if (reset) transition.set(0);
        setPhase(&attack);
        adsr_playing = true;
    }
 
 
 
    inline
    void noteOff(){
        setPhase(&release);
    }
 
 
 
    inline
    void setAttackLevel(byte value)
    {
        attack.level=value;
    }
 
 
 
    inline
    void setDecayLevel(byte value)
    {
        decay.level=value;
    }
 
 
    inline
    void setSustainLevel(byte value)
    {
        sustain.level=value;
    }
 
    inline
    void setReleaseLevel(byte value)
    {
        release.level=value;
    }
 
 
        inline
    void setIdleLevel(byte value)
    {
        idle.level=value;
    }
 
 
    inline
    void setADLevels(byte attack, byte decay)
    {
        setAttackLevel(attack);
        setDecayLevel(decay);
        setSustainLevel(decay); // stay at decay level
        setReleaseLevel(1);
        setIdleLevel(0);
    }
 
 
    inline
    void setLevels(byte attack, byte decay, byte sustain, byte release)
    {
        setAttackLevel(attack);
        setDecayLevel(decay);
        setSustainLevel(sustain);
        setReleaseLevel(release);
        setIdleLevel(0);
    }
 
 
    inline
    void setAttackTime(unsigned int msec)
    {
        setTime(&attack, msec);
    }
 
 
    inline
    void setDecayTime(unsigned int msec)
    {
        setTime(&decay, msec);
    }
 
 
    inline
    void setSustainTime(unsigned int msec)
    {
        setTime(&sustain, msec);
    }
 
 
 
    inline
    void setReleaseTime(unsigned int msec)
    {
        setTime(&release, msec);
    }
 
 
    inline
    void setIdleTime(unsigned int msec)
    {
        setTime(&idle, msec);
    }
 
 
    inline
    void setTimes(unsigned int attack_ms, unsigned int decay_ms, unsigned int sustain_ms, unsigned int release_ms)
    {
        setAttackTime(attack_ms);
        setDecayTime(decay_ms);
        setSustainTime(sustain_ms);
        setReleaseTime(release_ms);
        setIdleTime(65535); // guarantee step size of line will be 0
    }
 
 
 
    inline
    void setAttackUpdateSteps(unsigned int steps)
    {
        setUpdateSteps(&attack, steps);
    }
 
 
    inline
    void setDecayUpdateSteps(unsigned int steps)
    {
        setUpdateSteps(&decay, steps);
    }
 
 
    inline
    void setSustainUpdateSteps(unsigned int steps)
    {
        setUpdateSteps(&sustain, steps);
    }
 
 
    inline
    void setReleaseUpdateSteps(unsigned int steps)
    {
        setUpdateSteps(&release, steps);
    }
 
 
        inline
    void setIdleUpdateSteps(unsigned int steps)
    {
        setUpdateSteps(&idle, steps);
    }
 
    inline
    void setAllUpdateSteps(unsigned int attack_steps, unsigned int decay_steps, unsigned int sustain_steps, unsigned int release_steps)
    {
        setAttackUpdateSteps(attack_steps);
        setDecayUpdateSteps(decay_steps);
        setSustainUpdateSteps(sustain_steps);
        setReleaseUpdateSteps(release_steps);
        setIdleUpdateSteps(65535); // guarantee step size of line will be 0
    }
 
 
bool adsr_playing;
 
    inline
    bool playing()
    {
        return adsr_playing;
    }
 
 
};
 
 
#endif /* ADSR_H_ */