Огибающая ADSR и VCA: как нота начинается и затихает

Источники голоса выдают непрерывный сигнал: пока программа вызывает nextSample, осцилляторы (oscillator)?осциллятор (oscillator) — Генератор повторяющегося колебания. Частота задаёт число повторений за секунду, а форма волны — изменение значения внутри одного периода. звучат с постоянным уровнем. Нота же начинается с нажатия клавиши и заканчивается после отпускания. Эту форму во времени задаёт огибающая ADSR (ADSR envelope)?огибающая ADSR (ADSR envelope) — Управляющий сигнал от 0 до 1, который задаёт форму ноты во времени: атака и спад после нажатия, уровень sustain, пока клавиша нажата, и release после отпускания., а применяет к сигналу VCA (voltage-controlled amplifier)?VCA (voltage-controlled amplifier) — Усилитель голоса синтезатора, коэффициент которого задаёт управляющий сигнал. В цифровом голосе — умножение каждого отсчёта на значение огибающей. — умножитель усиления. Здесь разбирается вторая часть одноголосного синтезатора: события ноты, четыре стадии огибающей, их расчёт по отсчётам (sample)?отсчёт (sample) — Значение сигнала в один момент дискретизации, одно число. В звукозаписи его также называют сэмплом., щелчки на краях ноты и класс на C++20.

Голос и огибающая

Нота как события

Программа отмеряет время номерами отсчётов. Время события и длительность стадии переводятся в целое число отсчётов один раз:

При 48 кГц атака 10 мс занимает $0{,}01 \cdot 48\,000 = 480$ отсчётов ровно. Длительность 0,1234 с даёт $5923{,}2$, и округление (rounding)?округление (rounding) — Замена числа ближайшим допустимым значением, например ближайшим целым для round. Выбор при равном расстоянии до двух значений определяется отдельным соглашением. оставляет 5923 отсчёта. Ошибка — 0,2 отсчёта, около 4,2 мкс; в худшем случае она равна половине периода дискретизации (sampling period)?период дискретизации (sampling period) — Интервал времени между соседними отсчётами, обратный частоте дискретизации. Измеряется в секундах., 10,4 мкс при 48 кГц. На слух такая разница не определяется.

Ошибки округления складываются, если округлять длительности одну за другой. Сто нот по 0,1234 с, каждая округлённая до 5923 отсчётов, займут 592 300 отсчётов, а точное время 12,34 с соответствует 592 320. Последняя нота опоздает на 20 отсчётов, 0,42 мс, и сдвиг растёт с каждой нотой. Поэтому в отсчёты переводят абсолютное время события от начала записи, а длительность считают разностью уже округлённых моментов: ошибка каждого события остаётся не больше половины отсчёта.

Четыре стадии

• Атака (attack)?атака огибающей (attack) — Первая стадия огибающей ADSR: после нажатия клавиши уровень растёт до полного за время A. Не путать с временем атаки компрессора. начинается с note_on: уровень растёт до 1 за время A.
• Спад (decay)?спад огибающей (decay) — Стадия огибающей ADSR после атаки: уровень опускается от полного до уровня sustain за время D. идёт сразу после атаки: уровень опускается от 1 до уровня S за время D.
• Sustain (sustain)?sustain (sustain) — Стадия огибающей ADSR и её параметр: уровень, который держится, пока клавиша нажата. Это уровень, а не время. держит уровень S, пока клавиша нажата.
• Release (release)?release огибающей (release) — Последняя стадия огибающей ADSR: после отпускания клавиши уровень уходит от текущего значения к нулю за время R. Не путать с временем восстановления компрессора. начинается с note_off: уровень уходит к нулю за время R.

Пакетт описывает тот же генератор с пятым параметром — уровнем вершины атаки; здесь он равен 1 (Puckette, §4.1). A, D и R — времена в секундах, S — уровень без единиц. Если note_on и note_off разделены большим промежутком, огибающая с прямыми участками записывается кусочной функцией (piecewise function)?кусочная функция (piecewise function) — Функция, заданная разными выражениями на разных частях области допустимых аргументов. Выражение выбирается по условию, записанному рядом с ним. времени:

Длительность sustain в параметрах не задаётся: она равна времени нажатия минус A и D. Формула (2) описывает только случай, когда клавишу держат дольше атаки и спада. Ранний note_off, повторное нажатие и нулевые времена в неё не укладываются; их разбирает машина состояний.

Для A, D и R нужно уточнять, от какого и до какого уровня отсчитывается время. Здесь, как в juce::ADSR, атака — время от 0 до 1, спад — от 1 до S, release — от текущего уровня до 0. В моделях аналоговых огибающих спад и release часто задают для полного размаха от 1 до 0. Тогда при высоком S слышимый спад короче D, а release от S короче R (Pirkle, гл. 7.1).

Огибающая как управляющий сигнал

Поэтому $e[n]$ — управляющий сигнал: последовательность чисел от 0 до 1 с той же частотой дискретизации, что и звук. Её можно направить не только в VCA, но и на частоту среза фильтра или высоту тона (Puckette, §4.1). Если измерить огибающую сигнала на выходе VCA, она повторит $e[n]$, умноженную на размах источника, но с погрешностью детектора: пиковый детектор запаздывает и сглаживает быстрые изменения.

Линейные и экспоненциальные участки

Внутри стадии уровень меняется от начального значения $L$ к цели $T$: для атаки $T = 1$, для спада $T = S$, для release $T = 0$. Проще всего пройти этот путь за $N$ отсчётов равными шагами:

Атака 10 мс при 48 кГц: $N = 480$, шаг $1/480 \approx 0{,}00208$. Спад от 1 до 0,6 за 250 мс: $N = 12\,000$, шаг $-0{,}4/12\,000 \approx -3{,}33 \cdot 10^{-5}$. Шаги складываются в числах с плавающей точкой, поэтому после $N$-го шага уровень может отличаться от цели в последних знаках. В коде на последнем отсчёте стадии уровень присваивается цели точно.

Экспоненциальный участок вычисляется той же рекуррентной формулой (recurrence relation)?рекуррентная формула (recurrence relation) — Правило вычисления очередного значения последовательности через предыдущие значения. Для начала вычислений нужно задать начальное состояние., что сглаживание в компрессоре (dynamic range compressor)?компрессор (dynamic range compressor) — Устройство или программа, которая ослабляет сигнал, когда его уровень выше порога, и тем сужает динамический диапазон.: $e[n] = u + b\,(e[n-1] - u)$, где $u$ — цель, к которой стремится уровень, а $0 < b < 1$. Расстояние до цели на каждом отсчёте умножается на $b$: после $n$ шагов оно равно $(L - u)\,b^n$. Это число уменьшается, но при конечном $n$ не становится нулём. Если взять $u = T$, стадия никогда не закончится: спад к S будет бесконечно приближаться к нему, а release — к нулю.

Это решают порогом или целью с перелётом. Порог: стадия считается законченной, когда до цели остаётся меньше заданного $\varepsilon$, например $10^{-4}$ (−80 дБ), и уровню присваивается цель. Тогда реальная длина стадии зависит от $\varepsilon$ и от формы кривой. Цель с перелётом использует генератор огибающих Найджела Редмона (Redmon; Pirkle, гл. 7.5.1). Уровень стремится к точке $u$, которая лежит чуть дальше $T$, поэтому пересекает $T$ за конечное число шагов. В этой точке стадия и заканчивается.

Проверка: начальное расстояние до $u$ равно $(1 + r)(T - L)$, после $N$ шагов оно умножается на $b^N = r/(1 + r)$ и становится $r\,(T - L)$. Значит, уровень находится ровно в $T$. Длина стадии та же $N$, что у прямого участка, меняется только изгиб. Для release с $r = 0{,}01$ и $N = 480$ получается $b = (0{,}01/1{,}01)^{1/480} \approx 0{,}990431$. Малый $r$ даёт почти чистую экспоненту (exponential function)?экспонента (exponential function) — Функция eᵘ, также записываемая exp(u), где e ≈ 2,71828. Обратна натуральному логарифму: exp(ln(a)) = a при положительном a. При отрицательном аргументе принимает значения между 0 и 1. с крутым началом, большой — почти прямую (Redmon). Здесь для спада и release взято $r = 0{,}01$, для атаки $r = 0{,}3$: аналоговая микросхема CEM3310 заряжает конденсатор примерно до 77 % асимптоты, и верх атаки остаётся заметно изогнутым, без долгого подхода к 1 (Pirkle, гл. 7.5).

Формула коэффициента совпадает по виду с коэффициентом компрессора $\alpha = e^{-\ln 9/(f_s t)}$: там $f_s t$ — число отсчётов, а $\ln 9$ соответствует $(1 + r)/r = 9$, то есть $r = 1/8$. Различаются соглашения: время компрессора описывает переход от 10 до 90 % пути к цели, которой он не достигает, а здесь $N$ — отсчёт, на котором стадия заканчивается.

Машина состояний

Формула (2) отвечает на вопрос «какое значение в момент $t$», если известны оба события заранее. Синтезатор их заранее не знает: note_off может прийти во время атаки, а новый note_on — во время release. Поэтому огибающую строят как машину состояний (finite state machine): текущая стадия и уровень хранятся между отсчётами, а события и счётчик отсчётов переключают стадию (Pirkle, гл. 7.2).

enum class EnvelopeStage { idle, attack, decay, sustain, release };

Стадия idle — покой: огибающая выдаёт 0 и голос можно отдать другой ноте. Переходы собраны в таблицу.

Граничные случаи

Если note_off приходит во время атаки или спада, огибающая не доигрывает оставшиеся стадии и сразу переходит в release с того уровня, на котором её застало событие (Puckette, §4.1, рис. 4.2). Если начать release с S, уровень скачком перейдёт от текущего значения к S, а это щелчок. На рисунке 3а release начинается с 0,5 и длится те же 300 мс, что и от S.

Повторный note_on во время release запускает атаку с текущего уровня. Наклон сохраняется: от уровня $L$ атака длится $A\,(1 - L)$. Pirkle называет и второй режим — сброс в ноль перед атакой (reset to zero): он подчёркивает раздельность нот, но может щёлкать в момент сброса (Pirkle, гл. 7.1.2).

При нулевых временах уровень меняется сразу: $A = 0$ — уровень становится 1, $D = 0$ — сразу S, $R = 0$ — сразу 0. В коде стадия длиной 0 отсчётов пропускается в момент перехода. Огибающая при этом работает правильно, но усиление меняется скачком: о последствиях — в разделе о щелчках.

При $S = 0$ спад доводит уровень до нуля, и держать нечего: огибающая переходит в idle и не ждёт note_off. Так звучат щипковые и ударные звуки. При $S = 1$ спаду некуда опускаться: после атаки сразу sustain на полном уровне.

VCA: умножение на огибающую

При $x[n] = -0{,}8$ и $e[n] = 0{,}25$ выход $y[n] = -0{,}2$. Значение огибающей здесь — линейный коэффициент усиления (linear gain)?линейный коэффициент усиления (linear gain) — Безразмерный множитель аудиосигнала: 1 сохраняет амплитуду, значение между 0 и 1 уменьшает её, значение больше 1 увеличивает. Отрицательный множитель также меняет знак сигнала.: 0,5 уменьшает амплитуду (amplitude)?амплитуда (amplitude) — Наибольший модуль отклонения колеблющейся величины от равновесного значения. Для синусоиды обозначается A; единицы совпадают с единицами сигнала. вдвое, около −6 дБ. Поскольку $0 \le e[n] \le 1$, VCA не поднимает пик: оценка запаса из раздела о микшере остаётся верной и после него.

Та же операция стоит в тремоло (tremolo)?тремоло (tremolo) — Эффект периодического изменения амплитуды аудиосигнала. Скорость пульсации задаёт частота управляющего генератора, а диапазон усиления зависит от глубины и способа её преобразования. (принцип). Разница — в управляющем сигнале. У тремоло он периодичен: LFO (low-frequency oscillator, LFO)?низкочастотный генератор (low-frequency oscillator, LFO) — Генератор медленно повторяющегося управляющего сигнала, которым изменяют параметры звука, например усиление, частоту или панораму. Общей строгой верхней границы частоты у LFO нет. повторяет цикл независимо от нажатий, и одинаковое усиление возвращается через каждый период. Огибающая привязана к событиям ноты: она начинается с note_on, ветвится по note_off и после release не повторяется, пока не придёт новая нота.

Посмотреть и послушать

Визуализация считает огибающую и сигнал после VCA тем же кодом, что приведён в разделе C++, при 48 кГц. Сверху — огибающая с подписанными стадиями, снизу — сигнал после VCA на той же оси времени; длина графика равна длительности нажатия плюс R. Нота звучит один раз; при изменении параметров звук останавливается, чтобы новая нота прозвучала с начала.

Пример «Щипок» использует S = 0: нота затихает до note_off, и статус сообщает, что держать нечего. «note_off во время атаки» показывает release с уровня 0,40 вместо S. Переключите участки на экспоненциальные и сравните на слух: экспоненциальный release звучит как плавное затухание, линейный дольше остаётся громким. «Без атаки и release» включает пилу скачком; щелчки в начале и в конце слышны даже на 30 % громкости.

Защита от щелчков

Разрыв амплитуды возникает на краях ноты и при смене стадий:

• В начале ноты: при $A = 0$ усиление прыгает от 0 к 1. Если в этот момент сигнал не равен нулю — например, пила начинается со значения −1, — выход скачет на всю величину сигнала.
• В конце ноты: при $R = 0$ усиление падает от текущего уровня к 0 в произвольной фазе (phase)?фаза (phase) — Положение внутри периода колебания, выраженное углом: полный период соответствует 360°, или 2π радиан. Начальная фаза — её значение в момент t = 0. волны. Синус (sine)?синус (sine) — Вертикальная координата точки на единичной окружности под заданным углом от положительного направления горизонтальной оси. Для острого угла прямоугольного треугольника равен отношению противолежащего катета к гипотенузе., отпущенный на вершине, обрывается с 1 до 0.
• При смене стадий: $D = 0$ даёт скачок от 1 к S; сброс в ноль при повторном note_on — скачок от текущего уровня к 0. Release с S вместо текущего уровня тоже создаёт разрыв.

По Пакетту, разрывное изменение фазы осциллятора или амплитуды сигнала даёт слышимый артефакт, а скачок приращения фазы, то есть высоты тона, проходит без него (Puckette, §4.3). Короткая линейная атака заменяет ступеньку двумя изломами: в начале и в конце нарастания. Для приглушения перед разрывным изменением Пакетт берёт 5 мс (Puckette, §4.3.1); на практике минимальные атаку и release ограничивают несколькими миллисекундами, а дальше выбирают на слух.

Отдельный случай — конец рендера. Если записать в WAV только время нажатия, release обрежется, и последний отсчёт файла останется ненулевым: проигрыватель после него выдаёт тишину, и разрыв окажется на границе файла. Длина рендера должна быть не меньше длительности нажатия плюс R, тогда огибающая успевает дойти до нуля.

С фазой 90° вариант 0 мс прыгает от 0 к 1 на note_on и от 1 к 0 на note_off, а вариант 5 мс поднимается за 240 отсчётов: наибольший шаг между соседними отсчётами меньше 0,005. Выберите фазу 0°: у синуса в этот момент значение 0, и даже атака 0 мс не даёт скачка. Полагаться на это нельзя: фаза в момент note_off зависит от длительности нажатия и частоты, а у пилы и прямоугольника значение 0 бывает только в отдельных точках.

Код на C++

Класс AdsrEnvelope повторяет устройство осциллятора: структура Parameters отдельно от изменяемого состояния — стадии, уровня, шага и счётчика. prepare задаёт частоту дискретизации, setParameters — времена и уровень, noteOn и noteOff переключают стадию, nextSample выдаёт следующее значение, isActive сообщает, нужен ли ещё голос. Используется только стандартная библиотека C++20.

// Огибающая ADSR: параметры отдельно от состояния, стадии — счётчики отсчётов.
#include <cassert>
#include <cmath>

enum class EnvelopeStage { idle, attack, decay, sustain, release };
enum class Curve { linear, exponential };

class AdsrEnvelope
{
public:
    struct Parameters
    {
        double attack = 0.01, decay = 0.2, sustain = 0.6, release = 0.3; // с, доля, с
        Curve curve = Curve::linear;
    };

    void prepare (double newSampleRate) noexcept
    {
        assert (std::isfinite (newSampleRate) && newSampleRate > 0.0);
        sampleRate = newSampleRate;
        reset();
    }

    // Вызывать между нотами: новые времена действуют со следующей стадии.
    void setParameters (const Parameters& p) noexcept
    {
        assert (p.attack >= 0.0 && p.decay >= 0.0 && p.release >= 0.0);
        assert (p.sustain >= 0.0 && p.sustain <= 1.0);
        params = p;
    }

    void reset() noexcept { stage = EnvelopeStage::idle; level = 0.0; }
    void noteOn() noexcept { start (EnvelopeStage::attack); }
    void noteOff() noexcept
    {
        if (stage != EnvelopeStage::idle)
            start (EnvelopeStage::release);
    }
    bool isActive() const noexcept { return stage != EnvelopeStage::idle; }

    double nextSample() noexcept
    {
        if (stage == EnvelopeStage::idle || stage == EnvelopeStage::sustain)
            return level;
        level = params.curve == Curve::linear ? level + step
                                              : aim + (level - aim) * coef;
        if (--remaining == 0)
        {
            level = target; // точно на цели, без накопленной ошибки
            start (following (stage));
        }
        return level;
    }

private:
    static EnvelopeStage following (EnvelopeStage s) noexcept
    {
        return s == EnvelopeStage::attack ? EnvelopeStage::decay
             : s == EnvelopeStage::decay  ? EnvelopeStage::sustain
                                          : EnvelopeStage::idle;
    }

    void start (EnvelopeStage next) noexcept;

    Parameters params;
    double sampleRate = 48000.0;
    // Состояние: стадия, уровень и участок, который сейчас проходится.
    EnvelopeStage stage = EnvelopeStage::idle;
    double level = 0.0, target = 0.0, step = 0.0, aim = 0.0, coef = 0.0;
    long long remaining = 0;
};

nextSample на стадиях idle и sustain только возвращает уровень. На движущихся стадиях он делает шаг по формуле (3) или (4) и уменьшает счётчик. Когда счётчик доходит до нуля, уровень приравнивается цели и начинается следующая стадия. Все переходы, в том числе по событиям, проходят через start:

// Начало стадии: число отсчётов и шаг; стадии нулевой длины пропускаются.
void AdsrEnvelope::start (EnvelopeStage next) noexcept
{
    for (;;)
    {
        stage = next;
        if (stage == EnvelopeStage::idle)
        {
            level = 0.0;
            return;
        }
        if (stage == EnvelopeStage::sustain)
        {
            level = params.sustain;
            if (level == 0.0)
                stage = EnvelopeStage::idle; // держать нечего: голос свободен
            return;
        }
        double seconds = params.release, overshoot = 0.01;
        target = 0.0;
        if (stage == EnvelopeStage::attack)
        {
            target = 1.0;
            seconds = params.attack * (1.0 - level); // с прежним наклоном от 0 до 1
            overshoot = 0.3;
        }
        else if (stage == EnvelopeStage::decay)
        {
            target = params.sustain;
            seconds = params.decay;
        }
        remaining = std::llround (seconds * sampleRate);
        if (remaining > 0 && level != target)
        {
            step = (target - level) / static_cast<double> (remaining);
            aim = target + overshoot * (target - level); // цель с перелётом
            coef = std::pow (overshoot / (1.0 + overshoot), 1.0 / static_cast<double> (remaining));
            return;
        }
        level = target; // нулевая длина: скачок к цели и следующая стадия
        next = following (stage);
    }
}

Release и повторная атака всегда начинаются с текущего level: start не обнуляет его, а только вычисляет новый шаг. Цикл нужен для цепочки нулевых стадий: при $A = D = 0$ один вызов noteOn проходит атаку и спад и останавливается на sustain. Шаг и коэффициент вычисляются один раз на стадию, а std::pow не вызывается на каждом отсчёте. Код собран clang++ -std=c++20 -Wall -Wextra -Wconversion без предупреждений. Для A = 100 мс, D = 250 мс, S = 0,6, R = 400 мс и note_off через 0,8 с он даёт те же отсчёты, что визуализация: прямые участки совпадают точно, экспоненциальные — до $10^{-13}$, из-за разных реализаций pow.

Голос в аудиоблоке JUCE

// Голос в аудиоблоке JUCE: события ноты на своих отсчётах, VCA — умножение на огибающую.
#include <juce_audio_basics/juce_audio_basics.h>

void startNote (VoiceSources& voice, AdsrEnvelope& envelope, int midiNote)
{
    if (envelope.isActive()) // голос звучит: меняется шаг фазы, фаза продолжается
    {
        const double f = noteFrequency (midiNote);
        voice.osc1.setFrequency (f);
        voice.osc2.setFrequency (f * std::exp2 (7.0 / 1200.0));
        voice.sub.setFrequency (f / 2.0);
    }
    else
        voice.noteOn (midiNote, 0, 7.0); // в тишине фазы можно сбросить
    envelope.noteOn();
}

void renderBlock (VoiceSources& voice, const VoiceLevels& levels, AdsrEnvelope& envelope,
                  int& currentNote, const juce::MidiBuffer& midi,
                  juce::AudioBuffer<float>& output) noexcept
{
    auto render = [&] (int from, int to)
    {
        for (int n = from; n < to; ++n)
        {
            const auto y = static_cast<float> (voice.nextSample (levels) * envelope.nextSample());
            for (int channel = 0; channel < output.getNumChannels(); ++channel)
                output.setSample (channel, n, y);
        }
    };

    int done = 0;
    for (const auto metadata : midi)
    {
        render (done, metadata.samplePosition);
        done = metadata.samplePosition;
        const auto message = metadata.getMessage();
        if (message.isNoteOn())
        {
            currentNote = message.getNoteNumber();
            startNote (voice, envelope, currentNote);
        }
        else if (message.isNoteOff() && message.getNoteNumber() == currentNote)
            envelope.noteOff();
    }
    render (done, output.getNumSamples());
}

VoiceSources::noteOn сбрасывает фазы осцилляторов. В тишине это безопасно, но во время release уровень не равен нулю, и сброс фазы дал бы скачок сигнала на входе VCA — тот же щелчок. Поэтому у звучащего голоса меняется только частота: скачок шага фазы, как отмечает Пакетт, слышимого разрыва не даёт. Расстройка (detune)?расстройка (detune) — Небольшое отклонение частоты одного генератора от другого или от точного интервала, обычно в центах. При одновременном звучании даёт биения. +7 центов (cent)?цент (cent) — Сотая часть равномерно темперированного полутона; в октаве 1200 центов. Интервал в c центов умножает частоту на 2 в степени c/1200. — пример из статьи об осцилляторах. note_off другой клавиши игнорируется: одноголосный синтезатор отпускает только последнюю нажатую ноту. Когда envelope.isActive() возвращает false, голос молчит, и блок можно не считать.

Сравнение с juce::ADSR

Совпадает поведение стадий. Перечисление стадий то же: idle, attack, decay, sustain, release. noteOff во время атаки или спада начинает release с текущего значения, и release всегда длится R: шаг вычисляется в момент noteOff как текущий уровень, делённый на $R \cdot f_s$. noteOn не обнуляет уровень, поэтому повторная атака продолжает с текущего значения с наклоном $1/(A \cdot f_s)$. Нулевая атака сразу даёт 1, нулевые атака и спад — сразу S.

Различия:

• В juce::ADSR участки только линейные.
• Стадия заканчивается сравнением уровня с целью: envelopeVal >= 1.0f, <= sustain, <= 0.0f. Шаги складываются во float, и длина стадии может отличаться от $\operatorname{round}(t \cdot f_s)$ на отсчёт. Здесь стадию заканчивает счётчик, и уровень приравнивается цели.
• При $R = 0$ noteOff вызывает reset(): уровень обнуляется сразу, со скачком. Здесь то же самое, но через стадию нулевой длины.
• При S = 0 огибающая JUCE остаётся в sustain с уровнем 0 и isActive() возвращает true до noteOff. Здесь она переходит в idle сразу после спада.
• В стадии sustain JUCE каждый отсчёт берёт уровень из параметров, поэтому новое S применяется сразу, скачком. Документация JUCE просит не менять параметры во время звучания, а если они изменились до конца release — вызвать reset() перед следующим noteOn.

Самопроверка

Источники

• Puckette M. The Theory and Technique of Electronic Music. Гл. 4.1: Envelope generators, 4.2: Linear and curved amplitude shapes, 4.3: Continuous and discontinuous control changes, Muting и 10.2: Fourier series of the elementary waveforms. в списке литературы → — стадии ADSR и ранний off, повторная атака, восприятие линейного нарастания, слышимость разрывов амплитуды и фазы, приглушение за 5 мс, гармоники ступеньки и излома.
• Pirkle W. C. Designing Software Synthesizer Plugins in C++: With Audio DSP. Гл. 7: Envelope generators and DCA, с. 87–101. в списке литературы → — времена спада и release от полного размаха, перезапуск с текущего уровня и сброс в ноль, release с текущего уровня, машина состояний, линейный шаг, модель аналоговой огибающей CEM3310 и метод Редмона с перелётом цели.
• Redmon N. Envelope generators — ADSR code. в списке литературы → — генератор огибающих с параметром перелёта: малые значения дают почти экспоненциальную форму, большие — почти линейную.
• JUCE 9.0.3. juce_ADSR.h и juce_MidiBuffer.h — стадии, расчёт шагов, поведение при нулевых временах и S = 0, обход событий блока с samplePosition.
• Ableton. Live 12 Manual, Analog: Envelopes — стадии ADSR в инструменте, переключатель линейных и экспоненциальных участков, крайние положения Sustain.