Allow effect to continue processing if its buffer isn't empty (builtin reverb/delay)

src/effects/backends/builtin/echoeffect.cpp

@@ -118,6 +118,14 @@ void EchoEffect::loadEngineEffectParameters(
     m_pTripletParameter = parameters.value("triplet");
 }
 
+float averageSampleEnergy(mixxx::SampleBuffer const& delay_buffer) {
+    float differenceSum = 0.0f;
+    for (const CSAMPLE sample : delay_buffer.span()) {
+        differenceSum += std::abs(sample);
+    }
+    return differenceSum / delay_buffer.size();
+}
+
 void EchoEffect::processChannel(
         EchoGroupState* pGroupState,
         const CSAMPLE* pInput,
@@ -127,10 +135,16 @@ void EchoEffect::processChannel(
         const GroupFeatureState& groupFeatures) {
     // The minimum of the parameter is zero so the exact center of the knob is 1 beat.
     double period = m_pDelayParameter->value();
-    const auto send_current = static_cast<CSAMPLE_GAIN>(m_pSendParameter->value());
+    const auto send_current = enableState == EffectEnableState::Disabling
+            ? 0
+            : static_cast<CSAMPLE_GAIN>(m_pSendParameter->value());
     const auto feedback_current = static_cast<CSAMPLE_GAIN>(m_pFeedbackParameter->value());
     const auto pingpong_frac = static_cast<CSAMPLE_GAIN>(m_pPingPongParameter->value());
 
+    if (enableState == EffectEnableState::Enabling) {
+        m_isReadyForDisable = false;
+    }
+
     int delay_frames;
     if (groupFeatures.beat_length.has_value()) {
         // period is a number of beats
@@ -236,16 +250,17 @@ void EchoEffect::processChannel(
             pGroupState->ping_pong = 0;
         }
     }
-
-    // The ramping of the send parameter handles ramping when enabling, so
-    // this effect must handle ramping to dry when disabling itself (instead
-    // of being handled by EngineEffect::process).
+    pGroupState->prev_send = send_current;
     if (enableState == EffectEnableState::Disabling) {
-        SampleUtil::applyRampingGain(pOutput, 1.0, 0.0, engineParameters.samplesPerBuffer());
-        pGroupState->delay_buf.clear();
         pGroupState->prev_send = 0;
-    } else {
-        pGroupState->prev_send = send_current;
+        const SINT delayBufferSize = pGroupState->delay_buf.size();
+        // Calculate if the delayline-buffer is approx. zero/empty.
+        const float avgSampleEnergy = averageSampleEnergy(pGroupState->delay_buf);
+        // If echo tail fully faded
+        if (avgSampleEnergy < (0.00001f / delayBufferSize)) {
+            m_isReadyForDisable = true;
+            pGroupState->delay_buf.clear();
+        }
     }
 
     pGroupState->prev_feedback = feedback_current;

src/effects/backends/builtin/echoeffect.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <QMap>
+#include <span>
 
 #include "effects/backends/effectprocessor.h"
 #include "engine/engine.h"
@@ -53,7 +54,9 @@ class EchoEffect : public EffectProcessorImpl<EchoGroupState> {
 
     void loadEngineEffectParameters(
             const QMap<QString, EngineEffectParameterPointer>& parameters) override;
-
+    bool isReadyForDisable() override {
+        return m_isReadyForDisable;
+    };
     void processChannel(
             EchoGroupState* pState,
             const CSAMPLE* pInput,
@@ -73,6 +76,6 @@ class EchoEffect : public EffectProcessorImpl<EchoGroupState> {
     EngineEffectParameterPointer m_pPingPongParameter;
     EngineEffectParameterPointer m_pQuantizeParameter;
     EngineEffectParameterPointer m_pTripletParameter;
-
+    bool m_isReadyForDisable = false;
     DISALLOW_COPY_AND_ASSIGN(EchoEffect);
 };

src/effects/backends/builtin/reverbeffect.cpp

@@ -77,6 +77,24 @@ void ReverbEffect::loadEngineEffectParameters(
     m_pSendParameter = parameters.value("send_amount");
 }
 
+float averageSampleDifferenceEnergy(const SINT samplesPerBuffer,
+        const CSAMPLE* buffer_in,
+        const CSAMPLE* buffer_out,
+        const SINT tailCheckLength) {
+    if (tailCheckLength == 0) {
+        return 0;
+    }
+    float differenceSum = 0.0f;
+    for (SINT i = samplesPerBuffer - tailCheckLength;
+            i < samplesPerBuffer;
+            ++i) {
+        differenceSum += std::abs(buffer_out[i] - buffer_in[i]);
+    }
+    // Calculate average of the differences
+    const float averageDifference = differenceSum / tailCheckLength;
+    return averageDifference;
+}
+
 void ReverbEffect::processChannel(
         ReverbGroupState* pState,
         const CSAMPLE* pInput,
@@ -89,7 +107,9 @@ void ReverbEffect::processChannel(
     const auto decay = static_cast<sample_t>(m_pDecayParameter->value());
     const auto bandwidth = static_cast<sample_t>(m_pBandWidthParameter->value());
     const auto damping = static_cast<sample_t>(m_pDampingParameter->value());
-    const auto sendCurrent = static_cast<sample_t>(m_pSendParameter->value());
+    const auto sendCurrent = enableState == EffectEnableState::Disabling
+            ? 0
+            : static_cast<sample_t>(m_pSendParameter->value());
 
     // Reinitialize the effect when turning it on to prevent replaying the old buffer
     // from the last time the effect was enabled.
@@ -98,6 +118,7 @@ void ReverbEffect::processChannel(
             pState->sampleRate != engineParameters.sampleRate()) {
         pState->reverb.init(engineParameters.sampleRate());
         pState->sampleRate = engineParameters.sampleRate();
+        m_isReadyForDisable = false;
     }
 
     pState->reverb.processBuffer(pInput,
@@ -109,13 +130,16 @@ void ReverbEffect::processChannel(
             sendCurrent,
             pState->sendPrevious);
 
-    // The ramping of the send parameter handles ramping when enabling, so
-    // this effect must handle ramping to dry when disabling itself (instead
-    // of being handled by EngineEffect::process).
     if (enableState == EffectEnableState::Disabling) {
-        SampleUtil::applyRampingGain(pOutput, 1.0, 0.0, engineParameters.samplesPerBuffer());
-        pState->sendPrevious = 0;
-    } else {
-        pState->sendPrevious = sendCurrent;
+        // Calculate absolute difference between wet and dry buffers for the tail
+        const SINT tailCheckLength = engineParameters.samplesPerBuffer() / 4;
+        const float averageDifference = averageSampleDifferenceEnergy(
+                engineParameters.samplesPerBuffer(),
+                pInput,
+                pOutput,
+                tailCheckLength);
+        if (averageDifference < 0.002f) {
+            m_isReadyForDisable = true;
+        }
     }
 }

src/effects/backends/builtin/reverbeffect.h

@@ -37,6 +37,9 @@ class ReverbEffect : public EffectProcessorImpl<ReverbGroupState> {
 
     static QString getId();
     static EffectManifestPointer getManifest();
+    bool isReadyForDisable() override {
+        return m_isReadyForDisable;
+    };
 
     void loadEngineEffectParameters(
             const QMap<QString, EngineEffectParameterPointer>& parameters) override;
@@ -54,10 +57,17 @@ class ReverbEffect : public EffectProcessorImpl<ReverbGroupState> {
         return getId();
     }
 
+    bool m_isReadyForDisable = false;
+
     EngineEffectParameterPointer m_pDecayParameter;
     EngineEffectParameterPointer m_pBandWidthParameter;
     EngineEffectParameterPointer m_pDampingParameter;
     EngineEffectParameterPointer m_pSendParameter;
 
     DISALLOW_COPY_AND_ASSIGN(ReverbEffect);
 };
+
+float averageSampleDifferenceEnergy(const SINT samplesPerBuffer,
+        const CSAMPLE* buffer_in,
+        const CSAMPLE* buffer_out,
+        const SINT tailCheckLength);

src/effects/backends/effectprocessor.h

@@ -110,6 +110,9 @@ class EffectProcessor {
     /// the dry signal is delayed to overlap with the output wet signal
     /// after processing all effects in the effects chain.
     virtual SINT getGroupDelayFrames() = 0;
+    virtual bool isReadyForDisable() {
+        return true;
+    };
 };
 
 /// EffectProcessorImpl manages a separate EffectState for every combination of

src/engine/effects/engineeffect.cpp

@@ -217,7 +217,7 @@ bool EngineEffect::process(const ChannelHandle& inputHandle,
     // Now that the EffectProcessor has been sent the intermediate enabling/disabling
     // signal, set the channel state to fully enabled/disabled for the next engine callback.
     EffectEnableState& effectOnChannelState = m_effectEnableStateForChannelMatrix[inputHandle][outputHandle];
-    if (effectOnChannelState == EffectEnableState::Disabling) {
+    if (effectOnChannelState == EffectEnableState::Disabling && m_pProcessor->isReadyForDisable()) {
         effectOnChannelState = EffectEnableState::Disabled;
     } else if (effectOnChannelState == EffectEnableState::Enabling) {
         effectOnChannelState = EffectEnableState::Enabled;