amuse/lib/Envelope.cpp

#include "amuse/Envelope.hpp"
#include "amuse/Voice.hpp"

namespace amuse
{

static int32_t MIDItoTIME[104] =
{ /* [0..103] -> milliseconds */
    0,      10,     20,     30,     40,     50,     60,     70,
    80,     90,     100,    110,    110,    120,    130,    140,
    150,    160,    170,    190,    200,    220,    230,    250,
    270,    290,    310,    330,    350,    380,    410,    440,
    470,    500,    540,    580,    620,    660,    710,    760,
    820,    880,    940,    1000,   1000,   1100,   1200,   1300,
    1400,   1500,   1600,   1700,   1800,   2000,   2100,   2300,
    2400,   2600,   2800,   3000,   3200,   3500,   3700,   4000,
    4300,   4600,   4900,   5300,   5700,   6100,   6500,   7000,
    7500,   8100,   8600,   9300,   9900,   10000,  11000,  12000,
    13000,  14000,  15000,  16000,  17000,  18000,  19000,  21000,
    22000,  24000,  26000,  28000,  30000,  32000,  34000,  37000,
    39000,  42000,  45000,  49000,  50000,  55000,  60000,  65000
};

void Envelope::reset(const ADSR* adsr)
{
    m_phase = State::Attack;
    m_curTime = 0.0;
    m_attackTime = adsr->getAttack();
    m_decayTime = adsr->getDecay();
    m_sustainFactor = adsr->getSustain();
    m_releaseTime = adsr->getRelease();
    m_releaseStartFactor = 0.0;
    m_adsrSet = true;
}

void Envelope::reset(const ADSRDLS* adsr, int8_t note, int8_t vel)
{
    m_phase = State::Attack;
    m_curTime = 0.0;
    m_attackTime = adsr->getVelToAttack(vel);
    m_decayTime = adsr->getKeyToDecay(note);
    m_sustainFactor = adsr->getSustain();
    m_releaseTime = adsr->getRelease();
    m_releaseStartFactor = 0.0;
    m_adsrSet = true;
}

void Envelope::keyOff(const Voice& vox)
{
    double releaseTime = m_releaseTime;
    if (vox.m_state.m_useAdsrControllers)
        releaseTime = MIDItoTIME[clamp(0, int(vox.getCtrlValue(vox.m_state.m_midiRelease)), 103)] / 1000.0;

    m_phase = (releaseTime != 0.0) ? State::Release : State::Complete;
    m_curTime = 0.0;
}

void Envelope::keyOff()
{
    m_phase = (m_releaseTime != 0.0) ? State::Release : State::Complete;
    m_curTime = 0.0;
}

float Envelope::advance(double dt, const Voice& vox)
{
    double thisTime = m_curTime;
    m_curTime += dt;

    switch (m_phase)
    {
    case State::Attack:
    {
        double attackTime = m_attackTime;
        if (vox.m_state.m_useAdsrControllers)
            attackTime = MIDItoTIME[clamp(0, int(vox.getCtrlValue(vox.m_state.m_midiAttack)), 103)] / 1000.0;

        if (attackTime == 0.0)
        {
            m_phase = State::Decay;
            m_curTime = 0.0;
            m_releaseStartFactor = 1.f;
            return 1.f;
        }
        double attackFac = thisTime / attackTime;
        if (attackFac >= 1.0)
        {
            m_phase = State::Decay;
            m_curTime = 0.0;
            m_releaseStartFactor = 1.f;
            return 1.f;
        }
        m_releaseStartFactor = attackFac;
        return attackFac;
    }
    case State::Decay:
    {
        double decayTime = m_decayTime;
        if (vox.m_state.m_useAdsrControllers)
            decayTime = MIDItoTIME[clamp(0, int(vox.getCtrlValue(vox.m_state.m_midiDecay)), 103)] / 1000.0;

        double sustainFactor = m_sustainFactor;
        if (vox.m_state.m_useAdsrControllers)
            sustainFactor = clamp(0, int(vox.getCtrlValue(vox.m_state.m_midiSustain)), 127) / 127.0;

        if (decayTime == 0.0)
        {
            m_phase = State::Sustain;
            m_curTime = 0.0;
            m_releaseStartFactor = sustainFactor;
            return sustainFactor;
        }
        double decayFac = thisTime / decayTime;
        if (decayFac >= 1.0)
        {
            m_phase = State::Sustain;
            m_curTime = 0.0;
            m_releaseStartFactor = sustainFactor;
            return sustainFactor;
        }
        m_releaseStartFactor = (1.0 - decayFac) + decayFac * sustainFactor;
        return m_releaseStartFactor;
    }
    case State::Sustain:
    {
        double sustainFactor = m_sustainFactor;
        if (vox.m_state.m_useAdsrControllers)
            sustainFactor = clamp(0, int(vox.getCtrlValue(vox.m_state.m_midiSustain)), 127) / 127.0;

        return sustainFactor;
    }
    case State::Release:
    {
        double releaseTime = m_releaseTime;
        if (vox.m_state.m_useAdsrControllers)
            releaseTime = MIDItoTIME[clamp(0, int(vox.getCtrlValue(vox.m_state.m_midiRelease)), 103)] / 1000.0;

        if (releaseTime == 0.0)
        {
            m_phase = State::Complete;
            return 0.f;
        }
        double releaseFac = thisTime / releaseTime;
        if (releaseFac >= 1.0)
        {
            m_phase = State::Complete;
            return 0.f;
        }
        return std::min(m_releaseStartFactor, 1.0 - releaseFac);
    }
    case State::Complete:
    default:
        return 0.f;
    }
}

float Envelope::advance(double dt)
{
    double thisTime = m_curTime;
    m_curTime += dt;

    switch (m_phase)
    {
    case State::Attack:
    {
        double attackTime = m_attackTime;

        if (attackTime == 0.0)
        {
            m_phase = State::Decay;
            m_curTime = 0.0;
            m_releaseStartFactor = 1.f;
            return 1.f;
        }
        double attackFac = thisTime / attackTime;
        if (attackFac >= 1.0)
        {
            m_phase = State::Decay;
            m_curTime = 0.0;
            m_releaseStartFactor = 1.f;
            return 1.f;
        }
        m_releaseStartFactor = attackFac;
        return attackFac;
    }
    case State::Decay:
    {
        double decayTime = m_decayTime;
        double sustainFactor = m_sustainFactor;

        if (decayTime == 0.0)
        {
            m_phase = State::Sustain;
            m_curTime = 0.0;
            m_releaseStartFactor = sustainFactor;
            return sustainFactor;
        }
        double decayFac = thisTime / decayTime;
        if (decayFac >= 1.0)
        {
            m_phase = State::Sustain;
            m_curTime = 0.0;
            m_releaseStartFactor = sustainFactor;
            return sustainFactor;
        }
        m_releaseStartFactor = (1.0 - decayFac) + decayFac * sustainFactor;
        return m_releaseStartFactor;
    }
    case State::Sustain:
    {
        return m_sustainFactor;
    }
    case State::Release:
    {
        double releaseTime = m_releaseTime;

        if (releaseTime == 0.0)
        {
            m_phase = State::Complete;
            return 0.f;
        }
        double releaseFac = thisTime / releaseTime;
        if (releaseFac >= 1.0)
        {
            m_phase = State::Complete;
            return 0.f;
        }
        return std::min(m_releaseStartFactor, 1.0 - releaseFac);
    }
    case State::Complete:
    default:
        return 0.f;
    }
}

}