summaryrefslogtreecommitdiffstats
path: root/Alc
diff options
context:
space:
mode:
Diffstat (limited to 'Alc')
-rw-r--r--Alc/ALc.c21
-rw-r--r--Alc/alcDistortion.c356
-rw-r--r--Alc/alcEqualizer.c446
3 files changed, 820 insertions, 3 deletions
diff --git a/Alc/ALc.c b/Alc/ALc.c
index e859a6c2..24c2fbe5 100644
--- a/Alc/ALc.c
+++ b/Alc/ALc.c
@@ -516,9 +516,7 @@ static const ALCenums enumeration[] = {
DECL(AL_EFFECT_REVERB),
DECL(AL_EFFECT_EAXREVERB),
DECL(AL_EFFECT_CHORUS),
-#if 0
DECL(AL_EFFECT_DISTORTION),
-#endif
DECL(AL_EFFECT_ECHO),
DECL(AL_EFFECT_FLANGER),
#if 0
@@ -530,8 +528,8 @@ static const ALCenums enumeration[] = {
#if 0
DECL(AL_EFFECT_AUTOWAH),
DECL(AL_EFFECT_COMPRESSOR),
- DECL(AL_EFFECT_EQUALIZER),
#endif
+ DECL(AL_EFFECT_EQUALIZER),
DECL(AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT),
DECL(AL_EFFECT_DEDICATED_DIALOGUE),
@@ -593,6 +591,23 @@ static const ALCenums enumeration[] = {
DECL(AL_FLANGER_FEEDBACK),
DECL(AL_FLANGER_DELAY),
+ DECL(AL_EQUALIZER_LOW_GAIN),
+ DECL(AL_EQUALIZER_LOW_CUTOFF),
+ DECL(AL_EQUALIZER_MID1_GAIN),
+ DECL(AL_EQUALIZER_MID1_CENTER),
+ DECL(AL_EQUALIZER_MID1_WIDTH),
+ DECL(AL_EQUALIZER_MID2_GAIN),
+ DECL(AL_EQUALIZER_MID2_CENTER),
+ DECL(AL_EQUALIZER_MID2_WIDTH),
+ DECL(AL_EQUALIZER_HIGH_GAIN),
+ DECL(AL_EQUALIZER_HIGH_CUTOFF),
+
+ DECL(AL_DISTORTION_EDGE),
+ DECL(AL_DISTORTION_GAIN),
+ DECL(AL_DISTORTION_LOWPASS_CUTOFF),
+ DECL(AL_DISTORTION_EQCENTER),
+ DECL(AL_DISTORTION_EQBANDWIDTH),
+
DECL(AL_RING_MODULATOR_FREQUENCY),
DECL(AL_RING_MODULATOR_HIGHPASS_CUTOFF),
DECL(AL_RING_MODULATOR_WAVEFORM),
diff --git a/Alc/alcDistortion.c b/Alc/alcDistortion.c
new file mode 100644
index 00000000..717c7b3a
--- /dev/null
+++ b/Alc/alcDistortion.c
@@ -0,0 +1,356 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Mike Gorchak
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+/* Filters implementation is based on the "Cookbook formulae for audio *
+ * EQ biquad filter coefficients" by Robert Bristow-Johnson *
+ * http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt */
+
+typedef enum ALEQFilterType {
+ LOWPASS,
+ BANDPASS,
+} ALEQFilterType;
+
+typedef struct ALEQFilter {
+ ALEQFilterType type;
+ ALfloat x[2]; /* History of two last input samples */
+ ALfloat y[2]; /* History of two last output samples */
+ ALfloat a[3]; /* Transfer function coefficients "a" */
+ ALfloat b[3]; /* Transfer function coefficients "b" */
+} ALEQFilter;
+
+typedef struct ALdistortionState {
+ /* Must be first in all effects! */
+ ALeffectState state;
+
+ /* Effect gains for each channel */
+ ALfloat Gain[MaxChannels];
+
+ /* Effect parameters */
+ ALEQFilter bandpass;
+ ALEQFilter lowpass;
+ ALfloat frequency;
+ ALfloat attenuation;
+ ALfloat edge;
+
+ /* Oversample data */
+ ALfloat oversample_buffer[BUFFERSIZE][4];
+} ALdistortionState;
+
+static ALvoid DistortionDestroy(ALeffectState *effect)
+{
+ ALdistortionState *state = (ALdistortionState*)effect;
+
+ free(state);
+}
+
+static ALboolean DistortionDeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+{
+ ALdistortionState *state = (ALdistortionState*)effect;
+
+ state->frequency = (ALfloat)Device->Frequency;
+
+ return AL_TRUE;
+}
+
+static ALvoid DistortionUpdate(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+{
+ ALdistortionState *state = (ALdistortionState*)effect;
+ ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain;
+ ALuint it;
+ ALfloat w0;
+ ALfloat alpha;
+ ALfloat bandwidth;
+ ALfloat cutoff;
+
+ for(it = 0; it < Device->NumChan; it++)
+ {
+ enum Channel chan = Device->Speaker2Chan[it];
+ state->Gain[chan] = gain;
+ }
+
+ /* Store distorted signal attenuation settings */
+ state->attenuation = Slot->effect.Distortion.Gain;
+
+ /* Store waveshaper edge settings */
+ state->edge = Slot->effect.Distortion.Edge;
+
+ /* Lowpass filter */
+ cutoff = Slot->effect.Distortion.LowpassCutoff;
+ /* Bandwidth value is constant in octaves */
+ bandwidth = (cutoff / 2.0f) / (cutoff * 0.67f);
+ w0 = 2.0f * F_PI * cutoff / (state->frequency * 4.0f);
+ alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
+ state->lowpass.b[0] = (1.0f - cosf(w0)) / 2.0f;
+ state->lowpass.b[1] = 1.0f - cosf(w0);
+ state->lowpass.b[2] = (1.0f - cosf(w0)) / 2.0f;
+ state->lowpass.a[0] = 1.0f + alpha;
+ state->lowpass.a[1] = -2.0f * cosf(w0);
+ state->lowpass.a[2] = 1.0f - alpha;
+
+ /* Bandpass filter */
+ cutoff = Slot->effect.Distortion.EQCenter;
+ /* Convert bandwidth in Hz to octaves */
+ bandwidth = Slot->effect.Distortion.EQBandwidth / (cutoff * 0.67f);
+ w0 = 2.0f * F_PI * cutoff / (state->frequency * 4.0f);
+ alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
+ state->bandpass.b[0] = alpha;
+ state->bandpass.b[1] = 0;
+ state->bandpass.b[2] = -alpha;
+ state->bandpass.a[0] = 1.0f + alpha;
+ state->bandpass.a[1] = -2.0f * cosf(w0);
+ state->bandpass.a[2] = 1.0f - alpha;
+}
+
+static ALvoid DistortionProcess(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+{
+ ALdistortionState *state = (ALdistortionState*)effect;
+ float *RESTRICT oversample_buffer = &state->oversample_buffer[0][0];
+ ALfloat tempsmp;
+ ALuint it;
+ ALuint kt;
+ ALuint st;
+
+ /* Perform 4x oversampling to avoid aliasing. */
+ /* Oversampling greatly improves distortion */
+ /* quality and allows to implement lowpass and */
+ /* bandpass filters using high frequencies, at */
+ /* which classic IIR filters became unstable. */
+
+ /* Fill oversample buffer using zero stuffing */
+ for(it = 0; it < SamplesToDo; it++)
+ {
+ oversample_buffer[it*4 + 0] = SamplesIn[it];
+ oversample_buffer[it*4 + 1] = 0.0f;
+ oversample_buffer[it*4 + 2] = 0.0f;
+ oversample_buffer[it*4 + 3] = 0.0f;
+ }
+
+ /* First step, do lowpass filtering of original signal, */
+ /* additionally perform buffer interpolation and lowpass */
+ /* cutoff for oversampling (which is fortunately first */
+ /* step of distortion). So combine three operations into */
+ /* the one. */
+ for(it = 0; it < SamplesToDo * 4; it++)
+ {
+ tempsmp = state->lowpass.b[0] / state->lowpass.a[0] * oversample_buffer[it] +
+ state->lowpass.b[1] / state->lowpass.a[0] * state->lowpass.x[0] +
+ state->lowpass.b[2] / state->lowpass.a[0] * state->lowpass.x[1] -
+ state->lowpass.a[1] / state->lowpass.a[0] * state->lowpass.y[0] -
+ state->lowpass.a[2] / state->lowpass.a[0] * state->lowpass.y[1];
+
+ state->lowpass.x[1] = state->lowpass.x[0];
+ state->lowpass.x[0] = oversample_buffer[it];
+ state->lowpass.y[1] = state->lowpass.y[0];
+ state->lowpass.y[0] = tempsmp;
+ /* Restore signal power by multiplying sample by amount of oversampling */
+ oversample_buffer[it] = tempsmp * 4.0f;
+ }
+
+ for(it = 0; it < SamplesToDo * 4; it++)
+ {
+ ALfloat smp = oversample_buffer[it];
+ ALfloat edge = sinf(state->edge * (F_PI / 2.0f));
+
+ /* Second step, do distortion using waveshaper function */
+ /* to emulate signal processing during tube overdriving. */
+ /* Three steps of waveshaping are intended to modify */
+ /* waveform without boost/clipping/attenuation process. */
+ for(st = 0; st < 3; st++)
+ {
+ smp = (1.0f + 2.0f * edge / (1.0f - edge)) * smp / (1.0f + 2.0f * edge / (1.0f - edge) * fabsf(smp));
+ if((st & 0x00000001) == 0x00000001)
+ smp *= -1.0f;
+ }
+
+ /* Third step, do bandpass filtering of distorted signal */
+ tempsmp = state->bandpass.b[0] / state->bandpass.a[0] * smp +
+ state->bandpass.b[1] / state->bandpass.a[0] * state->bandpass.x[0] +
+ state->bandpass.b[2] / state->bandpass.a[0] * state->bandpass.x[1] -
+ state->bandpass.a[1] / state->bandpass.a[0] * state->bandpass.y[0] -
+ state->bandpass.a[2] / state->bandpass.a[0] * state->bandpass.y[1];
+
+ state->bandpass.x[1] = state->bandpass.x[0];
+ state->bandpass.x[0] = smp;
+ state->bandpass.y[1] = state->bandpass.y[0];
+ state->bandpass.y[0] = tempsmp;
+ smp = tempsmp;
+
+ /* Fourth step, final, do attenuation and perform decimation, */
+ /* store only one sample out of 4. */
+ if(!(it & 0x00000003))
+ {
+ smp *= state->attenuation;
+ for(kt = 0; kt < MaxChannels; kt++)
+ SamplesOut[kt][it>>2] += state->Gain[kt] * smp;
+ }
+ }
+}
+
+ALeffectState *DistortionCreate(void)
+{
+ ALdistortionState *state;
+
+ state = malloc(sizeof(*state));
+ if(!state)
+ return NULL;
+
+ state->state.Destroy = DistortionDestroy;
+ state->state.DeviceUpdate = DistortionDeviceUpdate;
+ state->state.Update = DistortionUpdate;
+ state->state.Process = DistortionProcess;
+
+ state->bandpass.type = BANDPASS;
+ state->lowpass.type = LOWPASS;
+
+ /* Initialize sample history only on filter creation to avoid */
+ /* sound clicks if filter settings were changed in runtime. */
+ state->bandpass.x[0] = 0.0f;
+ state->bandpass.x[1] = 0.0f;
+ state->lowpass.y[0] = 0.0f;
+ state->lowpass.y[1] = 0.0f;
+
+ return &state->state;
+}
+
+void distortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+{
+ effect=effect;
+ val=val;
+
+ switch(param)
+ {
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void distortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+ distortion_SetParami(effect, context, param, vals[0]);
+}
+void distortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+ switch(param)
+ {
+ case AL_DISTORTION_EDGE:
+ if(val >= AL_DISTORTION_MIN_EDGE && val <= AL_DISTORTION_MAX_EDGE)
+ effect->Distortion.Edge = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_DISTORTION_GAIN:
+ if(val >= AL_DISTORTION_MIN_GAIN && val <= AL_DISTORTION_MAX_GAIN)
+ effect->Distortion.Gain = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_DISTORTION_LOWPASS_CUTOFF:
+ if(val >= AL_DISTORTION_MIN_LOWPASS_CUTOFF && val <= AL_DISTORTION_MAX_LOWPASS_CUTOFF)
+ effect->Distortion.LowpassCutoff = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_DISTORTION_EQCENTER:
+ if(val >= AL_DISTORTION_MIN_EQCENTER && val <= AL_DISTORTION_MAX_EQCENTER)
+ effect->Distortion.EQCenter = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_DISTORTION_EQBANDWIDTH:
+ if(val >= AL_DISTORTION_MIN_EQBANDWIDTH && val <= AL_DISTORTION_MAX_EQBANDWIDTH)
+ effect->Distortion.EQBandwidth = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void distortion_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+ distortion_SetParamf(effect, context, param, vals[0]);
+}
+
+void distortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+{
+ effect=effect;
+ val=val;
+
+ switch(param)
+ {
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void distortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+ distortion_GetParami(effect, context, param, vals);
+}
+void distortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+ switch(param)
+ {
+ case AL_DISTORTION_EDGE:
+ *val = effect->Distortion.Edge;
+ break;
+
+ case AL_DISTORTION_GAIN:
+ *val = effect->Distortion.Gain;
+ break;
+
+ case AL_DISTORTION_LOWPASS_CUTOFF:
+ *val = effect->Distortion.LowpassCutoff;
+ break;
+
+ case AL_DISTORTION_EQCENTER:
+ *val = effect->Distortion.EQCenter;
+ break;
+
+ case AL_DISTORTION_EQBANDWIDTH:
+ *val = effect->Distortion.EQBandwidth;
+ break;
+
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void distortion_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+ distortion_GetParamf(effect, context, param, vals);
+}
diff --git a/Alc/alcEqualizer.c b/Alc/alcEqualizer.c
new file mode 100644
index 00000000..2067c319
--- /dev/null
+++ b/Alc/alcEqualizer.c
@@ -0,0 +1,446 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Mike Gorchak
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+/* The document "Effects Extension Guide.pdf" says that low and high *
+ * frequencies are cutoff frequencies. This is not fully correct, they *
+ * are corner frequencies for low and high shelf filters. If they were *
+ * just cutoff frequencies, there would be no need in cutoff frequency *
+ * gains, which are present. Documentation for "Creative Proteus X2" *
+ * software describes 4-band equalizer functionality in a much better *
+ * way. This equalizer seems to be a predecessor of OpenAL 4-band *
+ * equalizer. With low and high shelf filters we are able to cutoff *
+ * frequencies below and/or above corner frequencies using attenuation *
+ * gains (below 1.0) and amplify all low and/or high frequencies using *
+ * gains above 1.0. *
+ * *
+ * Low-shelf Low Mid Band High Mid Band High-shelf *
+ * corner center center corner *
+ * frequency frequency frequency frequency *
+ * 50Hz..800Hz 200Hz..3000Hz 1000Hz..8000Hz 4000Hz..16000Hz *
+ * *
+ * | | | | *
+ * | | | | *
+ * B -----+ /--+--\ /--+--\ +----- *
+ * O |\ | | | | | | /| *
+ * O | \ - | - - | - / | *
+ * S + | \ | | | | | | / | *
+ * T | | | | | | | | | | *
+ * ---------+---------------+------------------+---------------+-------- *
+ * C | | | | | | | | | | *
+ * U - | / | | | | | | \ | *
+ * T | / - | - - | - \ | *
+ * O |/ | | | | | | \| *
+ * F -----+ \--+--/ \--+--/ +----- *
+ * F | | | | *
+ * | | | | *
+ * *
+ * Gains vary from 0.126 up to 7.943, which means from -18dB attenuation *
+ * up to +18dB amplification. Band width varies from 0.01 up to 1.0 in *
+ * octaves for two mid bands. *
+ * *
+ * Implementation is based on the "Cookbook formulae for audio EQ biquad *
+ * filter coefficients" by Robert Bristow-Johnson *
+ * http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt */
+
+typedef enum ALEQFilterType {
+ LOW_SHELF,
+ HIGH_SHELF,
+ PEAKING
+} ALEQFilterType;
+
+typedef struct ALEQFilter {
+ ALEQFilterType type;
+ ALfloat x[2]; /* History of two last input samples */
+ ALfloat y[2]; /* History of two last output samples */
+ ALfloat a[3]; /* Transfer function coefficients "a" */
+ ALfloat b[3]; /* Transfer function coefficients "b" */
+} ALEQFilter;
+
+typedef struct ALequalizerState {
+ /* Must be first in all effects! */
+ ALeffectState state;
+
+ /* Effect gains for each channel */
+ ALfloat Gain[MaxChannels];
+
+ /* Effect parameters */
+ ALEQFilter bandfilter[4];
+ ALfloat frequency;
+} ALequalizerState;
+
+static ALvoid EqualizerDestroy(ALeffectState *effect)
+{
+ ALequalizerState *state = (ALequalizerState*)effect;
+
+ free(state);
+}
+
+static ALboolean EqualizerDeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+{
+ ALequalizerState *state = (ALequalizerState*)effect;
+
+ state->frequency = (ALfloat)Device->Frequency;
+
+ return AL_TRUE;
+}
+
+static ALvoid EqualizerUpdate(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+{
+ ALequalizerState *state = (ALequalizerState*)effect;
+ ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain;
+ ALuint it;
+
+ for(it = 0; it < Device->NumChan; it++)
+ {
+ enum Channel chan = Device->Speaker2Chan[it];
+ state->Gain[chan] = gain;
+ }
+
+ /* Calculate coefficients for the each type of filter */
+ for(it = 0; it < 4; it++)
+ {
+ ALfloat gain;
+ ALfloat filter_frequency;
+ ALfloat bandwidth = 0.0f;
+ ALfloat w0;
+ ALfloat alpha = 0.0f;
+
+ /* convert linear gains to filter gains */
+ switch (it)
+ {
+ case 0: /* Low Shelf */
+ gain = powf(10.0f, (20.0f * log10f(Slot->effect.Equalizer.LowGain)) / 40.0f);
+ filter_frequency = Slot->effect.Equalizer.LowCutoff;
+ break;
+ case 1: /* Peaking */
+ gain = powf(10.0f, (20.0f * log10f(Slot->effect.Equalizer.Mid1Gain)) / 40.0f);
+ filter_frequency = Slot->effect.Equalizer.Mid1Center;
+ bandwidth = Slot->effect.Equalizer.Mid1Width;
+ break;
+ case 2: /* Peaking */
+ gain = powf(10.0f, (20.0f * log10f(Slot->effect.Equalizer.Mid2Gain)) / 40.0f);
+ filter_frequency = Slot->effect.Equalizer.Mid2Center;
+ bandwidth = Slot->effect.Equalizer.Mid2Width;
+ break;
+ case 3: /* High Shelf */
+ gain = powf(10.0f, (20.0f * log10f(Slot->effect.Equalizer.HighGain)) / 40.0f);
+ filter_frequency = Slot->effect.Equalizer.HighCutoff;
+ break;
+ }
+
+ w0 = 2.0f * F_PI * filter_frequency / state->frequency;
+
+ /* Calculate filter coefficients depending on filter type */
+ switch(state->bandfilter[it].type)
+ {
+ case LOW_SHELF:
+ alpha = sinf(w0) / 2.0f *
+ sqrtf((gain + 1.0f / gain) * (1.0f / 0.75f - 1.0f) + 2.0f);
+ state->bandfilter[it].b[0] = gain * ((gain + 1.0f) -
+ (gain - 1.0f) * cosf(w0) + 2.0f * sqrtf(gain) * alpha);
+ state->bandfilter[it].b[1] = 2.0f * gain * ((gain - 1.0f) -
+ (gain + 1.0f) * cosf(w0));
+ state->bandfilter[it].b[2] = gain * ((gain + 1.0f) -
+ (gain - 1.0f) * cosf(w0) - 2.0f * sqrtf(gain) * alpha);
+ state->bandfilter[it].a[0] = (gain + 1.0f) + (gain - 1.0f) *
+ cosf(w0) + 2.0f * sqrtf(gain) * alpha;
+ state->bandfilter[it].a[1] = -2.0f * ((gain - 1.0f) +
+ (gain + 1.0f) * cosf(w0));
+ state->bandfilter[it].a[2] = (gain + 1.0f) + (gain - 1.0f) *
+ cosf(w0) - 2.0f * sqrtf(gain) * alpha;
+ break;
+ case HIGH_SHELF:
+ alpha = sinf(w0) / 2.0f * sqrtf((gain + 1.0f / gain) *
+ (1.0f / 0.75f - 1.0f) + 2.0f);
+ state->bandfilter[it].b[0] = gain * ((gain + 1.0f) +
+ (gain - 1.0f) * cosf(w0) +
+ 2.0f * sqrtf(gain) * alpha);
+ state->bandfilter[it].b[1] = -2.0f * gain * ((gain - 1.0f) +
+ (gain + 1.0f) *
+ cosf(w0));
+ state->bandfilter[it].b[2] = gain * ((gain + 1.0f) +
+ (gain - 1.0f) * cosf(w0) -
+ 2.0f * sqrtf(gain) * alpha);
+ state->bandfilter[it].a[0] = (gain + 1.0f) -
+ (gain - 1.0f) * cosf(w0) +
+ 2.0f * sqrtf(gain) * alpha;
+ state->bandfilter[it].a[1] = 2.0f * ((gain - 1.0f) -
+ (gain + 1.0f) * cosf(w0));
+ state->bandfilter[it].a[2] = (gain + 1.0f) -
+ (gain - 1.0f) * cosf(w0) -
+ 2.0f * sqrtf(gain) * alpha;
+ break;
+ case PEAKING:
+ alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
+ state->bandfilter[it].b[0] = 1.0f + alpha * gain;
+ state->bandfilter[it].b[1] = -2.0f * cosf(w0);
+ state->bandfilter[it].b[2] = 1.0f - alpha * gain;
+ state->bandfilter[it].a[0] = 1.0f + alpha / gain;
+ state->bandfilter[it].a[1] = -2.0f * cosf(w0);
+ state->bandfilter[it].a[2] = 1.0f - alpha / gain;
+ break;
+ }
+ }
+}
+
+static ALvoid EqualizerProcess(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+{
+ ALequalizerState *state = (ALequalizerState*)effect;
+ ALuint it;
+ ALuint kt;
+ ALuint ft;
+
+ for (it = 0; it < SamplesToDo; it++)
+ {
+ ALfloat tempsmp;
+ ALfloat smp = SamplesIn[it];
+
+ for(ft = 0;ft < 4;ft++)
+ {
+ tempsmp = state->bandfilter[ft].b[0] / state->bandfilter[ft].a[0] * smp +
+ state->bandfilter[ft].b[1] / state->bandfilter[ft].a[0] * state->bandfilter[ft].x[0] +
+ state->bandfilter[ft].b[2] / state->bandfilter[ft].a[0] * state->bandfilter[ft].x[1] -
+ state->bandfilter[ft].a[1] / state->bandfilter[ft].a[0] * state->bandfilter[ft].y[0] -
+ state->bandfilter[ft].a[2] / state->bandfilter[ft].a[0] * state->bandfilter[ft].y[1];
+
+ state->bandfilter[ft].x[1] = state->bandfilter[ft].x[0];
+ state->bandfilter[ft].x[0] = smp;
+ state->bandfilter[ft].y[1] = state->bandfilter[ft].y[0];
+ state->bandfilter[ft].y[0] = tempsmp;
+ smp = tempsmp;
+ }
+
+ for(kt = 0;kt < MaxChannels;kt++)
+ SamplesOut[kt][it] += state->Gain[kt] * smp;
+ }
+}
+
+ALeffectState *EqualizerCreate(void)
+{
+ ALequalizerState *state;
+ int it;
+
+ state = malloc(sizeof(*state));
+ if(!state)
+ return NULL;
+
+ state->state.Destroy = EqualizerDestroy;
+ state->state.DeviceUpdate = EqualizerDeviceUpdate;
+ state->state.Update = EqualizerUpdate;
+ state->state.Process = EqualizerProcess;
+
+ state->bandfilter[0].type = LOW_SHELF;
+ state->bandfilter[1].type = PEAKING;
+ state->bandfilter[2].type = PEAKING;
+ state->bandfilter[3].type = HIGH_SHELF;
+
+ /* Initialize sample history only on filter creation to avoid */
+ /* sound clicks if filter settings were changed in runtime. */
+ for(it = 0; it < 4; it++)
+ {
+ state->bandfilter[it].x[0] = 0.0f;
+ state->bandfilter[it].x[1] = 0.0f;
+ state->bandfilter[it].y[0] = 0.0f;
+ state->bandfilter[it].y[1] = 0.0f;
+ }
+
+ return &state->state;
+}
+
+void equalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+{
+ effect=effect;
+ val=val;
+
+ switch(param)
+ {
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void equalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+ equalizer_SetParami(effect, context, param, vals[0]);
+}
+void equalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+ switch(param)
+ {
+ case AL_EQUALIZER_LOW_GAIN:
+ if(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN)
+ effect->Equalizer.LowGain = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_LOW_CUTOFF:
+ if(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF)
+ effect->Equalizer.LowCutoff = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_MID1_GAIN:
+ if(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN)
+ effect->Equalizer.Mid1Gain = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_MID1_CENTER:
+ if(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER)
+ effect->Equalizer.Mid1Center = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_MID1_WIDTH:
+ if(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH)
+ effect->Equalizer.Mid1Width = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_MID2_GAIN:
+ if(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN)
+ effect->Equalizer.Mid2Gain = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_MID2_CENTER:
+ if(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER)
+ effect->Equalizer.Mid2Center = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_MID2_WIDTH:
+ if(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH)
+ effect->Equalizer.Mid2Width = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_HIGH_GAIN:
+ if(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN)
+ effect->Equalizer.HighGain = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ case AL_EQUALIZER_HIGH_CUTOFF:
+ if(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF)
+ effect->Equalizer.HighCutoff = val;
+ else
+ alSetError(context, AL_INVALID_VALUE);
+ break;
+
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void equalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+ equalizer_SetParamf(effect, context, param, vals[0]);
+}
+
+void equalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+{
+ effect=effect;
+ val=val;
+
+ switch(param)
+ {
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void equalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+ equalizer_GetParami(effect, context, param, vals);
+}
+void equalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+ switch(param)
+ {
+ case AL_EQUALIZER_LOW_GAIN:
+ *val = effect->Equalizer.LowGain;
+ break;
+
+ case AL_EQUALIZER_LOW_CUTOFF:
+ *val = effect->Equalizer.LowCutoff;
+ break;
+
+ case AL_EQUALIZER_MID1_GAIN:
+ *val = effect->Equalizer.Mid1Gain;
+ break;
+
+ case AL_EQUALIZER_MID1_CENTER:
+ *val = effect->Equalizer.Mid1Center;
+ break;
+
+ case AL_EQUALIZER_MID1_WIDTH:
+ *val = effect->Equalizer.Mid1Width;
+ break;
+
+ case AL_EQUALIZER_MID2_GAIN:
+ *val = effect->Equalizer.Mid2Gain;
+ break;
+
+ case AL_EQUALIZER_MID2_CENTER:
+ *val = effect->Equalizer.Mid2Center;
+ break;
+
+ case AL_EQUALIZER_MID2_WIDTH:
+ *val = effect->Equalizer.Mid2Width;
+ break;
+
+ case AL_EQUALIZER_HIGH_GAIN:
+ *val = effect->Equalizer.HighGain;
+ break;
+
+ case AL_EQUALIZER_HIGH_CUTOFF:
+ *val = effect->Equalizer.HighCutoff;
+ break;
+
+ default:
+ alSetError(context, AL_INVALID_ENUM);
+ break;
+ }
+}
+void equalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+ equalizer_GetParamf(effect, context, param, vals);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-13 04:37:45 +0000