ADSREnvelope.soul

// referenced from SOUL/example/PadSynth.soul
// TODO: implement proper gain tracking, ramp output value.

processor ADSREnvelope
{
    input stream float triggerLevel;
    output stream float envelopeLevel;
    input event float threshhold;

    event threshhold (float f)
    {
        threshholdLevel =  f * (1.0f / 10000.0f);
    }

    const float sampleRate = float (processor.frequency);

    float64 attackRamp = 1.0;
    float64 decayMultiplier = 0.995;
    float64 sustainLevel = 0.0;
    float64 releaseMultiplier = 0.99991;
    float32 velocitySensitivity = 0.1f;
    float64 targetValue = 1.0;
    float   threshholdLevel = 0.5;

    void calculateTargetValue (float noteVelocity)
    {
        // Use the velocitySensitivity to decide how the noteVelocity affects the target volume
        // We determine a dB attenuation range, then the note velocity decides where we are on it
        // Full velocity sensitivity is -12dB

        // We use 100 as a 'loud' note, so that's 0.75 out of 100 as 'normal', any higher velocity will be louder
        let attenuation = -12.0f * velocitySensitivity * (0.75f - noteVelocity);

        targetValue = pow (10.0f, attenuation / 10.0f);
    }

    void run()
    {
        float64 value = 0;

        loop
        {

            if (triggerLevel > threshholdLevel)
            {

                // Use the value of the trigger to modify our target value
                calculateTargetValue (triggerLevel);

                while (value < targetValue)
                {
                    value += attackRamp;
                    envelopeLevel << float(value);
                    advance();

                    if (triggerLevel <= threshholdLevel)
                        break;
                }

                // Cap it to the target value
                value = min (value, targetValue);

                // Decay stage
                while (value > targetValue * sustainLevel && triggerLevel > threshholdLevel)
                {
                    value = value * decayMultiplier;
                    envelopeLevel << float (value);
                    advance();
                }

                // Sustain stage
                while (triggerLevel > threshholdLevel)
                {
                    envelopeLevel << float (value);
                    advance();
                }
            }

            // console << value;
            // console << "\n";

            value *= releaseMultiplier;
            
            // console << value;

            envelopeLevel << float (value);
            advance();
        }
    }
}