KwidgetProcessor_Adsr.cpp

Go to the documentation of this file.

namespace krotos
{
    KwidgetProcessor_Adsr::KwidgetProcessor_Adsr(Kwidget& owner) : KwidgetProcessor(owner)
    {
        using P = Parameters;
 
        addParameterAttachments({{P::Attack, [this](float x) { setAttack(x); }, 0},
                                 {P::Decay, [this](float x) { setDecay(x); }, 0},
                                 {P::Sustain, [this](float x) { setSustain(x); }, 2},
                                 {P::Release, [this](float x) { setRelease(x); }, 0}});
 
        addModulator(true);
    }
 
    void KwidgetProcessor_Adsr::prepare(double sampleRate, int samplesPerBlock)
    {
        m_adsr.setSampleRate(sampleRate);
        updateParams();
 
        m_buffer.setSize(1, samplesPerBlock);
        getModulator(0)->setValues(m_buffer.getReadPointer(0), samplesPerBlock);
    }
 
    //==============================================================================
    void KwidgetProcessor_Adsr::process(AudioBuffer<float>& buffer)
    {
        auto numSamples = buffer.getNumSamples();
        auto numChannels = buffer.getNumChannels();
        auto bufferPtr = buffer.getArrayOfWritePointers();
 
        auto modulatorBufferPtr = m_buffer.getWritePointer(0);
 
        nextBlock(numSamples);
 
        for (int sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
        {
            nextSample();
 
            auto amp = m_adsr.getNextSample();
 
            // Output the modulation signal
            modulatorBufferPtr[sampleIndex] = amp;
 
            // Modulate the audio data using the
            for (int channelIndex = 0; channelIndex < numChannels; channelIndex++)
                bufferPtr[channelIndex][sampleIndex] *= amp;
        }
 
        if (!m_adsr.isActive() && !m_hasBeenReset) // If the ADSR has finished
        {
            reset();
            m_hasBeenReset = true;
        }
    }
 
    void KwidgetProcessor_Adsr::noteOn(int midiNoteNumber, float /*velocity*/, int)
    {
        m_isDrone = (midiNoteNumber & MIDI_NOTE_FLAG_DRONE) != 0; // Keep a record of the type of event
 
        if (!m_adsr.isActive()) // If we are not already active
        {
            if (m_isDrone && ((midiNoteNumber & MIDI_NOTE_FLAG_DRONE_NOTEUP) != 0))
            {
                // Its a drone note-up event
                m_noteIsOn = false;
                m_adsr.noteOff();
            }
            else
            {
                // Its a note on event
                m_noteIsOn = true;
                m_adsr.noteOn();
                m_hasBeenReset = false;
            }
        }
    }
 
    void KwidgetProcessor_Adsr::noteOff(float)
    {
        // If we were started as a drone, stop note can never switch us off, only startNote with stop flag
        if (!m_isDrone &&
            m_noteIsOn) // Checking m_noteIsOn prevents re-triggering of any already in-progress release - fix KST-1218
        {
            m_noteIsOn = false;
            m_adsr.noteOff();
        }
    }
 
    bool KwidgetProcessor_Adsr::isActive() { return m_adsr.isActive(); }
 
    void KwidgetProcessor_Adsr::noteCleared() { reset(); }
 
    void KwidgetProcessor_Adsr::reset()
    {
        m_noteIsOn = false;
        m_adsr.reset();
    }
 
    void KwidgetProcessor_Adsr::setAttack(float attack)
    {
        m_parameters.attack = attack;
        updateParams();
    }
    void KwidgetProcessor_Adsr::setDecay(float decay)
    {
        m_parameters.decay = decay;
        updateParams();
    }
    void KwidgetProcessor_Adsr::setSustain(float sustain)
    {
        m_parameters.sustain = sustain;
        updateParams();
    }
    void KwidgetProcessor_Adsr::setRelease(float release)
    {
        m_parameters.release = release;
        updateParams();
    }
 
    void KwidgetProcessor_Adsr::updateParams() { m_adsr.setParameters(m_parameters); }
 
} // namespace krotos