EFX: Autowah implementation

Add autowah effect using biquad peaking filter and envelope follower

7 files changed, 292 insertions, 3 deletions

diff --git a/Alc/ALc.c b/Alc/ALc.c
index 97d62812..535f9475 100644
--- a/Alc/ALc.c
+++ b/Alc/ALc.c
@@ -555,9 +555,7 @@ static const struct {
     DECL(AL_EFFECT_VOCAL_MORPHER),
 #endif
     DECL(AL_EFFECT_RING_MODULATOR),
-#if 0
     DECL(AL_EFFECT_AUTOWAH),
-#endif
     DECL(AL_EFFECT_COMPRESSOR),
     DECL(AL_EFFECT_EQUALIZER),
     DECL(AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT),
@@ -658,6 +656,11 @@ static const struct {
 
     DECL(AL_DEDICATED_GAIN),
 
+    DECL(AL_AUTOWAH_ATTACK_TIME),

+    DECL(AL_AUTOWAH_RELEASE_TIME),

+    DECL(AL_AUTOWAH_RESONANCE),

+    DECL(AL_AUTOWAH_PEAK_GAIN),
+
     DECL(AL_NUM_RESAMPLERS_SOFT),
     DECL(AL_DEFAULT_RESAMPLER_SOFT),
     DECL(AL_SOURCE_RESAMPLER_SOFT),
diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c
new file mode 100644
index 00000000..e9dbf304
--- /dev/null
+++ b/Alc/effects/autowah.c
@@ -0,0 +1,266 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2018 by Raul Herraiz.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+#include "filters/defs.h"
+
+#define MIN_FREQ 20.0f
+#define MAX_FREQ 2500.0f
+#define Q_FACTOR 5.0f
+
+
+typedef struct ALautowahState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    /* Effect parameters */
+    ALfloat AttackRate;
+    ALfloat ReleaseRate;
+    ALfloat ResonanceGain;
+    ALfloat PeakGain;
+    ALfloat FreqMinNorm;
+    ALfloat BandwidthNorm;
+    ALfloat env_delay;
+
+    BiquadFilter Filter;
+
+    /*Effects buffers*/ 
+    alignas(16) ALfloat BufferOut[BUFFERSIZE];
+
+    /* Effect gains for each output channel */
+    ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
+    ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
+} ALautowahState;
+
+static ALvoid ALautowahState_Destruct(ALautowahState *state);
+static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *device);
+static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
+static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+DECLARE_DEFAULT_ALLOCATORS(ALautowahState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALautowahState);
+
+/*Envelope follewer described on the book: Audio Effects, Theory, Implementation and Application*/
+static inline ALfloat envelope_follower(ALautowahState *state, ALfloat SampleIn)
+{
+    ALfloat alpha, Sample;
+
+    Sample =  state->PeakGain*fabsf(SampleIn);
+    alpha  = (Sample > state->env_delay) ? state->AttackRate : state->ReleaseRate;
+    state->env_delay = alpha*state->env_delay + (1.0f-alpha)*Sample;
+
+    return state->env_delay;
+}
+
+static void ALautowahState_Construct(ALautowahState *state)
+{
+    ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
+    SET_VTABLE2(ALautowahState, ALeffectState, state);
+}
+
+static ALvoid ALautowahState_Destruct(ALautowahState *state)
+{
+    ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
+}
+
+static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *UNUSED(device))
+{
+    /* (Re-)initializing parameters and clear the buffers. */
+    state->AttackRate    = 1.0f;
+    state->ReleaseRate   = 1.0f;
+    state->ResonanceGain = 10.0f;
+    state->PeakGain      = 4.5f;
+    state->FreqMinNorm   = 4.5e-4f;
+    state->BandwidthNorm = 0.05f;
+    state->env_delay     = 0.0f;
+
+    BiquadFilter_clear(&state->Filter);
+
+    memset(state->CurrentGains, 0, sizeof(state->CurrentGains));
+    memset(state->TargetGains,  0, sizeof(state->TargetGains));
+
+    return AL_TRUE;
+}
+
+static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+{
+    const ALCdevice *device = context->Device;
+    ALfloat coeffs[MAX_AMBI_COEFFS];
+    ALfloat ReleaseTime;
+
+    ReleaseTime = clampf(props->Autowah.ReleaseTime,0.001f,1.0f);
+
+    state->AttackRate    = expf(-1.0f/(props->Autowah.AttackTime*device->Frequency));
+    state->ReleaseRate   = expf(-1.0f/(ReleaseTime*device->Frequency));
+    state->ResonanceGain = 10.0f/3.0f*log10f(props->Autowah.Resonance);/*0-20dB Resonance Peak gain*/
+    state->PeakGain      = 1.0f -log10f(props->Autowah.PeakGain/AL_AUTOWAH_MAX_PEAK_GAIN);
+    state->FreqMinNorm   = MIN_FREQ/device->Frequency;
+    state->BandwidthNorm = (MAX_FREQ - MIN_FREQ)/device->Frequency;
+
+    CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
+    ComputeDryPanGains(&device->Dry, coeffs, slot->Params.Gain, state->TargetGains);
+}
+
+static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+{
+    ALfloat *restrict BufferOut = state->BufferOut;
+    ALsizei i;
+
+    for(i = 0;i < SamplesToDo;i++)
+    {
+        ALfloat env_out, f0norm, temp;
+
+        env_out = envelope_follower(state, SamplesIn[0][i]);
+        f0norm = state->BandwidthNorm*env_out + state->FreqMinNorm;
+
+        BiquadFilter_setParams(&state->Filter, BiquadType_Peaking, state->ResonanceGain,
+                               f0norm, 1.0f/Q_FACTOR);
+        BiquadFilter_process(&state->Filter, &temp, &SamplesIn[0][i], 1);
+
+        BufferOut[i] = temp;
+    }
+    /* Now, mix the processed sound data to the output. */
+    MixSamples(BufferOut, NumChannels, SamplesOut, state->CurrentGains, state->TargetGains,
+               SamplesToDo, 0, SamplesToDo);
+
+}
+
+typedef struct AutowahStateFactory {
+    DERIVE_FROM_TYPE(EffectStateFactory);
+} AutowahStateFactory;
+
+static ALeffectState *AutowahStateFactory_create(AutowahStateFactory *UNUSED(factory))
+{
+    ALautowahState *state;
+
+    NEW_OBJ0(state, ALautowahState)();
+    if(!state) return NULL;
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_EFFECTSTATEFACTORY_VTABLE(AutowahStateFactory);
+
+EffectStateFactory *AutowahStateFactory_getFactory(void)
+{
+    static AutowahStateFactory AutowahFactory = { { GET_VTABLE2(AutowahStateFactory, EffectStateFactory) } };
+
+    return STATIC_CAST(EffectStateFactory, &AutowahFactory);
+}
+
+void ALautowah_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_AUTOWAH_ATTACK_TIME:
+            if(!(val >= AL_AUTOWAH_MIN_ATTACK_TIME && val <= AL_AUTOWAH_MAX_ATTACK_TIME))
+                SETERR_RETURN(context, AL_INVALID_VALUE,,"Autowah attack time out of range");
+            props->Autowah.AttackTime = val;
+            break;
+
+        case AL_AUTOWAH_RELEASE_TIME:
+            if(!(val >= AL_AUTOWAH_MIN_RELEASE_TIME && val <= AL_AUTOWAH_MAX_RELEASE_TIME))
+                SETERR_RETURN(context, AL_INVALID_VALUE,,"Autowah release time out of range");
+            props->Autowah.ReleaseTime = val;
+            break;
+
+        case AL_AUTOWAH_RESONANCE:
+            if(!(val >= AL_AUTOWAH_MIN_RESONANCE && val <= AL_AUTOWAH_MAX_RESONANCE))
+                SETERR_RETURN(context, AL_INVALID_VALUE,,"Autowah resonance out of range");
+            props->Autowah.Resonance = val;
+            break;
+
+        case AL_AUTOWAH_PEAK_GAIN:
+            if(!(val >= AL_AUTOWAH_MIN_PEAK_GAIN && val <= AL_AUTOWAH_MAX_PEAK_GAIN))
+                SETERR_RETURN(context, AL_INVALID_VALUE,,"Autowah peak gain out of range");
+            props->Autowah.PeakGain = val;
+            break;
+
+        default:
+            alSetError(context, AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param);
+    }
+}
+
+void ALautowah_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALautowah_setParamf(effect, context, param, vals[0]);
+}
+
+void ALautowah_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
+{
+    alSetError(context, AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param);
+}
+
+void ALautowah_setParamiv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALint *UNUSED(vals))
+{
+    alSetError(context, AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x", param);
+}
+
+void ALautowah_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+{
+    alSetError(context, AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param);
+}
+void ALautowah_getParamiv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(vals))
+{
+    alSetError(context, AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x", param);
+}
+
+void ALautowah_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_AUTOWAH_ATTACK_TIME:
+            *val = props->Autowah.AttackTime;
+            break;
+
+        case AL_AUTOWAH_RELEASE_TIME:
+            *val = props->Autowah.ReleaseTime;
+            break;
+
+        case AL_AUTOWAH_RESONANCE:
+            *val = props->Autowah.Resonance;
+            break;
+
+        case AL_AUTOWAH_PEAK_GAIN:
+            *val = props->Autowah.PeakGain;
+            break;
+
+        default:
+            alSetError(context, AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param);
+    }
+
+}
+
+void ALautowah_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALautowah_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALautowah);
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b7de4a69..a7d13777 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -779,6 +779,7 @@ SET(ALC_OBJS
     Alc/mastering.h
     Alc/ringbuffer.c
     Alc/ringbuffer.h
+    Alc/effects/autowah.c
     Alc/effects/chorus.c
     Alc/effects/compressor.c
     Alc/effects/dedicated.c
diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h
index c1eae443..c4d662f1 100644
--- a/OpenAL32/Include/alAuxEffectSlot.h
+++ b/OpenAL32/Include/alAuxEffectSlot.h
@@ -160,6 +160,7 @@ ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);
 
 EffectStateFactory *NullStateFactory_getFactory(void);
 EffectStateFactory *ReverbStateFactory_getFactory(void);
+EffectStateFactory *AutowahStateFactory_getFactory(void);
 EffectStateFactory *ChorusStateFactory_getFactory(void);
 EffectStateFactory *CompressorStateFactory_getFactory(void);
 EffectStateFactory *DistortionStateFactory_getFactory(void);
diff --git a/OpenAL32/Include/alEffect.h b/OpenAL32/Include/alEffect.h
index 4d28a708..7b849c0c 100644
--- a/OpenAL32/Include/alEffect.h
+++ b/OpenAL32/Include/alEffect.h
@@ -12,6 +12,7 @@ struct ALeffect;
 enum {
     EAXREVERB_EFFECT = 0,
     REVERB_EFFECT,
+    AUTOWAH_EFFECT,
     CHORUS_EFFECT,
     COMPRESSOR_EFFECT,
     DISTORTION_EFFECT,
@@ -34,7 +35,7 @@ struct EffectList {
     int type;
     ALenum val;
 };
-#define EFFECTLIST_SIZE 13
+#define EFFECTLIST_SIZE 14
 extern const struct EffectList EffectList[EFFECTLIST_SIZE];
 
 
@@ -60,6 +61,7 @@ const struct ALeffectVtable T##_vtable = {  \
 
 extern const struct ALeffectVtable ALeaxreverb_vtable;
 extern const struct ALeffectVtable ALreverb_vtable;
+extern const struct ALeffectVtable ALautowah_vtable;
 extern const struct ALeffectVtable ALchorus_vtable;
 extern const struct ALeffectVtable ALcompressor_vtable;
 extern const struct ALeffectVtable ALdistortion_vtable;
@@ -104,6 +106,13 @@ typedef union ALeffectProps {
     } Reverb;
 
     struct {
+        ALfloat AttackTime;
+        ALfloat ReleaseTime;
+        ALfloat Resonance;
+        ALfloat PeakGain;
+    } Autowah;
+
+    struct {
         ALint Waveform;
         ALint Phase;
         ALfloat Rate;
diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c
index 6f6ef163..815a8d5a 100644
--- a/OpenAL32/alAuxEffectSlot.c
+++ b/OpenAL32/alAuxEffectSlot.c
@@ -48,6 +48,7 @@ static const struct {
     { AL_EFFECT_NULL, NullStateFactory_getFactory },
     { AL_EFFECT_EAXREVERB, ReverbStateFactory_getFactory },
     { AL_EFFECT_REVERB, ReverbStateFactory_getFactory },
+    { AL_EFFECT_AUTOWAH, AutowahStateFactory_getFactory },
     { AL_EFFECT_CHORUS, ChorusStateFactory_getFactory },
     { AL_EFFECT_COMPRESSOR, CompressorStateFactory_getFactory },
     { AL_EFFECT_DISTORTION, DistortionStateFactory_getFactory },
diff --git a/OpenAL32/alEffect.c b/OpenAL32/alEffect.c
index aacddd4c..c2a78a0c 100644
--- a/OpenAL32/alEffect.c
+++ b/OpenAL32/alEffect.c
@@ -38,6 +38,7 @@ extern inline ALboolean IsReverbEffect(ALenum type);
 const struct EffectList EffectList[EFFECTLIST_SIZE] = {
     { "eaxreverb",  EAXREVERB_EFFECT,  AL_EFFECT_EAXREVERB },
     { "reverb",     REVERB_EFFECT,     AL_EFFECT_REVERB },
+    { "autowah",    AUTOWAH_EFFECT,    AL_EFFECT_AUTOWAH },
     { "chorus",     CHORUS_EFFECT,     AL_EFFECT_CHORUS },
     { "compressor", COMPRESSOR_EFFECT, AL_EFFECT_COMPRESSOR },
     { "distortion", DISTORTION_EFFECT, AL_EFFECT_DISTORTION },
@@ -534,6 +535,13 @@ static void InitEffectParams(ALeffect *effect, ALenum type)
         effect->Props.Reverb.DecayHFLimit = AL_REVERB_DEFAULT_DECAY_HFLIMIT;
         effect->vtab = &ALreverb_vtable;
         break;
+    case AL_EFFECT_AUTOWAH:
+        effect->Props.Autowah.AttackTime = AL_AUTOWAH_DEFAULT_ATTACK_TIME;
+        effect->Props.Autowah.ReleaseTime = AL_AUTOWAH_DEFAULT_RELEASE_TIME;
+        effect->Props.Autowah.Resonance = AL_AUTOWAH_DEFAULT_RESONANCE;
+        effect->Props.Autowah.PeakGain = AL_AUTOWAH_DEFAULT_PEAK_GAIN;
+        effect->vtab = &ALautowah_vtable;
+        break;
     case AL_EFFECT_CHORUS:
         effect->Props.Chorus.Waveform = AL_CHORUS_DEFAULT_WAVEFORM;
         effect->Props.Chorus.Phase = AL_CHORUS_DEFAULT_PHASE;