#33 Add sustain to the limiter.

Author: Archie3d

Source/aeolus/dsp/limiter.cpp

@@ -30,15 +30,25 @@ void Limiter::updateSpec(Limiter::Spec& spec)
 void Limiter::resetState(const Limiter::Spec& spec, Limiter::State& state)
 {
     state.gain = 1.0f;
+    state.sustain = 0;
 }
 
 float Limiter::tick(const Limiter::Spec& spec, Limiter::State& state, float in)
 {
     const float level = std::abs(in);
 
     const float targetGain = (level > spec.threshold) ? spec.threshold / level : 1.0f;
-    state.gain = (state.gain > targetGain) ? std::max(state.gain / spec.attack, targetGain)
-                                           : std::min(state.gain * spec.release, targetGain);
+
+    if (state.gain > targetGain) {
+        state.gain = std::max(state.gain + (targetGain - state.gain) * spec.attack, targetGain);
+        state.sustain = spec.sustain;
+    } else {
+        if (state.sustain > 0) {
+            state.sustain--;
+        } else {
+            state.gain = std::min(state.gain + (targetGain - state.gain) * spec.release, targetGain);
+        }
+    }
 
     return in * state.gain;
 }
@@ -47,16 +57,28 @@ void Limiter::process(const Limiter::Spec& spec, Limiter::State& state, const fl
 {
     float targetGain = 1.0f;
     float gain = state.gain;
+    int sustain = state.sustain;
 
     for (size_t i = 0; i < size; ++i) {
         const float level = std::abs(in[i]);
         targetGain = (level > spec.threshold) ? spec.threshold / level : 1.0f;
-        gain = (gain > targetGain) ? std::max(gain / spec.attack, targetGain)
-                                   : std::min(gain * spec.release, targetGain);
+
+        if (gain > targetGain) {
+            gain = std::max(gain + (targetGain - gain) * spec.attack, targetGain);
+            sustain = spec.sustain;
+        } else {
+            if (sustain > 0) {
+                sustain--;
+            } else {
+                gain = std::min(gain + (targetGain - gain) * spec.release, targetGain);
+            }
+        }
+
         out[i] = in[i] * gain;
     }
 
     state.gain = gain;
+    state.sustain = sustain;
 }
 
 } // namespace dsp

Source/aeolus/dsp/limiter.h

@@ -33,11 +33,13 @@ struct Limiter
         float threshold;
         float attack;
         float release;
+        int sustain;
     };
 
     struct State
     {
         float gain;
+        int sustain;
     };
 
     static void updateSpec(Spec& spec);

Source/aeolus/engine.cpp

@@ -473,9 +473,10 @@ void Engine::prepareToPlay(float sampleRate, int frameSize)
     auto* g = EngineGlobal::getInstance();
     g->updateStops(SAMPLE_RATE_F);
 
-    _limiterSpec.threshold = 0.9f;
-    _limiterSpec.attack = 1.001f;
-    _limiterSpec.release = 1.00001f;
+    _limiterSpec.threshold = 0.75f;
+    _limiterSpec.attack = 10000.0f / sampleRate;
+    _limiterSpec.release = 1.0f / sampleRate;
+    _limiterSpec.sustain = std::max(0, int(sampleRate * 0.5f));
 
     for (auto& state : _limiterState)
         dsp::Limiter::resetState(_limiterSpec, state);
@@ -590,12 +591,12 @@ void Engine::process(float* outL, float* outR, int numFrames, bool isNonRealtime
 
     applyVolume(origOutL, origOutR, origNumFrames);
 
-    _volumeLevel.left.process(origOutL, origNumFrames);
-    _volumeLevel.right.process(origOutR, origNumFrames);
-
     // Apply limiter
     dsp::Limiter::process(_limiterSpec, _limiterState[0], origOutL, origOutL, origNumFrames);
     dsp::Limiter::process(_limiterSpec, _limiterState[1], origOutR, origOutR, origNumFrames);
+
+    _volumeLevel.left.process(origOutL, origNumFrames);
+    _volumeLevel.right.process(origOutR, origNumFrames);
 }
 
 void Engine::process(AudioBuffer<float>& out, bool isNonRealtime)