aboutsummaryrefslogtreecommitdiffstats
path: root/Alc/effects
diff options
context:
space:
mode:
Diffstat (limited to 'Alc/effects')
-rw-r--r--Alc/effects/autowah.c321
-rw-r--r--Alc/effects/chorus.c555
-rw-r--r--Alc/effects/compressor.c243
-rw-r--r--Alc/effects/dedicated.c184
-rw-r--r--Alc/effects/distortion.c286
-rw-r--r--Alc/effects/echo.c310
-rw-r--r--Alc/effects/equalizer.c355
-rw-r--r--Alc/effects/fshifter.c329
-rw-r--r--Alc/effects/modulator.c307
-rw-r--r--Alc/effects/null.c179
-rw-r--r--Alc/effects/pshifter.c441
-rw-r--r--Alc/effects/reverb.c2090
12 files changed, 0 insertions, 5600 deletions
diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c
deleted file mode 100644
index ba1180ef..00000000
--- a/Alc/effects/autowah.c
+++ /dev/null
@@ -1,321 +0,0 @@
-/**
- * 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;
-
- /* Filter components derived from the envelope. */
- struct {
- ALfloat cos_w0;
- ALfloat alpha;
- } Env[BUFFERSIZE];
-
- struct {
- /* Effect filters' history. */
- struct {
- ALfloat z1, z2;
- } Filter;
-
- /* Effect gains for each output channel */
- ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
- ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
- } Chans[MAX_EFFECT_CHANNELS];
-
- /* Effects buffers */
- alignas(16) ALfloat BufferOut[BUFFERSIZE];
-} 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);
-
-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. */
- ALsizei i, j;
-
- 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;
-
- memset(state->Env, 0, sizeof(state->Env));
-
- for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
- {
- for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
- state->Chans[i].CurrentGains[j] = 0.0f;
- state->Chans[i].Filter.z1 = 0.0f;
- state->Chans[i].Filter.z2 = 0.0f;
- }
-
- return AL_TRUE;
-}
-
-static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALfloat ReleaseTime;
- ALsizei i;
-
- 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));
- /* 0-20dB Resonance Peak gain */
- state->ResonanceGain = sqrtf(log10f(props->Autowah.Resonance)*10.0f / 3.0f);
- 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;
-
- STATIC_CAST(ALeffectState,state)->OutBuffer = device->FOAOut.Buffer;
- STATIC_CAST(ALeffectState,state)->OutChannels = device->FOAOut.NumChannels;
- for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
- ComputePanGains(&device->FOAOut, IdentityMatrixf.m[i], slot->Params.Gain,
- state->Chans[i].TargetGains);
-}
-
-static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- const ALfloat attack_rate = state->AttackRate;
- const ALfloat release_rate = state->ReleaseRate;
- const ALfloat res_gain = state->ResonanceGain;
- const ALfloat peak_gain = state->PeakGain;
- const ALfloat freq_min = state->FreqMinNorm;
- const ALfloat bandwidth = state->BandwidthNorm;
- ALfloat env_delay;
- ALsizei c, i;
-
- env_delay = state->env_delay;
- for(i = 0;i < SamplesToDo;i++)
- {
- ALfloat w0, sample, a;
-
- /* Envelope follower described on the book: Audio Effects, Theory,
- * Implementation and Application.
- */
- sample = peak_gain * fabsf(SamplesIn[0][i]);
- a = (sample > env_delay) ? attack_rate : release_rate;
- env_delay = lerp(sample, env_delay, a);
-
- /* Calculate the cos and alpha components for this sample's filter. */
- w0 = minf((bandwidth*env_delay + freq_min), 0.46f) * F_TAU;
- state->Env[i].cos_w0 = cosf(w0);
- state->Env[i].alpha = sinf(w0)/(2.0f * Q_FACTOR);
- }
- state->env_delay = env_delay;
-
- for(c = 0;c < MAX_EFFECT_CHANNELS; c++)
- {
- /* This effectively inlines BiquadFilter_setParams for a peaking
- * filter and BiquadFilter_processC. The alpha and cosine components
- * for the filter coefficients were previously calculated with the
- * envelope. Because the filter changes for each sample, the
- * coefficients are transient and don't need to be held.
- */
- ALfloat z1 = state->Chans[c].Filter.z1;
- ALfloat z2 = state->Chans[c].Filter.z2;
-
- for(i = 0;i < SamplesToDo;i++)
- {
- const ALfloat alpha = state->Env[i].alpha;
- const ALfloat cos_w0 = state->Env[i].cos_w0;
- ALfloat input, output;
- ALfloat a[3], b[3];
-
- b[0] = 1.0f + alpha*res_gain;
- b[1] = -2.0f * cos_w0;
- b[2] = 1.0f - alpha*res_gain;
- a[0] = 1.0f + alpha/res_gain;
- a[1] = -2.0f * cos_w0;
- a[2] = 1.0f - alpha/res_gain;
-
- input = SamplesIn[c][i];
- output = input*(b[0]/a[0]) + z1;
- z1 = input*(b[1]/a[0]) - output*(a[1]/a[0]) + z2;
- z2 = input*(b[2]/a[0]) - output*(a[2]/a[0]);
- state->BufferOut[i] = output;
- }
- state->Chans[c].Filter.z1 = z1;
- state->Chans[c].Filter.z2 = z2;
-
- /* Now, mix the processed sound data to the output. */
- MixSamples(state->BufferOut, NumChannels, SamplesOut, state->Chans[c].CurrentGains,
- state->Chans[c].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 *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(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/Alc/effects/chorus.c b/Alc/effects/chorus.c
deleted file mode 100644
index f2861cf5..00000000
--- a/Alc/effects/chorus.c
+++ /dev/null
@@ -1,555 +0,0 @@
-/**
- * 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.,
- * 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"
-
-
-static_assert(AL_CHORUS_WAVEFORM_SINUSOID == AL_FLANGER_WAVEFORM_SINUSOID, "Chorus/Flanger waveform value mismatch");
-static_assert(AL_CHORUS_WAVEFORM_TRIANGLE == AL_FLANGER_WAVEFORM_TRIANGLE, "Chorus/Flanger waveform value mismatch");
-
-enum WaveForm {
- WF_Sinusoid,
- WF_Triangle
-};
-
-typedef struct ALchorusState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- ALfloat *SampleBuffer;
- ALsizei BufferLength;
- ALsizei offset;
-
- ALsizei lfo_offset;
- ALsizei lfo_range;
- ALfloat lfo_scale;
- ALint lfo_disp;
-
- /* Gains for left and right sides */
- struct {
- ALfloat Current[MAX_OUTPUT_CHANNELS];
- ALfloat Target[MAX_OUTPUT_CHANNELS];
- } Gains[2];
-
- /* effect parameters */
- enum WaveForm waveform;
- ALint delay;
- ALfloat depth;
- ALfloat feedback;
-} ALchorusState;
-
-static ALvoid ALchorusState_Destruct(ALchorusState *state);
-static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device);
-static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props);
-static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALchorusState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState);
-
-
-static void ALchorusState_Construct(ALchorusState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALchorusState, ALeffectState, state);
-
- state->BufferLength = 0;
- state->SampleBuffer = NULL;
- state->offset = 0;
- state->lfo_offset = 0;
- state->lfo_range = 1;
- state->waveform = WF_Triangle;
-}
-
-static ALvoid ALchorusState_Destruct(ALchorusState *state)
-{
- al_free(state->SampleBuffer);
- state->SampleBuffer = NULL;
-
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device)
-{
- const ALfloat max_delay = maxf(AL_CHORUS_MAX_DELAY, AL_FLANGER_MAX_DELAY);
- ALsizei maxlen;
-
- maxlen = NextPowerOf2(float2int(max_delay*2.0f*Device->Frequency) + 1u);
- if(maxlen <= 0) return AL_FALSE;
-
- if(maxlen != state->BufferLength)
- {
- void *temp = al_calloc(16, maxlen * sizeof(ALfloat));
- if(!temp) return AL_FALSE;
-
- al_free(state->SampleBuffer);
- state->SampleBuffer = temp;
-
- state->BufferLength = maxlen;
- }
-
- memset(state->SampleBuffer, 0, state->BufferLength*sizeof(ALfloat));
- memset(state->Gains, 0, sizeof(state->Gains));
-
- return AL_TRUE;
-}
-
-static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props)
-{
- const ALsizei mindelay = MAX_RESAMPLE_PADDING << FRACTIONBITS;
- const ALCdevice *device = Context->Device;
- ALfloat frequency = (ALfloat)device->Frequency;
- ALfloat coeffs[MAX_AMBI_COEFFS];
- ALfloat rate;
- ALint phase;
-
- switch(props->Chorus.Waveform)
- {
- case AL_CHORUS_WAVEFORM_TRIANGLE:
- state->waveform = WF_Triangle;
- break;
- case AL_CHORUS_WAVEFORM_SINUSOID:
- state->waveform = WF_Sinusoid;
- break;
- }
-
- /* The LFO depth is scaled to be relative to the sample delay. Clamp the
- * delay and depth to allow enough padding for resampling.
- */
- state->delay = maxi(float2int(props->Chorus.Delay*frequency*FRACTIONONE + 0.5f),
- mindelay);
- state->depth = minf(props->Chorus.Depth * state->delay,
- (ALfloat)(state->delay - mindelay));
-
- state->feedback = props->Chorus.Feedback;
-
- /* Gains for left and right sides */
- CalcAngleCoeffs(-F_PI_2, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, Slot->Params.Gain, state->Gains[0].Target);
- CalcAngleCoeffs( F_PI_2, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, Slot->Params.Gain, state->Gains[1].Target);
-
- phase = props->Chorus.Phase;
- rate = props->Chorus.Rate;
- if(!(rate > 0.0f))
- {
- state->lfo_offset = 0;
- state->lfo_range = 1;
- state->lfo_scale = 0.0f;
- state->lfo_disp = 0;
- }
- else
- {
- /* Calculate LFO coefficient (number of samples per cycle). Limit the
- * max range to avoid overflow when calculating the displacement.
- */
- ALsizei lfo_range = float2int(minf(frequency/rate + 0.5f, (ALfloat)(INT_MAX/360 - 180)));
-
- state->lfo_offset = float2int((ALfloat)state->lfo_offset/state->lfo_range*
- lfo_range + 0.5f) % lfo_range;
- state->lfo_range = lfo_range;
- switch(state->waveform)
- {
- case WF_Triangle:
- state->lfo_scale = 4.0f / state->lfo_range;
- break;
- case WF_Sinusoid:
- state->lfo_scale = F_TAU / state->lfo_range;
- break;
- }
-
- /* Calculate lfo phase displacement */
- if(phase < 0) phase = 360 + phase;
- state->lfo_disp = (state->lfo_range*phase + 180) / 360;
- }
-}
-
-static void GetTriangleDelays(ALint *restrict delays, ALsizei offset, const ALsizei lfo_range,
- const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay,
- const ALsizei todo)
-{
- ALsizei i;
- for(i = 0;i < todo;i++)
- {
- delays[i] = fastf2i((1.0f - fabsf(2.0f - lfo_scale*offset)) * depth) + delay;
- offset = (offset+1)%lfo_range;
- }
-}
-
-static void GetSinusoidDelays(ALint *restrict delays, ALsizei offset, const ALsizei lfo_range,
- const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay,
- const ALsizei todo)
-{
- ALsizei i;
- for(i = 0;i < todo;i++)
- {
- delays[i] = fastf2i(sinf(lfo_scale*offset) * depth) + delay;
- offset = (offset+1)%lfo_range;
- }
-}
-
-
-static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- const ALsizei bufmask = state->BufferLength-1;
- const ALfloat feedback = state->feedback;
- const ALsizei avgdelay = (state->delay + (FRACTIONONE>>1)) >> FRACTIONBITS;
- ALfloat *restrict delaybuf = state->SampleBuffer;
- ALsizei offset = state->offset;
- ALsizei i, c;
- ALsizei base;
-
- for(base = 0;base < SamplesToDo;)
- {
- const ALsizei todo = mini(256, SamplesToDo-base);
- ALint moddelays[2][256];
- alignas(16) ALfloat temps[2][256];
-
- if(state->waveform == WF_Sinusoid)
- {
- GetSinusoidDelays(moddelays[0], state->lfo_offset, state->lfo_range, state->lfo_scale,
- state->depth, state->delay, todo);
- GetSinusoidDelays(moddelays[1], (state->lfo_offset+state->lfo_disp)%state->lfo_range,
- state->lfo_range, state->lfo_scale, state->depth, state->delay,
- todo);
- }
- else /*if(state->waveform == WF_Triangle)*/
- {
- GetTriangleDelays(moddelays[0], state->lfo_offset, state->lfo_range, state->lfo_scale,
- state->depth, state->delay, todo);
- GetTriangleDelays(moddelays[1], (state->lfo_offset+state->lfo_disp)%state->lfo_range,
- state->lfo_range, state->lfo_scale, state->depth, state->delay,
- todo);
- }
- state->lfo_offset = (state->lfo_offset+todo) % state->lfo_range;
-
- for(i = 0;i < todo;i++)
- {
- ALint delay;
- ALfloat mu;
-
- // Feed the buffer's input first (necessary for delays < 1).
- delaybuf[offset&bufmask] = SamplesIn[0][base+i];
-
- // Tap for the left output.
- delay = offset - (moddelays[0][i]>>FRACTIONBITS);
- mu = (moddelays[0][i]&FRACTIONMASK) * (1.0f/FRACTIONONE);
- temps[0][i] = cubic(delaybuf[(delay+1) & bufmask], delaybuf[(delay ) & bufmask],
- delaybuf[(delay-1) & bufmask], delaybuf[(delay-2) & bufmask],
- mu);
-
- // Tap for the right output.
- delay = offset - (moddelays[1][i]>>FRACTIONBITS);
- mu = (moddelays[1][i]&FRACTIONMASK) * (1.0f/FRACTIONONE);
- temps[1][i] = cubic(delaybuf[(delay+1) & bufmask], delaybuf[(delay ) & bufmask],
- delaybuf[(delay-1) & bufmask], delaybuf[(delay-2) & bufmask],
- mu);
-
- // Accumulate feedback from the average delay of the taps.
- delaybuf[offset&bufmask] += delaybuf[(offset-avgdelay) & bufmask] * feedback;
- offset++;
- }
-
- for(c = 0;c < 2;c++)
- MixSamples(temps[c], NumChannels, SamplesOut, state->Gains[c].Current,
- state->Gains[c].Target, SamplesToDo-base, base, todo);
-
- base += todo;
- }
-
- state->offset = offset;
-}
-
-
-typedef struct ChorusStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} ChorusStateFactory;
-
-static ALeffectState *ChorusStateFactory_create(ChorusStateFactory *UNUSED(factory))
-{
- ALchorusState *state;
-
- NEW_OBJ0(state, ALchorusState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(ChorusStateFactory);
-
-
-EffectStateFactory *ChorusStateFactory_getFactory(void)
-{
- static ChorusStateFactory ChorusFactory = { { GET_VTABLE2(ChorusStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &ChorusFactory);
-}
-
-
-void ALchorus_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_CHORUS_WAVEFORM:
- if(!(val >= AL_CHORUS_MIN_WAVEFORM && val <= AL_CHORUS_MAX_WAVEFORM))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid chorus waveform");
- props->Chorus.Waveform = val;
- break;
-
- case AL_CHORUS_PHASE:
- if(!(val >= AL_CHORUS_MIN_PHASE && val <= AL_CHORUS_MAX_PHASE))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus phase out of range");
- props->Chorus.Phase = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param);
- }
-}
-void ALchorus_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{ ALchorus_setParami(effect, context, param, vals[0]); }
-void ALchorus_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_CHORUS_RATE:
- if(!(val >= AL_CHORUS_MIN_RATE && val <= AL_CHORUS_MAX_RATE))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus rate out of range");
- props->Chorus.Rate = val;
- break;
-
- case AL_CHORUS_DEPTH:
- if(!(val >= AL_CHORUS_MIN_DEPTH && val <= AL_CHORUS_MAX_DEPTH))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus depth out of range");
- props->Chorus.Depth = val;
- break;
-
- case AL_CHORUS_FEEDBACK:
- if(!(val >= AL_CHORUS_MIN_FEEDBACK && val <= AL_CHORUS_MAX_FEEDBACK))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus feedback out of range");
- props->Chorus.Feedback = val;
- break;
-
- case AL_CHORUS_DELAY:
- if(!(val >= AL_CHORUS_MIN_DELAY && val <= AL_CHORUS_MAX_DELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus delay out of range");
- props->Chorus.Delay = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param);
- }
-}
-void ALchorus_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALchorus_setParamf(effect, context, param, vals[0]); }
-
-void ALchorus_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_CHORUS_WAVEFORM:
- *val = props->Chorus.Waveform;
- break;
-
- case AL_CHORUS_PHASE:
- *val = props->Chorus.Phase;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param);
- }
-}
-void ALchorus_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{ ALchorus_getParami(effect, context, param, vals); }
-void ALchorus_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_CHORUS_RATE:
- *val = props->Chorus.Rate;
- break;
-
- case AL_CHORUS_DEPTH:
- *val = props->Chorus.Depth;
- break;
-
- case AL_CHORUS_FEEDBACK:
- *val = props->Chorus.Feedback;
- break;
-
- case AL_CHORUS_DELAY:
- *val = props->Chorus.Delay;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param);
- }
-}
-void ALchorus_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALchorus_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALchorus);
-
-
-/* Flanger is basically a chorus with a really short delay. They can both use
- * the same processing functions, so piggyback flanger on the chorus functions.
- */
-typedef struct FlangerStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} FlangerStateFactory;
-
-ALeffectState *FlangerStateFactory_create(FlangerStateFactory *UNUSED(factory))
-{
- ALchorusState *state;
-
- NEW_OBJ0(state, ALchorusState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(FlangerStateFactory);
-
-EffectStateFactory *FlangerStateFactory_getFactory(void)
-{
- static FlangerStateFactory FlangerFactory = { { GET_VTABLE2(FlangerStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &FlangerFactory);
-}
-
-
-void ALflanger_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FLANGER_WAVEFORM:
- if(!(val >= AL_FLANGER_MIN_WAVEFORM && val <= AL_FLANGER_MAX_WAVEFORM))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid flanger waveform");
- props->Chorus.Waveform = val;
- break;
-
- case AL_FLANGER_PHASE:
- if(!(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger phase out of range");
- props->Chorus.Phase = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param);
- }
-}
-void ALflanger_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{ ALflanger_setParami(effect, context, param, vals[0]); }
-void ALflanger_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FLANGER_RATE:
- if(!(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger rate out of range");
- props->Chorus.Rate = val;
- break;
-
- case AL_FLANGER_DEPTH:
- if(!(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger depth out of range");
- props->Chorus.Depth = val;
- break;
-
- case AL_FLANGER_FEEDBACK:
- if(!(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger feedback out of range");
- props->Chorus.Feedback = val;
- break;
-
- case AL_FLANGER_DELAY:
- if(!(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger delay out of range");
- props->Chorus.Delay = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param);
- }
-}
-void ALflanger_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALflanger_setParamf(effect, context, param, vals[0]); }
-
-void ALflanger_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FLANGER_WAVEFORM:
- *val = props->Chorus.Waveform;
- break;
-
- case AL_FLANGER_PHASE:
- *val = props->Chorus.Phase;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param);
- }
-}
-void ALflanger_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{ ALflanger_getParami(effect, context, param, vals); }
-void ALflanger_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FLANGER_RATE:
- *val = props->Chorus.Rate;
- break;
-
- case AL_FLANGER_DEPTH:
- *val = props->Chorus.Depth;
- break;
-
- case AL_FLANGER_FEEDBACK:
- *val = props->Chorus.Feedback;
- break;
-
- case AL_FLANGER_DELAY:
- *val = props->Chorus.Delay;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param);
- }
-}
-void ALflanger_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALflanger_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALflanger);
diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c
deleted file mode 100644
index 2b4a76b0..00000000
--- a/Alc/effects/compressor.c
+++ /dev/null
@@ -1,243 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2013 by Anis A. Hireche
- * 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 <stdlib.h>
-
-#include "config.h"
-#include "alError.h"
-#include "alMain.h"
-#include "alAuxEffectSlot.h"
-#include "alu.h"
-
-
-#define AMP_ENVELOPE_MIN 0.5f
-#define AMP_ENVELOPE_MAX 2.0f
-
-#define ATTACK_TIME 0.1f /* 100ms to rise from min to max */
-#define RELEASE_TIME 0.2f /* 200ms to drop from max to min */
-
-
-typedef struct ALcompressorState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- /* Effect gains for each channel */
- ALfloat Gain[MAX_EFFECT_CHANNELS][MAX_OUTPUT_CHANNELS];
-
- /* Effect parameters */
- ALboolean Enabled;
- ALfloat AttackMult;
- ALfloat ReleaseMult;
- ALfloat EnvFollower;
-} ALcompressorState;
-
-static ALvoid ALcompressorState_Destruct(ALcompressorState *state);
-static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device);
-static ALvoid ALcompressorState_update(ALcompressorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALcompressorState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState);
-
-
-static void ALcompressorState_Construct(ALcompressorState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALcompressorState, ALeffectState, state);
-
- state->Enabled = AL_TRUE;
- state->AttackMult = 1.0f;
- state->ReleaseMult = 1.0f;
- state->EnvFollower = 1.0f;
-}
-
-static ALvoid ALcompressorState_Destruct(ALcompressorState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device)
-{
- /* Number of samples to do a full attack and release (non-integer sample
- * counts are okay).
- */
- const ALfloat attackCount = (ALfloat)device->Frequency * ATTACK_TIME;
- const ALfloat releaseCount = (ALfloat)device->Frequency * RELEASE_TIME;
-
- /* Calculate per-sample multipliers to attack and release at the desired
- * rates.
- */
- state->AttackMult = powf(AMP_ENVELOPE_MAX/AMP_ENVELOPE_MIN, 1.0f/attackCount);
- state->ReleaseMult = powf(AMP_ENVELOPE_MIN/AMP_ENVELOPE_MAX, 1.0f/releaseCount);
-
- return AL_TRUE;
-}
-
-static ALvoid ALcompressorState_update(ALcompressorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALuint i;
-
- state->Enabled = props->Compressor.OnOff;
-
- STATIC_CAST(ALeffectState,state)->OutBuffer = device->FOAOut.Buffer;
- STATIC_CAST(ALeffectState,state)->OutChannels = device->FOAOut.NumChannels;
- for(i = 0;i < 4;i++)
- ComputePanGains(&device->FOAOut, IdentityMatrixf.m[i], slot->Params.Gain, state->Gain[i]);
-}
-
-static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- ALsizei i, j, k;
- ALsizei base;
-
- for(base = 0;base < SamplesToDo;)
- {
- ALfloat gains[256];
- ALsizei td = mini(256, SamplesToDo-base);
- ALfloat env = state->EnvFollower;
-
- /* Generate the per-sample gains from the signal envelope. */
- if(state->Enabled)
- {
- for(i = 0;i < td;++i)
- {
- /* Clamp the absolute amplitude to the defined envelope limits,
- * then attack or release the envelope to reach it.
- */
- ALfloat amplitude = clampf(fabsf(SamplesIn[0][base+i]),
- AMP_ENVELOPE_MIN, AMP_ENVELOPE_MAX);
- if(amplitude > env)
- env = minf(env*state->AttackMult, amplitude);
- else if(amplitude < env)
- env = maxf(env*state->ReleaseMult, amplitude);
-
- /* Apply the reciprocal of the envelope to normalize the volume
- * (compress the dynamic range).
- */
- gains[i] = 1.0f / env;
- }
- }
- else
- {
- /* Same as above, except the amplitude is forced to 1. This helps
- * ensure smooth gain changes when the compressor is turned on and
- * off.
- */
- for(i = 0;i < td;++i)
- {
- ALfloat amplitude = 1.0f;
- if(amplitude > env)
- env = minf(env*state->AttackMult, amplitude);
- else if(amplitude < env)
- env = maxf(env*state->ReleaseMult, amplitude);
-
- gains[i] = 1.0f / env;
- }
- }
- state->EnvFollower = env;
-
- /* Now compress the signal amplitude to output. */
- for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
- {
- for(k = 0;k < NumChannels;k++)
- {
- ALfloat gain = state->Gain[j][k];
- if(!(fabsf(gain) > GAIN_SILENCE_THRESHOLD))
- continue;
-
- for(i = 0;i < td;i++)
- SamplesOut[k][base+i] += SamplesIn[j][base+i] * gains[i] * gain;
- }
- }
-
- base += td;
- }
-}
-
-
-typedef struct CompressorStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} CompressorStateFactory;
-
-static ALeffectState *CompressorStateFactory_create(CompressorStateFactory *UNUSED(factory))
-{
- ALcompressorState *state;
-
- NEW_OBJ0(state, ALcompressorState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(CompressorStateFactory);
-
-EffectStateFactory *CompressorStateFactory_getFactory(void)
-{
- static CompressorStateFactory CompressorFactory = { { GET_VTABLE2(CompressorStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &CompressorFactory);
-}
-
-
-void ALcompressor_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_COMPRESSOR_ONOFF:
- if(!(val >= AL_COMPRESSOR_MIN_ONOFF && val <= AL_COMPRESSOR_MAX_ONOFF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Compressor state out of range");
- props->Compressor.OnOff = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid compressor integer property 0x%04x",
- param);
- }
-}
-void ALcompressor_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{ ALcompressor_setParami(effect, context, param, vals[0]); }
-void ALcompressor_setParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid compressor float property 0x%04x", param); }
-void ALcompressor_setParamfv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid compressor float-vector property 0x%04x", param); }
-
-void ALcompressor_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_COMPRESSOR_ONOFF:
- *val = props->Compressor.OnOff;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid compressor integer property 0x%04x",
- param);
- }
-}
-void ALcompressor_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{ ALcompressor_getParami(effect, context, param, vals); }
-void ALcompressor_getParamf(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat *UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid compressor float property 0x%04x", param); }
-void ALcompressor_getParamfv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid compressor float-vector property 0x%04x", param); }
-
-DEFINE_ALEFFECT_VTABLE(ALcompressor);
diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c
deleted file mode 100644
index 0e1fd389..00000000
--- a/Alc/effects/dedicated.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2011 by Chris Robinson.
- * 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 <stdlib.h>
-
-#include "alMain.h"
-#include "alAuxEffectSlot.h"
-#include "alError.h"
-#include "alu.h"
-#include "filters/defs.h"
-
-
-typedef struct ALdedicatedState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
- ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
-} ALdedicatedState;
-
-static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state);
-static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *device);
-static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALdedicatedState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState);
-
-
-static void ALdedicatedState_Construct(ALdedicatedState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALdedicatedState, ALeffectState, state);
-}
-
-static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *UNUSED(device))
-{
- ALsizei i;
- for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
- state->CurrentGains[i] = 0.0f;
- return AL_TRUE;
-}
-
-static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALfloat Gain;
- ALsizei i;
-
- for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
- state->TargetGains[i] = 0.0f;
-
- Gain = slot->Params.Gain * props->Dedicated.Gain;
- if(slot->Params.EffectType == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT)
- {
- int idx;
- if((idx=GetChannelIdxByName(&device->RealOut, LFE)) != -1)
- {
- STATIC_CAST(ALeffectState,state)->OutBuffer = device->RealOut.Buffer;
- STATIC_CAST(ALeffectState,state)->OutChannels = device->RealOut.NumChannels;
- state->TargetGains[idx] = Gain;
- }
- }
- else if(slot->Params.EffectType == AL_EFFECT_DEDICATED_DIALOGUE)
- {
- int idx;
- /* Dialog goes to the front-center speaker if it exists, otherwise it
- * plays from the front-center location. */
- if((idx=GetChannelIdxByName(&device->RealOut, FrontCenter)) != -1)
- {
- STATIC_CAST(ALeffectState,state)->OutBuffer = device->RealOut.Buffer;
- STATIC_CAST(ALeffectState,state)->OutChannels = device->RealOut.NumChannels;
- state->TargetGains[idx] = Gain;
- }
- else
- {
- ALfloat coeffs[MAX_AMBI_COEFFS];
- CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
-
- STATIC_CAST(ALeffectState,state)->OutBuffer = device->Dry.Buffer;
- STATIC_CAST(ALeffectState,state)->OutChannels = device->Dry.NumChannels;
- ComputePanGains(&device->Dry, coeffs, Gain, state->TargetGains);
- }
- }
-}
-
-static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- MixSamples(SamplesIn[0], NumChannels, SamplesOut, state->CurrentGains,
- state->TargetGains, SamplesToDo, 0, SamplesToDo);
-}
-
-
-typedef struct DedicatedStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} DedicatedStateFactory;
-
-ALeffectState *DedicatedStateFactory_create(DedicatedStateFactory *UNUSED(factory))
-{
- ALdedicatedState *state;
-
- NEW_OBJ0(state, ALdedicatedState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(DedicatedStateFactory);
-
-
-EffectStateFactory *DedicatedStateFactory_getFactory(void)
-{
- static DedicatedStateFactory DedicatedFactory = { { GET_VTABLE2(DedicatedStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &DedicatedFactory);
-}
-
-
-void ALdedicated_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param); }
-void ALdedicated_setParamiv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x", param); }
-void ALdedicated_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_DEDICATED_GAIN:
- if(!(val >= 0.0f && isfinite(val)))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Dedicated gain out of range");
- props->Dedicated.Gain = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param);
- }
-}
-void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALdedicated_setParamf(effect, context, param, vals[0]); }
-
-void ALdedicated_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param); }
-void ALdedicated_getParamiv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x", param); }
-void ALdedicated_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_DEDICATED_GAIN:
- *val = props->Dedicated.Gain;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param);
- }
-}
-void ALdedicated_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALdedicated_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALdedicated);
diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c
deleted file mode 100644
index de8da4fe..00000000
--- a/Alc/effects/distortion.c
+++ /dev/null
@@ -1,286 +0,0 @@
-/**
- * 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.,
- * 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"
-
-
-typedef struct ALdistortionState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- /* Effect gains for each channel */
- ALfloat Gain[MAX_OUTPUT_CHANNELS];
-
- /* Effect parameters */
- BiquadFilter lowpass;
- BiquadFilter bandpass;
- ALfloat attenuation;
- ALfloat edge_coeff;
-
- ALfloat Buffer[2][BUFFERSIZE];
-} ALdistortionState;
-
-static ALvoid ALdistortionState_Destruct(ALdistortionState *state);
-static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *device);
-static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALdistortionState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState);
-
-
-static void ALdistortionState_Construct(ALdistortionState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALdistortionState, ALeffectState, state);
-}
-
-static ALvoid ALdistortionState_Destruct(ALdistortionState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *UNUSED(device))
-{
- BiquadFilter_clear(&state->lowpass);
- BiquadFilter_clear(&state->bandpass);
- return AL_TRUE;
-}
-
-static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALfloat frequency = (ALfloat)device->Frequency;
- ALfloat coeffs[MAX_AMBI_COEFFS];
- ALfloat bandwidth;
- ALfloat cutoff;
- ALfloat edge;
-
- /* Store waveshaper edge settings. */
- edge = sinf(props->Distortion.Edge * (F_PI_2));
- edge = minf(edge, 0.99f);
- state->edge_coeff = 2.0f * edge / (1.0f-edge);
-
- cutoff = props->Distortion.LowpassCutoff;
- /* Bandwidth value is constant in octaves. */
- bandwidth = (cutoff / 2.0f) / (cutoff * 0.67f);
- /* Multiply sampling frequency by the amount of oversampling done during
- * processing.
- */
- BiquadFilter_setParams(&state->lowpass, BiquadType_LowPass, 1.0f,
- cutoff / (frequency*4.0f), calc_rcpQ_from_bandwidth(cutoff / (frequency*4.0f), bandwidth)
- );
-
- cutoff = props->Distortion.EQCenter;
- /* Convert bandwidth in Hz to octaves. */
- bandwidth = props->Distortion.EQBandwidth / (cutoff * 0.67f);
- BiquadFilter_setParams(&state->bandpass, BiquadType_BandPass, 1.0f,
- cutoff / (frequency*4.0f), calc_rcpQ_from_bandwidth(cutoff / (frequency*4.0f), bandwidth)
- );
-
- CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain*props->Distortion.Gain, state->Gain);
-}
-
-static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- ALfloat (*restrict buffer)[BUFFERSIZE] = state->Buffer;
- const ALfloat fc = state->edge_coeff;
- ALsizei base;
- ALsizei i, k;
-
- for(base = 0;base < SamplesToDo;)
- {
- /* 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.
- */
- ALsizei todo = mini(BUFFERSIZE, (SamplesToDo-base) * 4);
-
- /* Fill oversample buffer using zero stuffing. Multiply the sample by
- * the amount of oversampling to maintain the signal's power.
- */
- for(i = 0;i < todo;i++)
- buffer[0][i] = !(i&3) ? SamplesIn[0][(i>>2)+base] * 4.0f : 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.
- */
- BiquadFilter_process(&state->lowpass, buffer[1], buffer[0], todo);
-
- /* 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(i = 0;i < todo;i++)
- {
- ALfloat smp = buffer[1][i];
-
- smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp));
- smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp)) * -1.0f;
- smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp));
-
- buffer[0][i] = smp;
- }
-
- /* Third step, do bandpass filtering of distorted signal. */
- BiquadFilter_process(&state->bandpass, buffer[1], buffer[0], todo);
-
- todo >>= 2;
- for(k = 0;k < NumChannels;k++)
- {
- /* Fourth step, final, do attenuation and perform decimation,
- * storing only one sample out of four.
- */
- ALfloat gain = state->Gain[k];
- if(!(fabsf(gain) > GAIN_SILENCE_THRESHOLD))
- continue;
-
- for(i = 0;i < todo;i++)
- SamplesOut[k][base+i] += gain * buffer[1][i*4];
- }
-
- base += todo;
- }
-}
-
-
-typedef struct DistortionStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} DistortionStateFactory;
-
-static ALeffectState *DistortionStateFactory_create(DistortionStateFactory *UNUSED(factory))
-{
- ALdistortionState *state;
-
- NEW_OBJ0(state, ALdistortionState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(DistortionStateFactory);
-
-
-EffectStateFactory *DistortionStateFactory_getFactory(void)
-{
- static DistortionStateFactory DistortionFactory = { { GET_VTABLE2(DistortionStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &DistortionFactory);
-}
-
-
-void ALdistortion_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param); }
-void ALdistortion_setParamiv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x", param); }
-void ALdistortion_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_DISTORTION_EDGE:
- if(!(val >= AL_DISTORTION_MIN_EDGE && val <= AL_DISTORTION_MAX_EDGE))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Distortion edge out of range");
- props->Distortion.Edge = val;
- break;
-
- case AL_DISTORTION_GAIN:
- if(!(val >= AL_DISTORTION_MIN_GAIN && val <= AL_DISTORTION_MAX_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Distortion gain out of range");
- props->Distortion.Gain = val;
- break;
-
- case AL_DISTORTION_LOWPASS_CUTOFF:
- if(!(val >= AL_DISTORTION_MIN_LOWPASS_CUTOFF && val <= AL_DISTORTION_MAX_LOWPASS_CUTOFF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Distortion low-pass cutoff out of range");
- props->Distortion.LowpassCutoff = val;
- break;
-
- case AL_DISTORTION_EQCENTER:
- if(!(val >= AL_DISTORTION_MIN_EQCENTER && val <= AL_DISTORTION_MAX_EQCENTER))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Distortion EQ center out of range");
- props->Distortion.EQCenter = val;
- break;
-
- case AL_DISTORTION_EQBANDWIDTH:
- if(!(val >= AL_DISTORTION_MIN_EQBANDWIDTH && val <= AL_DISTORTION_MAX_EQBANDWIDTH))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Distortion EQ bandwidth out of range");
- props->Distortion.EQBandwidth = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid distortion float property 0x%04x",
- param);
- }
-}
-void ALdistortion_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALdistortion_setParamf(effect, context, param, vals[0]); }
-
-void ALdistortion_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param); }
-void ALdistortion_getParamiv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x", param); }
-void ALdistortion_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_DISTORTION_EDGE:
- *val = props->Distortion.Edge;
- break;
-
- case AL_DISTORTION_GAIN:
- *val = props->Distortion.Gain;
- break;
-
- case AL_DISTORTION_LOWPASS_CUTOFF:
- *val = props->Distortion.LowpassCutoff;
- break;
-
- case AL_DISTORTION_EQCENTER:
- *val = props->Distortion.EQCenter;
- break;
-
- case AL_DISTORTION_EQBANDWIDTH:
- *val = props->Distortion.EQBandwidth;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid distortion float property 0x%04x",
- param);
- }
-}
-void ALdistortion_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALdistortion_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALdistortion);
diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c
deleted file mode 100644
index 4570fcb1..00000000
--- a/Alc/effects/echo.c
+++ /dev/null
@@ -1,310 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2009 by Chris Robinson.
- * 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 "alFilter.h"
-#include "alAuxEffectSlot.h"
-#include "alError.h"
-#include "alu.h"
-#include "filters/defs.h"
-
-
-typedef struct ALechoState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- ALfloat *SampleBuffer;
- ALsizei BufferLength;
-
- // The echo is two tap. The delay is the number of samples from before the
- // current offset
- struct {
- ALsizei delay;
- } Tap[2];
- ALsizei Offset;
-
- /* The panning gains for the two taps */
- struct {
- ALfloat Current[MAX_OUTPUT_CHANNELS];
- ALfloat Target[MAX_OUTPUT_CHANNELS];
- } Gains[2];
-
- ALfloat FeedGain;
-
- BiquadFilter Filter;
-} ALechoState;
-
-static ALvoid ALechoState_Destruct(ALechoState *state);
-static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device);
-static ALvoid ALechoState_update(ALechoState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALechoState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALechoState);
-
-
-static void ALechoState_Construct(ALechoState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALechoState, ALeffectState, state);
-
- state->BufferLength = 0;
- state->SampleBuffer = NULL;
-
- state->Tap[0].delay = 0;
- state->Tap[1].delay = 0;
- state->Offset = 0;
-
- BiquadFilter_clear(&state->Filter);
-}
-
-static ALvoid ALechoState_Destruct(ALechoState *state)
-{
- al_free(state->SampleBuffer);
- state->SampleBuffer = NULL;
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device)
-{
- ALsizei maxlen;
-
- // Use the next power of 2 for the buffer length, so the tap offsets can be
- // wrapped using a mask instead of a modulo
- maxlen = float2int(AL_ECHO_MAX_DELAY*Device->Frequency + 0.5f) +
- float2int(AL_ECHO_MAX_LRDELAY*Device->Frequency + 0.5f);
- maxlen = NextPowerOf2(maxlen);
- if(maxlen <= 0) return AL_FALSE;
-
- if(maxlen != state->BufferLength)
- {
- void *temp = al_calloc(16, maxlen * sizeof(ALfloat));
- if(!temp) return AL_FALSE;
-
- al_free(state->SampleBuffer);
- state->SampleBuffer = temp;
- state->BufferLength = maxlen;
- }
-
- memset(state->SampleBuffer, 0, state->BufferLength*sizeof(ALfloat));
- memset(state->Gains, 0, sizeof(state->Gains));
-
- return AL_TRUE;
-}
-
-static ALvoid ALechoState_update(ALechoState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALuint frequency = device->Frequency;
- ALfloat coeffs[MAX_AMBI_COEFFS];
- ALfloat gainhf, lrpan, spread;
-
- state->Tap[0].delay = maxi(float2int(props->Echo.Delay*frequency + 0.5f), 1);
- state->Tap[1].delay = float2int(props->Echo.LRDelay*frequency + 0.5f);
- state->Tap[1].delay += state->Tap[0].delay;
-
- spread = props->Echo.Spread;
- if(spread < 0.0f) lrpan = -1.0f;
- else lrpan = 1.0f;
- /* Convert echo spread (where 0 = omni, +/-1 = directional) to coverage
- * spread (where 0 = point, tau = omni).
- */
- spread = asinf(1.0f - fabsf(spread))*4.0f;
-
- state->FeedGain = props->Echo.Feedback;
-
- gainhf = maxf(1.0f - props->Echo.Damping, 0.0625f); /* Limit -24dB */
- BiquadFilter_setParams(&state->Filter, BiquadType_HighShelf,
- gainhf, LOWPASSFREQREF/frequency, calc_rcpQ_from_slope(gainhf, 1.0f)
- );
-
- /* First tap panning */
- CalcAngleCoeffs(-F_PI_2*lrpan, 0.0f, spread, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->Gains[0].Target);
-
- /* Second tap panning */
- CalcAngleCoeffs( F_PI_2*lrpan, 0.0f, spread, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->Gains[1].Target);
-}
-
-static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- const ALsizei mask = state->BufferLength-1;
- const ALsizei tap1 = state->Tap[0].delay;
- const ALsizei tap2 = state->Tap[1].delay;
- ALfloat *restrict delaybuf = state->SampleBuffer;
- ALsizei offset = state->Offset;
- ALfloat z1, z2, in, out;
- ALsizei base;
- ALsizei c, i;
-
- z1 = state->Filter.z1;
- z2 = state->Filter.z2;
- for(base = 0;base < SamplesToDo;)
- {
- alignas(16) ALfloat temps[2][128];
- ALsizei td = mini(128, SamplesToDo-base);
-
- for(i = 0;i < td;i++)
- {
- /* Feed the delay buffer's input first. */
- delaybuf[offset&mask] = SamplesIn[0][i+base];
-
- /* First tap */
- temps[0][i] = delaybuf[(offset-tap1) & mask];
- /* Second tap */
- temps[1][i] = delaybuf[(offset-tap2) & mask];
-
- /* Apply damping to the second tap, then add it to the buffer with
- * feedback attenuation.
- */
- in = temps[1][i];
- out = in*state->Filter.b0 + z1;
- z1 = in*state->Filter.b1 - out*state->Filter.a1 + z2;
- z2 = in*state->Filter.b2 - out*state->Filter.a2;
-
- delaybuf[offset&mask] += out * state->FeedGain;
- offset++;
- }
-
- for(c = 0;c < 2;c++)
- MixSamples(temps[c], NumChannels, SamplesOut, state->Gains[c].Current,
- state->Gains[c].Target, SamplesToDo-base, base, td);
-
- base += td;
- }
- state->Filter.z1 = z1;
- state->Filter.z2 = z2;
-
- state->Offset = offset;
-}
-
-
-typedef struct EchoStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} EchoStateFactory;
-
-ALeffectState *EchoStateFactory_create(EchoStateFactory *UNUSED(factory))
-{
- ALechoState *state;
-
- NEW_OBJ0(state, ALechoState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(EchoStateFactory);
-
-EffectStateFactory *EchoStateFactory_getFactory(void)
-{
- static EchoStateFactory EchoFactory = { { GET_VTABLE2(EchoStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &EchoFactory);
-}
-
-
-void ALecho_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param); }
-void ALecho_setParamiv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param); }
-void ALecho_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_ECHO_DELAY:
- if(!(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Echo delay out of range");
- props->Echo.Delay = val;
- break;
-
- case AL_ECHO_LRDELAY:
- if(!(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Echo LR delay out of range");
- props->Echo.LRDelay = val;
- break;
-
- case AL_ECHO_DAMPING:
- if(!(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Echo damping out of range");
- props->Echo.Damping = val;
- break;
-
- case AL_ECHO_FEEDBACK:
- if(!(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Echo feedback out of range");
- props->Echo.Feedback = val;
- break;
-
- case AL_ECHO_SPREAD:
- if(!(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Echo spread out of range");
- props->Echo.Spread = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param);
- }
-}
-void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALecho_setParamf(effect, context, param, vals[0]); }
-
-void ALecho_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param); }
-void ALecho_getParamiv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param); }
-void ALecho_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_ECHO_DELAY:
- *val = props->Echo.Delay;
- break;
-
- case AL_ECHO_LRDELAY:
- *val = props->Echo.LRDelay;
- break;
-
- case AL_ECHO_DAMPING:
- *val = props->Echo.Damping;
- break;
-
- case AL_ECHO_FEEDBACK:
- *val = props->Echo.Feedback;
- break;
-
- case AL_ECHO_SPREAD:
- *val = props->Echo.Spread;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param);
- }
-}
-void ALecho_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALecho_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALecho);
diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c
deleted file mode 100644
index 17106127..00000000
--- a/Alc/effects/equalizer.c
+++ /dev/null
@@ -1,355 +0,0 @@
-/**
- * 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.,
- * 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"
-
-
-/* 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 struct ALequalizerState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- struct {
- /* Effect parameters */
- BiquadFilter filter[4];
-
- /* Effect gains for each channel */
- ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
- ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
- } Chans[MAX_EFFECT_CHANNELS];
-
- ALfloat SampleBuffer[MAX_EFFECT_CHANNELS][BUFFERSIZE];
-} ALequalizerState;
-
-static ALvoid ALequalizerState_Destruct(ALequalizerState *state);
-static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *device);
-static ALvoid ALequalizerState_update(ALequalizerState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALequalizerState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState);
-
-
-static void ALequalizerState_Construct(ALequalizerState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALequalizerState, ALeffectState, state);
-}
-
-static ALvoid ALequalizerState_Destruct(ALequalizerState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *UNUSED(device))
-{
- ALsizei i, j;
-
- for(i = 0; i < MAX_EFFECT_CHANNELS;i++)
- {
- for(j = 0;j < 4;j++)
- BiquadFilter_clear(&state->Chans[i].filter[j]);
- for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
- state->Chans[i].CurrentGains[j] = 0.0f;
- }
- return AL_TRUE;
-}
-
-static ALvoid ALequalizerState_update(ALequalizerState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALfloat frequency = (ALfloat)device->Frequency;
- ALfloat gain, f0norm;
- ALuint i;
-
- /* Calculate coefficients for the each type of filter. Note that the shelf
- * filters' gain is for the reference frequency, which is the centerpoint
- * of the transition band.
- */
- gain = maxf(sqrtf(props->Equalizer.LowGain), 0.0625f); /* Limit -24dB */
- f0norm = props->Equalizer.LowCutoff/frequency;
- BiquadFilter_setParams(&state->Chans[0].filter[0], BiquadType_LowShelf,
- gain, f0norm, calc_rcpQ_from_slope(gain, 0.75f)
- );
-
- gain = maxf(props->Equalizer.Mid1Gain, 0.0625f);
- f0norm = props->Equalizer.Mid1Center/frequency;
- BiquadFilter_setParams(&state->Chans[0].filter[1], BiquadType_Peaking,
- gain, f0norm, calc_rcpQ_from_bandwidth(
- f0norm, props->Equalizer.Mid1Width
- )
- );
-
- gain = maxf(props->Equalizer.Mid2Gain, 0.0625f);
- f0norm = props->Equalizer.Mid2Center/frequency;
- BiquadFilter_setParams(&state->Chans[0].filter[2], BiquadType_Peaking,
- gain, f0norm, calc_rcpQ_from_bandwidth(
- f0norm, props->Equalizer.Mid2Width
- )
- );
-
- gain = maxf(sqrtf(props->Equalizer.HighGain), 0.0625f);
- f0norm = props->Equalizer.HighCutoff/frequency;
- BiquadFilter_setParams(&state->Chans[0].filter[3], BiquadType_HighShelf,
- gain, f0norm, calc_rcpQ_from_slope(gain, 0.75f)
- );
-
- /* Copy the filter coefficients for the other input channels. */
- for(i = 1;i < MAX_EFFECT_CHANNELS;i++)
- {
- BiquadFilter_copyParams(&state->Chans[i].filter[0], &state->Chans[0].filter[0]);
- BiquadFilter_copyParams(&state->Chans[i].filter[1], &state->Chans[0].filter[1]);
- BiquadFilter_copyParams(&state->Chans[i].filter[2], &state->Chans[0].filter[2]);
- BiquadFilter_copyParams(&state->Chans[i].filter[3], &state->Chans[0].filter[3]);
- }
-
- STATIC_CAST(ALeffectState,state)->OutBuffer = device->FOAOut.Buffer;
- STATIC_CAST(ALeffectState,state)->OutChannels = device->FOAOut.NumChannels;
- for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
- ComputePanGains(&device->FOAOut, IdentityMatrixf.m[i], slot->Params.Gain,
- state->Chans[i].TargetGains);
-}
-
-static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- ALfloat (*restrict temps)[BUFFERSIZE] = state->SampleBuffer;
- ALsizei c;
-
- for(c = 0;c < MAX_EFFECT_CHANNELS;c++)
- {
- BiquadFilter_process(&state->Chans[c].filter[0], temps[0], SamplesIn[c], SamplesToDo);
- BiquadFilter_process(&state->Chans[c].filter[1], temps[1], temps[0], SamplesToDo);
- BiquadFilter_process(&state->Chans[c].filter[2], temps[2], temps[1], SamplesToDo);
- BiquadFilter_process(&state->Chans[c].filter[3], temps[3], temps[2], SamplesToDo);
-
- MixSamples(temps[3], NumChannels, SamplesOut,
- state->Chans[c].CurrentGains, state->Chans[c].TargetGains,
- SamplesToDo, 0, SamplesToDo
- );
- }
-}
-
-
-typedef struct EqualizerStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} EqualizerStateFactory;
-
-ALeffectState *EqualizerStateFactory_create(EqualizerStateFactory *UNUSED(factory))
-{
- ALequalizerState *state;
-
- NEW_OBJ0(state, ALequalizerState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(EqualizerStateFactory);
-
-EffectStateFactory *EqualizerStateFactory_getFactory(void)
-{
- static EqualizerStateFactory EqualizerFactory = { { GET_VTABLE2(EqualizerStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &EqualizerFactory);
-}
-
-
-void ALequalizer_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param); }
-void ALequalizer_setParamiv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x", param); }
-void ALequalizer_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EQUALIZER_LOW_GAIN:
- if(!(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer low-band gain out of range");
- props->Equalizer.LowGain = val;
- break;
-
- case AL_EQUALIZER_LOW_CUTOFF:
- if(!(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer low-band cutoff out of range");
- props->Equalizer.LowCutoff = val;
- break;
-
- case AL_EQUALIZER_MID1_GAIN:
- if(!(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer mid1-band gain out of range");
- props->Equalizer.Mid1Gain = val;
- break;
-
- case AL_EQUALIZER_MID1_CENTER:
- if(!(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer mid1-band center out of range");
- props->Equalizer.Mid1Center = val;
- break;
-
- case AL_EQUALIZER_MID1_WIDTH:
- if(!(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer mid1-band width out of range");
- props->Equalizer.Mid1Width = val;
- break;
-
- case AL_EQUALIZER_MID2_GAIN:
- if(!(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer mid2-band gain out of range");
- props->Equalizer.Mid2Gain = val;
- break;
-
- case AL_EQUALIZER_MID2_CENTER:
- if(!(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer mid2-band center out of range");
- props->Equalizer.Mid2Center = val;
- break;
-
- case AL_EQUALIZER_MID2_WIDTH:
- if(!(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer mid2-band width out of range");
- props->Equalizer.Mid2Width = val;
- break;
-
- case AL_EQUALIZER_HIGH_GAIN:
- if(!(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer high-band gain out of range");
- props->Equalizer.HighGain = val;
- break;
-
- case AL_EQUALIZER_HIGH_CUTOFF:
- if(!(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer high-band cutoff out of range");
- props->Equalizer.HighCutoff = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param);
- }
-}
-void ALequalizer_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALequalizer_setParamf(effect, context, param, vals[0]); }
-
-void ALequalizer_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(val))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param); }
-void ALequalizer_getParamiv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint *UNUSED(vals))
-{ alSetError(context, AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x", param); }
-void ALequalizer_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EQUALIZER_LOW_GAIN:
- *val = props->Equalizer.LowGain;
- break;
-
- case AL_EQUALIZER_LOW_CUTOFF:
- *val = props->Equalizer.LowCutoff;
- break;
-
- case AL_EQUALIZER_MID1_GAIN:
- *val = props->Equalizer.Mid1Gain;
- break;
-
- case AL_EQUALIZER_MID1_CENTER:
- *val = props->Equalizer.Mid1Center;
- break;
-
- case AL_EQUALIZER_MID1_WIDTH:
- *val = props->Equalizer.Mid1Width;
- break;
-
- case AL_EQUALIZER_MID2_GAIN:
- *val = props->Equalizer.Mid2Gain;
- break;
-
- case AL_EQUALIZER_MID2_CENTER:
- *val = props->Equalizer.Mid2Center;
- break;
-
- case AL_EQUALIZER_MID2_WIDTH:
- *val = props->Equalizer.Mid2Width;
- break;
-
- case AL_EQUALIZER_HIGH_GAIN:
- *val = props->Equalizer.HighGain;
- break;
-
- case AL_EQUALIZER_HIGH_CUTOFF:
- *val = props->Equalizer.HighCutoff;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param);
- }
-}
-void ALequalizer_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALequalizer_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALequalizer);
diff --git a/Alc/effects/fshifter.c b/Alc/effects/fshifter.c
deleted file mode 100644
index 7d72472a..00000000
--- a/Alc/effects/fshifter.c
+++ /dev/null
@@ -1,329 +0,0 @@
-/**
- * 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"
-
-#include "alcomplex.h"
-
-#define HIL_SIZE 1024
-#define OVERSAMP (1<<2)
-
-#define HIL_STEP (HIL_SIZE / OVERSAMP)
-#define FIFO_LATENCY (HIL_STEP * (OVERSAMP-1))
-
-
-typedef struct ALfshifterState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- /* Effect parameters */
- ALsizei count;
- ALsizei PhaseStep;
- ALsizei Phase;
- ALdouble ld_sign;
-
- /*Effects buffers*/
- ALfloat InFIFO[HIL_SIZE];
- ALcomplex OutFIFO[HIL_SIZE];
- ALcomplex OutputAccum[HIL_SIZE];
- ALcomplex Analytic[HIL_SIZE];
- ALcomplex Outdata[BUFFERSIZE];
-
- alignas(16) ALfloat BufferOut[BUFFERSIZE];
-
- /* Effect gains for each output channel */
- ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
- ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
-} ALfshifterState;
-
-static ALvoid ALfshifterState_Destruct(ALfshifterState *state);
-static ALboolean ALfshifterState_deviceUpdate(ALfshifterState *state, ALCdevice *device);
-static ALvoid ALfshifterState_update(ALfshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALfshifterState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALfshifterState);
-
-/* Define a Hann window, used to filter the HIL input and output. */
-alignas(16) static ALdouble HannWindow[HIL_SIZE];
-
-static void InitHannWindow(void)
-{
- ALsizei i;
-
- /* Create lookup table of the Hann window for the desired size, i.e. HIL_SIZE */
- for(i = 0;i < HIL_SIZE>>1;i++)
- {
- ALdouble val = sin(M_PI * (ALdouble)i / (ALdouble)(HIL_SIZE-1));
- HannWindow[i] = HannWindow[HIL_SIZE-1-i] = val * val;
- }
-}
-
-static alonce_flag HannInitOnce = AL_ONCE_FLAG_INIT;
-
-static void ALfshifterState_Construct(ALfshifterState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALfshifterState, ALeffectState, state);
-
- alcall_once(&HannInitOnce, InitHannWindow);
-}
-
-static ALvoid ALfshifterState_Destruct(ALfshifterState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALfshifterState_deviceUpdate(ALfshifterState *state, ALCdevice *UNUSED(device))
-{
- /* (Re-)initializing parameters and clear the buffers. */
- state->count = FIFO_LATENCY;
- state->PhaseStep = 0;
- state->Phase = 0;
- state->ld_sign = 1.0;
-
- memset(state->InFIFO, 0, sizeof(state->InFIFO));
- memset(state->OutFIFO, 0, sizeof(state->OutFIFO));
- memset(state->OutputAccum, 0, sizeof(state->OutputAccum));
- memset(state->Analytic, 0, sizeof(state->Analytic));
-
- memset(state->CurrentGains, 0, sizeof(state->CurrentGains));
- memset(state->TargetGains, 0, sizeof(state->TargetGains));
-
- return AL_TRUE;
-}
-
-static ALvoid ALfshifterState_update(ALfshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALfloat coeffs[MAX_AMBI_COEFFS];
- ALfloat step;
-
- step = props->Fshifter.Frequency / (ALfloat)device->Frequency;
- state->PhaseStep = fastf2i(minf(step, 0.5f) * FRACTIONONE);
-
- switch(props->Fshifter.LeftDirection)
- {
- case AL_FREQUENCY_SHIFTER_DIRECTION_DOWN:
- state->ld_sign = -1.0;
- break;
-
- case AL_FREQUENCY_SHIFTER_DIRECTION_UP:
- state->ld_sign = 1.0;
- break;
-
- case AL_FREQUENCY_SHIFTER_DIRECTION_OFF:
- state->Phase = 0;
- state->PhaseStep = 0;
- break;
- }
-
- CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->TargetGains);
-}
-
-static ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- static const ALcomplex complex_zero = { 0.0, 0.0 };
- ALfloat *restrict BufferOut = state->BufferOut;
- ALsizei j, k, base;
-
- for(base = 0;base < SamplesToDo;)
- {
- ALsizei todo = mini(HIL_SIZE-state->count, SamplesToDo-base);
-
- ASSUME(todo > 0);
-
- /* Fill FIFO buffer with samples data */
- k = state->count;
- for(j = 0;j < todo;j++,k++)
- {
- state->InFIFO[k] = SamplesIn[0][base+j];
- state->Outdata[base+j] = state->OutFIFO[k-FIFO_LATENCY];
- }
- state->count += todo;
- base += todo;
-
- /* Check whether FIFO buffer is filled */
- if(state->count < HIL_SIZE) continue;
-
- state->count = FIFO_LATENCY;
-
- /* Real signal windowing and store in Analytic buffer */
- for(k = 0;k < HIL_SIZE;k++)
- {
- state->Analytic[k].Real = state->InFIFO[k] * HannWindow[k];
- state->Analytic[k].Imag = 0.0;
- }
-
- /* Processing signal by Discrete Hilbert Transform (analytical signal). */
- complex_hilbert(state->Analytic, HIL_SIZE);
-
- /* Windowing and add to output accumulator */
- for(k = 0;k < HIL_SIZE;k++)
- {
- state->OutputAccum[k].Real += 2.0/OVERSAMP*HannWindow[k]*state->Analytic[k].Real;
- state->OutputAccum[k].Imag += 2.0/OVERSAMP*HannWindow[k]*state->Analytic[k].Imag;
- }
-
- /* Shift accumulator, input & output FIFO */
- for(k = 0;k < HIL_STEP;k++) state->OutFIFO[k] = state->OutputAccum[k];
- for(j = 0;k < HIL_SIZE;k++,j++) state->OutputAccum[j] = state->OutputAccum[k];
- for(;j < HIL_SIZE;j++) state->OutputAccum[j] = complex_zero;
- for(k = 0;k < FIFO_LATENCY;k++)
- state->InFIFO[k] = state->InFIFO[k+HIL_STEP];
- }
-
- /* Process frequency shifter using the analytic signal obtained. */
- for(k = 0;k < SamplesToDo;k++)
- {
- ALdouble phase = state->Phase * ((1.0/FRACTIONONE) * 2.0*M_PI);
- BufferOut[k] = (ALfloat)(state->Outdata[k].Real*cos(phase) +
- state->Outdata[k].Imag*sin(phase)*state->ld_sign);
-
- state->Phase += state->PhaseStep;
- state->Phase &= FRACTIONMASK;
- }
-
- /* Now, mix the processed sound data to the output. */
- MixSamples(BufferOut, NumChannels, SamplesOut, state->CurrentGains, state->TargetGains,
- maxi(SamplesToDo, 512), 0, SamplesToDo);
-}
-
-typedef struct FshifterStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} FshifterStateFactory;
-
-static ALeffectState *FshifterStateFactory_create(FshifterStateFactory *UNUSED(factory))
-{
- ALfshifterState *state;
-
- NEW_OBJ0(state, ALfshifterState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(FshifterStateFactory);
-
-EffectStateFactory *FshifterStateFactory_getFactory(void)
-{
- static FshifterStateFactory FshifterFactory = { { GET_VTABLE2(FshifterStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &FshifterFactory);
-}
-
-void ALfshifter_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FREQUENCY_SHIFTER_FREQUENCY:
- if(!(val >= AL_FREQUENCY_SHIFTER_MIN_FREQUENCY && val <= AL_FREQUENCY_SHIFTER_MAX_FREQUENCY))
- SETERR_RETURN(context, AL_INVALID_VALUE,,"Frequency shifter frequency out of range");
- props->Fshifter.Frequency = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid frequency shifter float property 0x%04x", param);
- }
-}
-
-void ALfshifter_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{
- ALfshifter_setParamf(effect, context, param, vals[0]);
-}
-
-void ALfshifter_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FREQUENCY_SHIFTER_LEFT_DIRECTION:
- if(!(val >= AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION && val <= AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION))
- SETERR_RETURN(context, AL_INVALID_VALUE,,"Frequency shifter left direction out of range");
- props->Fshifter.LeftDirection = val;
- break;
-
- case AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION:
- if(!(val >= AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION && val <= AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION))
- SETERR_RETURN(context, AL_INVALID_VALUE,,"Frequency shifter right direction out of range");
- props->Fshifter.RightDirection = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid frequency shifter integer property 0x%04x", param);
- }
-}
-void ALfshifter_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{
- ALfshifter_setParami(effect, context, param, vals[0]);
-}
-
-void ALfshifter_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FREQUENCY_SHIFTER_LEFT_DIRECTION:
- *val = props->Fshifter.LeftDirection;
- break;
- case AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION:
- *val = props->Fshifter.RightDirection;
- break;
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid frequency shifter integer property 0x%04x", param);
- }
-}
-void ALfshifter_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{
- ALfshifter_getParami(effect, context, param, vals);
-}
-
-void ALfshifter_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
-
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_FREQUENCY_SHIFTER_FREQUENCY:
- *val = props->Fshifter.Frequency;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid frequency shifter float property 0x%04x", param);
- }
-
-}
-
-void ALfshifter_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{
- ALfshifter_getParamf(effect, context, param, vals);
-}
-
-DEFINE_ALEFFECT_VTABLE(ALfshifter);
diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c
deleted file mode 100644
index e368adb8..00000000
--- a/Alc/effects/modulator.c
+++ /dev/null
@@ -1,307 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2009 by Chris Robinson.
- * 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 MAX_UPDATE_SAMPLES 128
-
-typedef struct ALmodulatorState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- void (*GetSamples)(ALfloat*, ALsizei, const ALsizei, ALsizei);
-
- ALsizei index;
- ALsizei step;
-
- struct {
- BiquadFilter Filter;
-
- ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
- ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
- } Chans[MAX_EFFECT_CHANNELS];
-} ALmodulatorState;
-
-static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state);
-static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *device);
-static ALvoid ALmodulatorState_update(ALmodulatorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALmodulatorState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState);
-
-
-#define WAVEFORM_FRACBITS 24
-#define WAVEFORM_FRACONE (1<<WAVEFORM_FRACBITS)
-#define WAVEFORM_FRACMASK (WAVEFORM_FRACONE-1)
-
-static inline ALfloat Sin(ALsizei index)
-{
- return sinf((ALfloat)index * (F_TAU / WAVEFORM_FRACONE));
-}
-
-static inline ALfloat Saw(ALsizei index)
-{
- return (ALfloat)index*(2.0f/WAVEFORM_FRACONE) - 1.0f;
-}
-
-static inline ALfloat Square(ALsizei index)
-{
- return (ALfloat)(((index>>(WAVEFORM_FRACBITS-2))&2) - 1);
-}
-
-static inline ALfloat One(ALsizei UNUSED(index))
-{
- return 1.0f;
-}
-
-#define DECL_TEMPLATE(func) \
-static void Modulate##func(ALfloat *restrict dst, ALsizei index, \
- const ALsizei step, ALsizei todo) \
-{ \
- ALsizei i; \
- for(i = 0;i < todo;i++) \
- { \
- index += step; \
- index &= WAVEFORM_FRACMASK; \
- dst[i] = func(index); \
- } \
-}
-
-DECL_TEMPLATE(Sin)
-DECL_TEMPLATE(Saw)
-DECL_TEMPLATE(Square)
-DECL_TEMPLATE(One)
-
-#undef DECL_TEMPLATE
-
-
-static void ALmodulatorState_Construct(ALmodulatorState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALmodulatorState, ALeffectState, state);
-
- state->index = 0;
- state->step = 1;
-}
-
-static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *UNUSED(device))
-{
- ALsizei i, j;
- for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
- {
- BiquadFilter_clear(&state->Chans[i].Filter);
- for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
- state->Chans[i].CurrentGains[j] = 0.0f;
- }
- return AL_TRUE;
-}
-
-static ALvoid ALmodulatorState_update(ALmodulatorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALfloat f0norm;
- ALsizei i;
-
- state->step = fastf2i(props->Modulator.Frequency / (ALfloat)device->Frequency *
- WAVEFORM_FRACONE);
- state->step = clampi(state->step, 0, WAVEFORM_FRACONE-1);
-
- if(state->step == 0)
- state->GetSamples = ModulateOne;
- else if(props->Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
- state->GetSamples = ModulateSin;
- else if(props->Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
- state->GetSamples = ModulateSaw;
- else /*if(Slot->Params.EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SQUARE)*/
- state->GetSamples = ModulateSquare;
-
- f0norm = props->Modulator.HighPassCutoff / (ALfloat)device->Frequency;
- f0norm = clampf(f0norm, 1.0f/512.0f, 0.49f);
- /* Bandwidth value is constant in octaves. */
- BiquadFilter_setParams(&state->Chans[0].Filter, BiquadType_HighPass, 1.0f,
- f0norm, calc_rcpQ_from_bandwidth(f0norm, 0.75f));
- for(i = 1;i < MAX_EFFECT_CHANNELS;i++)
- BiquadFilter_copyParams(&state->Chans[i].Filter, &state->Chans[0].Filter);
-
- STATIC_CAST(ALeffectState,state)->OutBuffer = device->FOAOut.Buffer;
- STATIC_CAST(ALeffectState,state)->OutChannels = device->FOAOut.NumChannels;
- for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
- ComputePanGains(&device->FOAOut, IdentityMatrixf.m[i], slot->Params.Gain,
- state->Chans[i].TargetGains);
-}
-
-static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- const ALsizei step = state->step;
- ALsizei base;
-
- for(base = 0;base < SamplesToDo;)
- {
- alignas(16) ALfloat modsamples[MAX_UPDATE_SAMPLES];
- ALsizei td = mini(MAX_UPDATE_SAMPLES, SamplesToDo-base);
- ALsizei c, i;
-
- state->GetSamples(modsamples, state->index, step, td);
- state->index += (step*td) & WAVEFORM_FRACMASK;
- state->index &= WAVEFORM_FRACMASK;
-
- for(c = 0;c < MAX_EFFECT_CHANNELS;c++)
- {
- alignas(16) ALfloat temps[MAX_UPDATE_SAMPLES];
-
- BiquadFilter_process(&state->Chans[c].Filter, temps, &SamplesIn[c][base], td);
- for(i = 0;i < td;i++)
- temps[i] *= modsamples[i];
-
- MixSamples(temps, NumChannels, SamplesOut, state->Chans[c].CurrentGains,
- state->Chans[c].TargetGains, SamplesToDo-base, base, td);
- }
-
- base += td;
- }
-}
-
-
-typedef struct ModulatorStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} ModulatorStateFactory;
-
-static ALeffectState *ModulatorStateFactory_create(ModulatorStateFactory *UNUSED(factory))
-{
- ALmodulatorState *state;
-
- NEW_OBJ0(state, ALmodulatorState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(ModulatorStateFactory);
-
-EffectStateFactory *ModulatorStateFactory_getFactory(void)
-{
- static ModulatorStateFactory ModulatorFactory = { { GET_VTABLE2(ModulatorStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &ModulatorFactory);
-}
-
-
-void ALmodulator_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_RING_MODULATOR_FREQUENCY:
- if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Modulator frequency out of range");
- props->Modulator.Frequency = val;
- break;
-
- case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
- if(!(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Modulator high-pass cutoff out of range");
- props->Modulator.HighPassCutoff = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param);
- }
-}
-void ALmodulator_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALmodulator_setParamf(effect, context, param, vals[0]); }
-void ALmodulator_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_RING_MODULATOR_FREQUENCY:
- case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
- ALmodulator_setParamf(effect, context, param, (ALfloat)val);
- break;
-
- case AL_RING_MODULATOR_WAVEFORM:
- if(!(val >= AL_RING_MODULATOR_MIN_WAVEFORM && val <= AL_RING_MODULATOR_MAX_WAVEFORM))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid modulator waveform");
- props->Modulator.Waveform = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x", param);
- }
-}
-void ALmodulator_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{ ALmodulator_setParami(effect, context, param, vals[0]); }
-
-void ALmodulator_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_RING_MODULATOR_FREQUENCY:
- *val = (ALint)props->Modulator.Frequency;
- break;
- case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
- *val = (ALint)props->Modulator.HighPassCutoff;
- break;
- case AL_RING_MODULATOR_WAVEFORM:
- *val = props->Modulator.Waveform;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x", param);
- }
-}
-void ALmodulator_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{ ALmodulator_getParami(effect, context, param, vals); }
-void ALmodulator_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_RING_MODULATOR_FREQUENCY:
- *val = props->Modulator.Frequency;
- break;
- case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
- *val = props->Modulator.HighPassCutoff;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param);
- }
-}
-void ALmodulator_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALmodulator_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALmodulator);
diff --git a/Alc/effects/null.c b/Alc/effects/null.c
deleted file mode 100644
index e57359e3..00000000
--- a/Alc/effects/null.c
+++ /dev/null
@@ -1,179 +0,0 @@
-#include "config.h"
-
-#include <stdlib.h>
-
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "alMain.h"
-#include "alAuxEffectSlot.h"
-#include "alError.h"
-
-
-typedef struct ALnullState {
- DERIVE_FROM_TYPE(ALeffectState);
-} ALnullState;
-
-/* Forward-declare "virtual" functions to define the vtable with. */
-static ALvoid ALnullState_Destruct(ALnullState *state);
-static ALboolean ALnullState_deviceUpdate(ALnullState *state, ALCdevice *device);
-static ALvoid ALnullState_update(ALnullState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALnullState_process(ALnullState *state, ALsizei samplesToDo, const ALfloat (*restrict samplesIn)[BUFFERSIZE], ALfloat (*restrict samplesOut)[BUFFERSIZE], ALsizei mumChannels);
-static void *ALnullState_New(size_t size);
-static void ALnullState_Delete(void *ptr);
-
-/* Define the ALeffectState vtable for this type. */
-DEFINE_ALEFFECTSTATE_VTABLE(ALnullState);
-
-
-/* This constructs the effect state. It's called when the object is first
- * created. Make sure to call the parent Construct function first, and set the
- * vtable!
- */
-static void ALnullState_Construct(ALnullState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALnullState, ALeffectState, state);
-}
-
-/* This destructs (not free!) the effect state. It's called only when the
- * effect slot is no longer used. Make sure to call the parent Destruct
- * function before returning!
- */
-static ALvoid ALnullState_Destruct(ALnullState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-/* This updates the device-dependant effect state. This is called on
- * initialization and any time the device parameters (eg. playback frequency,
- * format) have been changed.
- */
-static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice* UNUSED(device))
-{
- return AL_TRUE;
-}
-
-/* This updates the effect state. This is called any time the effect is
- * (re)loaded into a slot.
- */
-static ALvoid ALnullState_update(ALnullState* UNUSED(state), const ALCcontext* UNUSED(context), const ALeffectslot* UNUSED(slot), const ALeffectProps* UNUSED(props))
-{
-}
-
-/* This processes the effect state, for the given number of samples from the
- * input to the output buffer. The result should be added to the output buffer,
- * not replace it.
- */
-static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALsizei UNUSED(samplesToDo), const ALfloatBUFFERSIZE*restrict UNUSED(samplesIn), ALfloatBUFFERSIZE*restrict UNUSED(samplesOut), ALsizei UNUSED(numChannels))
-{
-}
-
-/* This allocates memory to store the object, before it gets constructed.
- * DECLARE_DEFAULT_ALLOCATORS can be used to declare a default method.
- */
-static void *ALnullState_New(size_t size)
-{
- return al_malloc(16, size);
-}
-
-/* This frees the memory used by the object, after it has been destructed.
- * DECLARE_DEFAULT_ALLOCATORS can be used to declare a default method.
- */
-static void ALnullState_Delete(void *ptr)
-{
- al_free(ptr);
-}
-
-
-typedef struct NullStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} NullStateFactory;
-
-/* Creates ALeffectState objects of the appropriate type. */
-ALeffectState *NullStateFactory_create(NullStateFactory *UNUSED(factory))
-{
- ALnullState *state;
-
- NEW_OBJ0(state, ALnullState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-/* Define the EffectStateFactory vtable for this type. */
-DEFINE_EFFECTSTATEFACTORY_VTABLE(NullStateFactory);
-
-EffectStateFactory *NullStateFactory_getFactory(void)
-{
- static NullStateFactory NullFactory = { { GET_VTABLE2(NullStateFactory, EffectStateFactory) } };
- return STATIC_CAST(EffectStateFactory, &NullFactory);
-}
-
-
-void ALnull_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x", param);
- }
-}
-void ALnull_setParamiv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALint* UNUSED(vals))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect integer-vector property 0x%04x", param);
- }
-}
-void ALnull_setParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect float property 0x%04x", param);
- }
-}
-void ALnull_setParamfv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat* UNUSED(vals))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect float-vector property 0x%04x", param);
- }
-}
-
-void ALnull_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x", param);
- }
-}
-void ALnull_getParamiv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect integer-vector property 0x%04x", param);
- }
-}
-void ALnull_getParamf(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect float property 0x%04x", param);
- }
-}
-void ALnull_getParamfv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals))
-{
- switch(param)
- {
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid null effect float-vector property 0x%04x", param);
- }
-}
-
-DEFINE_ALEFFECT_VTABLE(ALnull);
diff --git a/Alc/effects/pshifter.c b/Alc/effects/pshifter.c
deleted file mode 100644
index ed18e9a8..00000000
--- a/Alc/effects/pshifter.c
+++ /dev/null
@@ -1,441 +0,0 @@
-/**
- * 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"
-
-#include "alcomplex.h"
-
-
-#define STFT_SIZE 1024
-#define STFT_HALF_SIZE (STFT_SIZE>>1)
-#define OVERSAMP (1<<2)
-
-#define STFT_STEP (STFT_SIZE / OVERSAMP)
-#define FIFO_LATENCY (STFT_STEP * (OVERSAMP-1))
-
-
-typedef struct ALphasor {
- ALdouble Amplitude;
- ALdouble Phase;
-} ALphasor;
-
-typedef struct ALFrequencyDomain {
- ALdouble Amplitude;
- ALdouble Frequency;
-} ALfrequencyDomain;
-
-
-typedef struct ALpshifterState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- /* Effect parameters */
- ALsizei count;
- ALsizei PitchShiftI;
- ALfloat PitchShift;
- ALfloat FreqPerBin;
-
- /*Effects buffers*/
- ALfloat InFIFO[STFT_SIZE];
- ALfloat OutFIFO[STFT_STEP];
- ALdouble LastPhase[STFT_HALF_SIZE+1];
- ALdouble SumPhase[STFT_HALF_SIZE+1];
- ALdouble OutputAccum[STFT_SIZE];
-
- ALcomplex FFTbuffer[STFT_SIZE];
-
- ALfrequencyDomain Analysis_buffer[STFT_HALF_SIZE+1];
- ALfrequencyDomain Syntesis_buffer[STFT_HALF_SIZE+1];
-
- alignas(16) ALfloat BufferOut[BUFFERSIZE];
-
- /* Effect gains for each output channel */
- ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
- ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
-} ALpshifterState;
-
-static ALvoid ALpshifterState_Destruct(ALpshifterState *state);
-static ALboolean ALpshifterState_deviceUpdate(ALpshifterState *state, ALCdevice *device);
-static ALvoid ALpshifterState_update(ALpshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALpshifterState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALpshifterState);
-
-
-/* Define a Hann window, used to filter the STFT input and output. */
-alignas(16) static ALdouble HannWindow[STFT_SIZE];
-
-static void InitHannWindow(void)
-{
- ALsizei i;
-
- /* Create lookup table of the Hann window for the desired size, i.e. STFT_SIZE */
- for(i = 0;i < STFT_SIZE>>1;i++)
- {
- ALdouble val = sin(M_PI * (ALdouble)i / (ALdouble)(STFT_SIZE-1));
- HannWindow[i] = HannWindow[STFT_SIZE-1-i] = val * val;
- }
-}
-static alonce_flag HannInitOnce = AL_ONCE_FLAG_INIT;
-
-
-static inline ALint double2int(ALdouble d)
-{
-#if ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__)) && \
- !defined(__SSE2_MATH__)) || (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP < 2)
- ALint sign, shift;
- ALint64 mant;
- union {
- ALdouble d;
- ALint64 i64;
- } conv;
-
- conv.d = d;
- sign = (conv.i64>>63) | 1;
- shift = ((conv.i64>>52)&0x7ff) - (1023+52);
-
- /* Over/underflow */
- if(UNLIKELY(shift >= 63 || shift < -52))
- return 0;
-
- mant = (conv.i64&I64(0xfffffffffffff)) | I64(0x10000000000000);
- if(LIKELY(shift < 0))
- return (ALint)(mant >> -shift) * sign;
- return (ALint)(mant << shift) * sign;
-
-#else
-
- return (ALint)d;
-#endif
-}
-
-
-/* Converts ALcomplex to ALphasor */
-static inline ALphasor rect2polar(ALcomplex number)
-{
- ALphasor polar;
-
- polar.Amplitude = sqrt(number.Real*number.Real + number.Imag*number.Imag);
- polar.Phase = atan2(number.Imag, number.Real);
-
- return polar;
-}
-
-/* Converts ALphasor to ALcomplex */
-static inline ALcomplex polar2rect(ALphasor number)
-{
- ALcomplex cartesian;
-
- cartesian.Real = number.Amplitude * cos(number.Phase);
- cartesian.Imag = number.Amplitude * sin(number.Phase);
-
- return cartesian;
-}
-
-
-static void ALpshifterState_Construct(ALpshifterState *state)
-{
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALpshifterState, ALeffectState, state);
-
- alcall_once(&HannInitOnce, InitHannWindow);
-}
-
-static ALvoid ALpshifterState_Destruct(ALpshifterState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
-}
-
-static ALboolean ALpshifterState_deviceUpdate(ALpshifterState *state, ALCdevice *device)
-{
- /* (Re-)initializing parameters and clear the buffers. */
- state->count = FIFO_LATENCY;
- state->PitchShiftI = FRACTIONONE;
- state->PitchShift = 1.0f;
- state->FreqPerBin = device->Frequency / (ALfloat)STFT_SIZE;
-
- memset(state->InFIFO, 0, sizeof(state->InFIFO));
- memset(state->OutFIFO, 0, sizeof(state->OutFIFO));
- memset(state->FFTbuffer, 0, sizeof(state->FFTbuffer));
- memset(state->LastPhase, 0, sizeof(state->LastPhase));
- memset(state->SumPhase, 0, sizeof(state->SumPhase));
- memset(state->OutputAccum, 0, sizeof(state->OutputAccum));
- memset(state->Analysis_buffer, 0, sizeof(state->Analysis_buffer));
- memset(state->Syntesis_buffer, 0, sizeof(state->Syntesis_buffer));
-
- memset(state->CurrentGains, 0, sizeof(state->CurrentGains));
- memset(state->TargetGains, 0, sizeof(state->TargetGains));
-
- return AL_TRUE;
-}
-
-static ALvoid ALpshifterState_update(ALpshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
-{
- const ALCdevice *device = context->Device;
- ALfloat coeffs[MAX_AMBI_COEFFS];
- float pitch;
-
- pitch = powf(2.0f,
- (ALfloat)(props->Pshifter.CoarseTune*100 + props->Pshifter.FineTune) / 1200.0f
- );
- state->PitchShiftI = fastf2i(pitch*FRACTIONONE);
- state->PitchShift = state->PitchShiftI * (1.0f/FRACTIONONE);
-
- CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->TargetGains);
-}
-
-static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- /* Pitch shifter engine based on the work of Stephan Bernsee.
- * http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
- */
-
- static const ALdouble expected = M_PI*2.0 / OVERSAMP;
- const ALdouble freq_per_bin = state->FreqPerBin;
- ALfloat *restrict bufferOut = state->BufferOut;
- ALsizei count = state->count;
- ALsizei i, j, k;
-
- for(i = 0;i < SamplesToDo;)
- {
- do {
- /* Fill FIFO buffer with samples data */
- state->InFIFO[count] = SamplesIn[0][i];
- bufferOut[i] = state->OutFIFO[count - FIFO_LATENCY];
-
- count++;
- } while(++i < SamplesToDo && count < STFT_SIZE);
-
- /* Check whether FIFO buffer is filled */
- if(count < STFT_SIZE) break;
- count = FIFO_LATENCY;
-
- /* Real signal windowing and store in FFTbuffer */
- for(k = 0;k < STFT_SIZE;k++)
- {
- state->FFTbuffer[k].Real = state->InFIFO[k] * HannWindow[k];
- state->FFTbuffer[k].Imag = 0.0;
- }
-
- /* ANALYSIS */
- /* Apply FFT to FFTbuffer data */
- complex_fft(state->FFTbuffer, STFT_SIZE, -1.0);
-
- /* Analyze the obtained data. Since the real FFT is symmetric, only
- * STFT_HALF_SIZE+1 samples are needed.
- */
- for(k = 0;k < STFT_HALF_SIZE+1;k++)
- {
- ALphasor component;
- ALdouble tmp;
- ALint qpd;
-
- /* Compute amplitude and phase */
- component = rect2polar(state->FFTbuffer[k]);
-
- /* Compute phase difference and subtract expected phase difference */
- tmp = (component.Phase - state->LastPhase[k]) - k*expected;
-
- /* Map delta phase into +/- Pi interval */
- qpd = double2int(tmp / M_PI);
- tmp -= M_PI * (qpd + (qpd%2));
-
- /* Get deviation from bin frequency from the +/- Pi interval */
- tmp /= expected;
-
- /* Compute the k-th partials' true frequency, twice the amplitude
- * for maintain the gain (because half of bins are used) and store
- * amplitude and true frequency in analysis buffer.
- */
- state->Analysis_buffer[k].Amplitude = 2.0 * component.Amplitude;
- state->Analysis_buffer[k].Frequency = (k + tmp) * freq_per_bin;
-
- /* Store actual phase[k] for the calculations in the next frame*/
- state->LastPhase[k] = component.Phase;
- }
-
- /* PROCESSING */
- /* pitch shifting */
- for(k = 0;k < STFT_HALF_SIZE+1;k++)
- {
- state->Syntesis_buffer[k].Amplitude = 0.0;
- state->Syntesis_buffer[k].Frequency = 0.0;
- }
-
- for(k = 0;k < STFT_HALF_SIZE+1;k++)
- {
- j = (k*state->PitchShiftI) >> FRACTIONBITS;
- if(j >= STFT_HALF_SIZE+1) break;
-
- state->Syntesis_buffer[j].Amplitude += state->Analysis_buffer[k].Amplitude;
- state->Syntesis_buffer[j].Frequency = state->Analysis_buffer[k].Frequency *
- state->PitchShift;
- }
-
- /* SYNTHESIS */
- /* Synthesis the processing data */
- for(k = 0;k < STFT_HALF_SIZE+1;k++)
- {
- ALphasor component;
- ALdouble tmp;
-
- /* Compute bin deviation from scaled freq */
- tmp = state->Syntesis_buffer[k].Frequency/freq_per_bin - k;
-
- /* Calculate actual delta phase and accumulate it to get bin phase */
- state->SumPhase[k] += (k + tmp) * expected;
-
- component.Amplitude = state->Syntesis_buffer[k].Amplitude;
- component.Phase = state->SumPhase[k];
-
- /* Compute phasor component to cartesian complex number and storage it into FFTbuffer*/
- state->FFTbuffer[k] = polar2rect(component);
- }
- /* zero negative frequencies for recontruct a real signal */
- for(k = STFT_HALF_SIZE+1;k < STFT_SIZE;k++)
- {
- state->FFTbuffer[k].Real = 0.0;
- state->FFTbuffer[k].Imag = 0.0;
- }
-
- /* Apply iFFT to buffer data */
- complex_fft(state->FFTbuffer, STFT_SIZE, 1.0);
-
- /* Windowing and add to output */
- for(k = 0;k < STFT_SIZE;k++)
- state->OutputAccum[k] += HannWindow[k] * state->FFTbuffer[k].Real /
- (0.5 * STFT_HALF_SIZE * OVERSAMP);
-
- /* Shift accumulator, input & output FIFO */
- for(k = 0;k < STFT_STEP;k++) state->OutFIFO[k] = (ALfloat)state->OutputAccum[k];
- for(j = 0;k < STFT_SIZE;k++,j++) state->OutputAccum[j] = state->OutputAccum[k];
- for(;j < STFT_SIZE;j++) state->OutputAccum[j] = 0.0;
- for(k = 0;k < FIFO_LATENCY;k++)
- state->InFIFO[k] = state->InFIFO[k+STFT_STEP];
- }
- state->count = count;
-
- /* Now, mix the processed sound data to the output. */
- MixSamples(bufferOut, NumChannels, SamplesOut, state->CurrentGains, state->TargetGains,
- maxi(SamplesToDo, 512), 0, SamplesToDo);
-}
-
-typedef struct PshifterStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} PshifterStateFactory;
-
-static ALeffectState *PshifterStateFactory_create(PshifterStateFactory *UNUSED(factory))
-{
- ALpshifterState *state;
-
- NEW_OBJ0(state, ALpshifterState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(PshifterStateFactory);
-
-EffectStateFactory *PshifterStateFactory_getFactory(void)
-{
- static PshifterStateFactory PshifterFactory = { { GET_VTABLE2(PshifterStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &PshifterFactory);
-}
-
-
-void ALpshifter_setParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val))
-{
- alSetError( context, AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param );
-}
-
-void ALpshifter_setParamfv(ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat *UNUSED(vals))
-{
- alSetError( context, AL_INVALID_ENUM, "Invalid pitch shifter float-vector property 0x%04x", param );
-}
-
-void ALpshifter_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_PITCH_SHIFTER_COARSE_TUNE:
- if(!(val >= AL_PITCH_SHIFTER_MIN_COARSE_TUNE && val <= AL_PITCH_SHIFTER_MAX_COARSE_TUNE))
- SETERR_RETURN(context, AL_INVALID_VALUE,,"Pitch shifter coarse tune out of range");
- props->Pshifter.CoarseTune = val;
- break;
-
- case AL_PITCH_SHIFTER_FINE_TUNE:
- if(!(val >= AL_PITCH_SHIFTER_MIN_FINE_TUNE && val <= AL_PITCH_SHIFTER_MAX_FINE_TUNE))
- SETERR_RETURN(context, AL_INVALID_VALUE,,"Pitch shifter fine tune out of range");
- props->Pshifter.FineTune = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x", param);
- }
-}
-void ALpshifter_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{
- ALpshifter_setParami(effect, context, param, vals[0]);
-}
-
-void ALpshifter_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_PITCH_SHIFTER_COARSE_TUNE:
- *val = (ALint)props->Pshifter.CoarseTune;
- break;
- case AL_PITCH_SHIFTER_FINE_TUNE:
- *val = (ALint)props->Pshifter.FineTune;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x", param);
- }
-}
-void ALpshifter_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{
- ALpshifter_getParami(effect, context, param, vals);
-}
-
-void ALpshifter_getParamf(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat *UNUSED(val))
-{
- alSetError(context, AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param);
-}
-
-void ALpshifter_getParamfv(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum param, ALfloat *UNUSED(vals))
-{
- alSetError(context, AL_INVALID_ENUM, "Invalid pitch shifter float vector-property 0x%04x", param);
-}
-
-DEFINE_ALEFFECT_VTABLE(ALpshifter);
diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c
deleted file mode 100644
index 8ebc089e..00000000
--- a/Alc/effects/reverb.c
+++ /dev/null
@@ -1,2090 +0,0 @@
-/**
- * Ambisonic reverb engine for the OpenAL cross platform audio library
- * Copyright (C) 2008-2017 by Chris Robinson and Christopher Fitzgerald.
- * 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 <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-#include "alMain.h"
-#include "alu.h"
-#include "alAuxEffectSlot.h"
-#include "alListener.h"
-#include "alError.h"
-#include "filters/defs.h"
-
-/* This is a user config option for modifying the overall output of the reverb
- * effect.
- */
-ALfloat ReverbBoost = 1.0f;
-
-/* This is the maximum number of samples processed for each inner loop
- * iteration. */
-#define MAX_UPDATE_SAMPLES 256
-
-/* The number of samples used for cross-faded delay lines. This can be used
- * to balance the compensation for abrupt line changes and attenuation due to
- * minimally lengthed recursive lines. Try to keep this below the device
- * update size.
- */
-#define FADE_SAMPLES 128
-
-/* The number of spatialized lines or channels to process. Four channels allows
- * for a 3D A-Format response. NOTE: This can't be changed without taking care
- * of the conversion matrices, and a few places where the length arrays are
- * assumed to have 4 elements.
- */
-#define NUM_LINES 4
-
-
-/* The B-Format to A-Format conversion matrix. The arrangement of rows is
- * deliberately chosen to align the resulting lines to their spatial opposites
- * (0:above front left <-> 3:above back right, 1:below front right <-> 2:below
- * back left). It's not quite opposite, since the A-Format results in a
- * tetrahedron, but it's close enough. Should the model be extended to 8-lines
- * in the future, true opposites can be used.
- */
-static const aluMatrixf B2A = {{
- { 0.288675134595f, 0.288675134595f, 0.288675134595f, 0.288675134595f },
- { 0.288675134595f, -0.288675134595f, -0.288675134595f, 0.288675134595f },
- { 0.288675134595f, 0.288675134595f, -0.288675134595f, -0.288675134595f },
- { 0.288675134595f, -0.288675134595f, 0.288675134595f, -0.288675134595f }
-}};
-
-/* Converts A-Format to B-Format. */
-static const aluMatrixf A2B = {{
- { 0.866025403785f, 0.866025403785f, 0.866025403785f, 0.866025403785f },
- { 0.866025403785f, -0.866025403785f, 0.866025403785f, -0.866025403785f },
- { 0.866025403785f, -0.866025403785f, -0.866025403785f, 0.866025403785f },
- { 0.866025403785f, 0.866025403785f, -0.866025403785f, -0.866025403785f }
-}};
-
-static const ALfloat FadeStep = 1.0f / FADE_SAMPLES;
-
-/* The all-pass and delay lines have a variable length dependent on the
- * effect's density parameter, which helps alter the perceived environment
- * size. The size-to-density conversion is a cubed scale:
- *
- * density = min(1.0, pow(size, 3.0) / DENSITY_SCALE);
- *
- * The line lengths scale linearly with room size, so the inverse density
- * conversion is needed, taking the cube root of the re-scaled density to
- * calculate the line length multiplier:
- *
- * length_mult = max(5.0, cbrtf(density*DENSITY_SCALE));
- *
- * The density scale below will result in a max line multiplier of 50, for an
- * effective size range of 5m to 50m.
- */
-static const ALfloat DENSITY_SCALE = 125000.0f;
-
-/* All delay line lengths are specified in seconds.
- *
- * To approximate early reflections, we break them up into primary (those
- * arriving from the same direction as the source) and secondary (those
- * arriving from the opposite direction).
- *
- * The early taps decorrelate the 4-channel signal to approximate an average
- * room response for the primary reflections after the initial early delay.
- *
- * Given an average room dimension (d_a) and the speed of sound (c) we can
- * calculate the average reflection delay (r_a) regardless of listener and
- * source positions as:
- *
- * r_a = d_a / c
- * c = 343.3
- *
- * This can extended to finding the average difference (r_d) between the
- * maximum (r_1) and minimum (r_0) reflection delays:
- *
- * r_0 = 2 / 3 r_a
- * = r_a - r_d / 2
- * = r_d
- * r_1 = 4 / 3 r_a
- * = r_a + r_d / 2
- * = 2 r_d
- * r_d = 2 / 3 r_a
- * = r_1 - r_0
- *
- * As can be determined by integrating the 1D model with a source (s) and
- * listener (l) positioned across the dimension of length (d_a):
- *
- * r_d = int_(l=0)^d_a (int_(s=0)^d_a |2 d_a - 2 (l + s)| ds) dl / c
- *
- * The initial taps (T_(i=0)^N) are then specified by taking a power series
- * that ranges between r_0 and half of r_1 less r_0:
- *
- * R_i = 2^(i / (2 N - 1)) r_d
- * = r_0 + (2^(i / (2 N - 1)) - 1) r_d
- * = r_0 + T_i
- * T_i = R_i - r_0
- * = (2^(i / (2 N - 1)) - 1) r_d
- *
- * Assuming an average of 1m, we get the following taps:
- */
-static const ALfloat EARLY_TAP_LENGTHS[NUM_LINES] =
-{
- 0.0000000e+0f, 2.0213520e-4f, 4.2531060e-4f, 6.7171600e-4f
-};
-
-/* The early all-pass filter lengths are based on the early tap lengths:
- *
- * A_i = R_i / a
- *
- * Where a is the approximate maximum all-pass cycle limit (20).
- */
-static const ALfloat EARLY_ALLPASS_LENGTHS[NUM_LINES] =
-{
- 9.7096800e-5f, 1.0720356e-4f, 1.1836234e-4f, 1.3068260e-4f
-};
-
-/* The early delay lines are used to transform the primary reflections into
- * the secondary reflections. The A-format is arranged in such a way that
- * the channels/lines are spatially opposite:
- *
- * C_i is opposite C_(N-i-1)
- *
- * The delays of the two opposing reflections (R_i and O_i) from a source
- * anywhere along a particular dimension always sum to twice its full delay:
- *
- * 2 r_a = R_i + O_i
- *
- * With that in mind we can determine the delay between the two reflections
- * and thus specify our early line lengths (L_(i=0)^N) using:
- *
- * O_i = 2 r_a - R_(N-i-1)
- * L_i = O_i - R_(N-i-1)
- * = 2 (r_a - R_(N-i-1))
- * = 2 (r_a - T_(N-i-1) - r_0)
- * = 2 r_a (1 - (2 / 3) 2^((N - i - 1) / (2 N - 1)))
- *
- * Using an average dimension of 1m, we get:
- */
-static const ALfloat EARLY_LINE_LENGTHS[NUM_LINES] =
-{
- 5.9850400e-4f, 1.0913150e-3f, 1.5376658e-3f, 1.9419362e-3f
-};
-
-/* The late all-pass filter lengths are based on the late line lengths:
- *
- * A_i = (5 / 3) L_i / r_1
- */
-static const ALfloat LATE_ALLPASS_LENGTHS[NUM_LINES] =
-{
- 1.6182800e-4f, 2.0389060e-4f, 2.8159360e-4f, 3.2365600e-4f
-};
-
-/* The late lines are used to approximate the decaying cycle of recursive
- * late reflections.
- *
- * Splitting the lines in half, we start with the shortest reflection paths
- * (L_(i=0)^(N/2)):
- *
- * L_i = 2^(i / (N - 1)) r_d
- *
- * Then for the opposite (longest) reflection paths (L_(i=N/2)^N):
- *
- * L_i = 2 r_a - L_(i-N/2)
- * = 2 r_a - 2^((i - N / 2) / (N - 1)) r_d
- *
- * For our 1m average room, we get:
- */
-static const ALfloat LATE_LINE_LENGTHS[NUM_LINES] =
-{
- 1.9419362e-3f, 2.4466860e-3f, 3.3791220e-3f, 3.8838720e-3f
-};
-
-
-typedef struct DelayLineI {
- /* The delay lines use interleaved samples, with the lengths being powers
- * of 2 to allow the use of bit-masking instead of a modulus for wrapping.
- */
- ALsizei Mask;
- ALfloat (*Line)[NUM_LINES];
-} DelayLineI;
-
-typedef struct VecAllpass {
- DelayLineI Delay;
- ALfloat Coeff;
- ALsizei Offset[NUM_LINES][2];
-} VecAllpass;
-
-typedef struct T60Filter {
- /* Two filters are used to adjust the signal. One to control the low
- * frequencies, and one to control the high frequencies.
- */
- ALfloat MidGain[2];
- BiquadFilter HFFilter, LFFilter;
-} T60Filter;
-
-typedef struct EarlyReflections {
- /* A Gerzon vector all-pass filter is used to simulate initial diffusion.
- * The spread from this filter also helps smooth out the reverb tail.
- */
- VecAllpass VecAp;
-
- /* An echo line is used to complete the second half of the early
- * reflections.
- */
- DelayLineI Delay;
- ALsizei Offset[NUM_LINES][2];
- ALfloat Coeff[NUM_LINES][2];
-
- /* The gain for each output channel based on 3D panning. */
- ALfloat CurrentGain[NUM_LINES][MAX_OUTPUT_CHANNELS];
- ALfloat PanGain[NUM_LINES][MAX_OUTPUT_CHANNELS];
-} EarlyReflections;
-
-typedef struct LateReverb {
- /* A recursive delay line is used fill in the reverb tail. */
- DelayLineI Delay;
- ALsizei Offset[NUM_LINES][2];
-
- /* Attenuation to compensate for the modal density and decay rate of the
- * late lines.
- */
- ALfloat DensityGain[2];
-
- /* T60 decay filters are used to simulate absorption. */
- T60Filter T60[NUM_LINES];
-
- /* A Gerzon vector all-pass filter is used to simulate diffusion. */
- VecAllpass VecAp;
-
- /* The gain for each output channel based on 3D panning. */
- ALfloat CurrentGain[NUM_LINES][MAX_OUTPUT_CHANNELS];
- ALfloat PanGain[NUM_LINES][MAX_OUTPUT_CHANNELS];
-} LateReverb;
-
-typedef struct ReverbState {
- DERIVE_FROM_TYPE(ALeffectState);
-
- /* All delay lines are allocated as a single buffer to reduce memory
- * fragmentation and management code.
- */
- ALfloat *SampleBuffer;
- ALuint TotalSamples;
-
- struct {
- /* Calculated parameters which indicate if cross-fading is needed after
- * an update.
- */
- ALfloat Density, Diffusion;
- ALfloat DecayTime, HFDecayTime, LFDecayTime;
- ALfloat HFReference, LFReference;
- } Params;
-
- /* Master effect filters */
- struct {
- BiquadFilter Lp;
- BiquadFilter Hp;
- } Filter[NUM_LINES];
-
- /* Core delay line (early reflections and late reverb tap from this). */
- DelayLineI Delay;
-
- /* Tap points for early reflection delay. */
- ALsizei EarlyDelayTap[NUM_LINES][2];
- ALfloat EarlyDelayCoeff[NUM_LINES][2];
-
- /* Tap points for late reverb feed and delay. */
- ALsizei LateFeedTap;
- ALsizei LateDelayTap[NUM_LINES][2];
-
- /* Coefficients for the all-pass and line scattering matrices. */
- ALfloat MixX;
- ALfloat MixY;
-
- EarlyReflections Early;
-
- LateReverb Late;
-
- /* Indicates the cross-fade point for delay line reads [0,FADE_SAMPLES]. */
- ALsizei FadeCount;
-
- /* Maximum number of samples to process at once. */
- ALsizei MaxUpdate[2];
-
- /* The current write offset for all delay lines. */
- ALsizei Offset;
-
- /* Temporary storage used when processing. */
- alignas(16) ALfloat TempSamples[NUM_LINES][MAX_UPDATE_SAMPLES];
- alignas(16) ALfloat MixSamples[NUM_LINES][MAX_UPDATE_SAMPLES];
-} ReverbState;
-
-static ALvoid ReverbState_Destruct(ReverbState *State);
-static ALboolean ReverbState_deviceUpdate(ReverbState *State, ALCdevice *Device);
-static ALvoid ReverbState_update(ReverbState *State, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props);
-static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ReverbState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ReverbState);
-
-static void ReverbState_Construct(ReverbState *state)
-{
- ALsizei i, j;
-
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ReverbState, ALeffectState, state);
-
- state->TotalSamples = 0;
- state->SampleBuffer = NULL;
-
- state->Params.Density = AL_EAXREVERB_DEFAULT_DENSITY;
- state->Params.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
- state->Params.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME;
- state->Params.HFDecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME*AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
- state->Params.LFDecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME*AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
- state->Params.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
- state->Params.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
-
- for(i = 0;i < NUM_LINES;i++)
- {
- BiquadFilter_clear(&state->Filter[i].Lp);
- BiquadFilter_clear(&state->Filter[i].Hp);
- }
-
- state->Delay.Mask = 0;
- state->Delay.Line = NULL;
-
- for(i = 0;i < NUM_LINES;i++)
- {
- state->EarlyDelayTap[i][0] = 0;
- state->EarlyDelayTap[i][1] = 0;
- state->EarlyDelayCoeff[i][0] = 0.0f;
- state->EarlyDelayCoeff[i][1] = 0.0f;
- }
-
- state->LateFeedTap = 0;
-
- for(i = 0;i < NUM_LINES;i++)
- {
- state->LateDelayTap[i][0] = 0;
- state->LateDelayTap[i][1] = 0;
- }
-
- state->MixX = 0.0f;
- state->MixY = 0.0f;
-
- state->Early.VecAp.Delay.Mask = 0;
- state->Early.VecAp.Delay.Line = NULL;
- state->Early.VecAp.Coeff = 0.0f;
- state->Early.Delay.Mask = 0;
- state->Early.Delay.Line = NULL;
- for(i = 0;i < NUM_LINES;i++)
- {
- state->Early.VecAp.Offset[i][0] = 0;
- state->Early.VecAp.Offset[i][1] = 0;
- state->Early.Offset[i][0] = 0;
- state->Early.Offset[i][1] = 0;
- state->Early.Coeff[i][0] = 0.0f;
- state->Early.Coeff[i][1] = 0.0f;
- }
-
- state->Late.DensityGain[0] = 0.0f;
- state->Late.DensityGain[1] = 0.0f;
- state->Late.Delay.Mask = 0;
- state->Late.Delay.Line = NULL;
- state->Late.VecAp.Delay.Mask = 0;
- state->Late.VecAp.Delay.Line = NULL;
- state->Late.VecAp.Coeff = 0.0f;
- for(i = 0;i < NUM_LINES;i++)
- {
- state->Late.Offset[i][0] = 0;
- state->Late.Offset[i][1] = 0;
-
- state->Late.VecAp.Offset[i][0] = 0;
- state->Late.VecAp.Offset[i][1] = 0;
-
- state->Late.T60[i].MidGain[0] = 0.0f;
- state->Late.T60[i].MidGain[1] = 0.0f;
- BiquadFilter_clear(&state->Late.T60[i].HFFilter);
- BiquadFilter_clear(&state->Late.T60[i].LFFilter);
- }
-
- for(i = 0;i < NUM_LINES;i++)
- {
- for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
- {
- state->Early.CurrentGain[i][j] = 0.0f;
- state->Early.PanGain[i][j] = 0.0f;
- state->Late.CurrentGain[i][j] = 0.0f;
- state->Late.PanGain[i][j] = 0.0f;
- }
- }
-
- state->FadeCount = 0;
- state->MaxUpdate[0] = MAX_UPDATE_SAMPLES;
- state->MaxUpdate[1] = MAX_UPDATE_SAMPLES;
- state->Offset = 0;
-}
-
-static ALvoid ReverbState_Destruct(ReverbState *State)
-{
- al_free(State->SampleBuffer);
- State->SampleBuffer = NULL;
-
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,State));
-}
-
-/**************************************
- * Device Update *
- **************************************/
-
-static inline ALfloat CalcDelayLengthMult(ALfloat density)
-{
- return maxf(5.0f, cbrtf(density*DENSITY_SCALE));
-}
-
-/* Given the allocated sample buffer, this function updates each delay line
- * offset.
- */
-static inline ALvoid RealizeLineOffset(ALfloat *sampleBuffer, DelayLineI *Delay)
-{
- union {
- ALfloat *f;
- ALfloat (*f4)[NUM_LINES];
- } u;
- u.f = &sampleBuffer[(ptrdiff_t)Delay->Line * NUM_LINES];
- Delay->Line = u.f4;
-}
-
-/* Calculate the length of a delay line and store its mask and offset. */
-static ALuint CalcLineLength(const ALfloat length, const ptrdiff_t offset, const ALuint frequency,
- const ALuint extra, DelayLineI *Delay)
-{
- ALuint samples;
-
- /* All line lengths are powers of 2, calculated from their lengths in
- * seconds, rounded up.
- */
- samples = float2int(ceilf(length*frequency));
- samples = NextPowerOf2(samples + extra);
-
- /* All lines share a single sample buffer. */
- Delay->Mask = samples - 1;
- Delay->Line = (ALfloat(*)[NUM_LINES])offset;
-
- /* Return the sample count for accumulation. */
- return samples;
-}
-
-/* Calculates the delay line metrics and allocates the shared sample buffer
- * for all lines given the sample rate (frequency). If an allocation failure
- * occurs, it returns AL_FALSE.
- */
-static ALboolean AllocLines(const ALuint frequency, ReverbState *State)
-{
- ALuint totalSamples, i;
- ALfloat multiplier, length;
-
- /* All delay line lengths are calculated to accomodate the full range of
- * lengths given their respective paramters.
- */
- totalSamples = 0;
-
- /* Multiplier for the maximum density value, i.e. density=1, which is
- * actually the least density...
- */
- multiplier = CalcDelayLengthMult(AL_EAXREVERB_MAX_DENSITY);
-
- /* The main delay length includes the maximum early reflection delay, the
- * largest early tap width, the maximum late reverb delay, and the
- * largest late tap width. Finally, it must also be extended by the
- * update size (MAX_UPDATE_SAMPLES) for block processing.
- */
- length = AL_EAXREVERB_MAX_REFLECTIONS_DELAY + EARLY_TAP_LENGTHS[NUM_LINES-1]*multiplier +
- AL_EAXREVERB_MAX_LATE_REVERB_DELAY +
- (LATE_LINE_LENGTHS[NUM_LINES-1] - LATE_LINE_LENGTHS[0])*0.25f*multiplier;
- totalSamples += CalcLineLength(length, totalSamples, frequency, MAX_UPDATE_SAMPLES,
- &State->Delay);
-
- /* The early vector all-pass line. */
- length = EARLY_ALLPASS_LENGTHS[NUM_LINES-1] * multiplier;
- totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
- &State->Early.VecAp.Delay);
-
- /* The early reflection line. */
- length = EARLY_LINE_LENGTHS[NUM_LINES-1] * multiplier;
- totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
- &State->Early.Delay);
-
- /* The late vector all-pass line. */
- length = LATE_ALLPASS_LENGTHS[NUM_LINES-1] * multiplier;
- totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
- &State->Late.VecAp.Delay);
-
- /* The late delay lines are calculated from the largest maximum density
- * line length.
- */
- length = LATE_LINE_LENGTHS[NUM_LINES-1] * multiplier;
- totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
- &State->Late.Delay);
-
- if(totalSamples != State->TotalSamples)
- {
- ALfloat *newBuffer;
-
- TRACE("New reverb buffer length: %ux4 samples\n", totalSamples);
- newBuffer = al_calloc(16, sizeof(ALfloat[NUM_LINES]) * totalSamples);
- if(!newBuffer) return AL_FALSE;
-
- al_free(State->SampleBuffer);
- State->SampleBuffer = newBuffer;
- State->TotalSamples = totalSamples;
- }
-
- /* Update all delays to reflect the new sample buffer. */
- RealizeLineOffset(State->SampleBuffer, &State->Delay);
- RealizeLineOffset(State->SampleBuffer, &State->Early.VecAp.Delay);
- RealizeLineOffset(State->SampleBuffer, &State->Early.Delay);
- RealizeLineOffset(State->SampleBuffer, &State->Late.VecAp.Delay);
- RealizeLineOffset(State->SampleBuffer, &State->Late.Delay);
-
- /* Clear the sample buffer. */
- for(i = 0;i < State->TotalSamples;i++)
- State->SampleBuffer[i] = 0.0f;
-
- return AL_TRUE;
-}
-
-static ALboolean ReverbState_deviceUpdate(ReverbState *State, ALCdevice *Device)
-{
- ALuint frequency = Device->Frequency;
- ALfloat multiplier;
- ALsizei i, j;
-
- /* Allocate the delay lines. */
- if(!AllocLines(frequency, State))
- return AL_FALSE;
-
- multiplier = CalcDelayLengthMult(AL_EAXREVERB_MAX_DENSITY);
-
- /* The late feed taps are set a fixed position past the latest delay tap. */
- State->LateFeedTap = float2int((AL_EAXREVERB_MAX_REFLECTIONS_DELAY +
- EARLY_TAP_LENGTHS[NUM_LINES-1]*multiplier) *
- frequency);
-
- /* Clear filters and gain coefficients since the delay lines were all just
- * cleared (if not reallocated).
- */
- for(i = 0;i < NUM_LINES;i++)
- {
- BiquadFilter_clear(&State->Filter[i].Lp);
- BiquadFilter_clear(&State->Filter[i].Hp);
- }
-
- for(i = 0;i < NUM_LINES;i++)
- {
- State->EarlyDelayCoeff[i][0] = 0.0f;
- State->EarlyDelayCoeff[i][1] = 0.0f;
- }
-
- for(i = 0;i < NUM_LINES;i++)
- {
- State->Early.Coeff[i][0] = 0.0f;
- State->Early.Coeff[i][1] = 0.0f;
- }
-
- State->Late.DensityGain[0] = 0.0f;
- State->Late.DensityGain[1] = 0.0f;
- for(i = 0;i < NUM_LINES;i++)
- {
- State->Late.T60[i].MidGain[0] = 0.0f;
- State->Late.T60[i].MidGain[1] = 0.0f;
- BiquadFilter_clear(&State->Late.T60[i].HFFilter);
- BiquadFilter_clear(&State->Late.T60[i].LFFilter);
- }
-
- for(i = 0;i < NUM_LINES;i++)
- {
- for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
- {
- State->Early.CurrentGain[i][j] = 0.0f;
- State->Early.PanGain[i][j] = 0.0f;
- State->Late.CurrentGain[i][j] = 0.0f;
- State->Late.PanGain[i][j] = 0.0f;
- }
- }
-
- /* Reset counters and offset base. */
- State->FadeCount = 0;
- State->MaxUpdate[0] = MAX_UPDATE_SAMPLES;
- State->MaxUpdate[1] = MAX_UPDATE_SAMPLES;
- State->Offset = 0;
-
- return AL_TRUE;
-}
-
-/**************************************
- * Effect Update *
- **************************************/
-
-/* Calculate a decay coefficient given the length of each cycle and the time
- * until the decay reaches -60 dB.
- */
-static inline ALfloat CalcDecayCoeff(const ALfloat length, const ALfloat decayTime)
-{
- return powf(REVERB_DECAY_GAIN, length/decayTime);
-}
-
-/* Calculate a decay length from a coefficient and the time until the decay
- * reaches -60 dB.
- */
-static inline ALfloat CalcDecayLength(const ALfloat coeff, const ALfloat decayTime)
-{
- return log10f(coeff) * decayTime / log10f(REVERB_DECAY_GAIN);
-}
-
-/* Calculate an attenuation to be applied to the input of any echo models to
- * compensate for modal density and decay time.
- */
-static inline ALfloat CalcDensityGain(const ALfloat a)
-{
- /* The energy of a signal can be obtained by finding the area under the
- * squared signal. This takes the form of Sum(x_n^2), where x is the
- * amplitude for the sample n.
- *
- * Decaying feedback matches exponential decay of the form Sum(a^n),
- * where a is the attenuation coefficient, and n is the sample. The area
- * under this decay curve can be calculated as: 1 / (1 - a).
- *
- * Modifying the above equation to find the area under the squared curve
- * (for energy) yields: 1 / (1 - a^2). Input attenuation can then be
- * calculated by inverting the square root of this approximation,
- * yielding: 1 / sqrt(1 / (1 - a^2)), simplified to: sqrt(1 - a^2).
- */
- return sqrtf(1.0f - a*a);
-}
-
-/* Calculate the scattering matrix coefficients given a diffusion factor. */
-static inline ALvoid CalcMatrixCoeffs(const ALfloat diffusion, ALfloat *x, ALfloat *y)
-{
- ALfloat n, t;
-
- /* The matrix is of order 4, so n is sqrt(4 - 1). */
- n = sqrtf(3.0f);
- t = diffusion * atanf(n);
-
- /* Calculate the first mixing matrix coefficient. */
- *x = cosf(t);
- /* Calculate the second mixing matrix coefficient. */
- *y = sinf(t) / n;
-}
-
-/* Calculate the limited HF ratio for use with the late reverb low-pass
- * filters.
- */
-static ALfloat CalcLimitedHfRatio(const ALfloat hfRatio, const ALfloat airAbsorptionGainHF,
- const ALfloat decayTime, const ALfloat SpeedOfSound)
-{
- ALfloat limitRatio;
-
- /* Find the attenuation due to air absorption in dB (converting delay
- * time to meters using the speed of sound). Then reversing the decay
- * equation, solve for HF ratio. The delay length is cancelled out of
- * the equation, so it can be calculated once for all lines.
- */
- limitRatio = 1.0f / (CalcDecayLength(airAbsorptionGainHF, decayTime) * SpeedOfSound);
-
- /* Using the limit calculated above, apply the upper bound to the HF ratio.
- */
- return minf(limitRatio, hfRatio);
-}
-
-
-/* Calculates the 3-band T60 damping coefficients for a particular delay line
- * of specified length, using a combination of two shelf filter sections given
- * decay times for each band split at two reference frequencies.
- */
-static void CalcT60DampingCoeffs(const ALfloat length, const ALfloat lfDecayTime,
- const ALfloat mfDecayTime, const ALfloat hfDecayTime,
- const ALfloat lf0norm, const ALfloat hf0norm,
- T60Filter *filter)
-{
- ALfloat lfGain = CalcDecayCoeff(length, lfDecayTime);
- ALfloat mfGain = CalcDecayCoeff(length, mfDecayTime);
- ALfloat hfGain = CalcDecayCoeff(length, hfDecayTime);
-
- filter->MidGain[1] = mfGain;
- BiquadFilter_setParams(&filter->LFFilter, BiquadType_LowShelf, lfGain/mfGain, lf0norm,
- calc_rcpQ_from_slope(lfGain/mfGain, 1.0f));
- BiquadFilter_setParams(&filter->HFFilter, BiquadType_HighShelf, hfGain/mfGain, hf0norm,
- calc_rcpQ_from_slope(hfGain/mfGain, 1.0f));
-}
-
-/* Update the offsets for the main effect delay line. */
-static ALvoid UpdateDelayLine(const ALfloat earlyDelay, const ALfloat lateDelay, const ALfloat density, const ALfloat decayTime, const ALuint frequency, ReverbState *State)
-{
- ALfloat multiplier, length;
- ALuint i;
-
- multiplier = CalcDelayLengthMult(density);
-
- /* Early reflection taps are decorrelated by means of an average room
- * reflection approximation described above the definition of the taps.
- * This approximation is linear and so the above density multiplier can
- * be applied to adjust the width of the taps. A single-band decay
- * coefficient is applied to simulate initial attenuation and absorption.
- *
- * Late reverb taps are based on the late line lengths to allow a zero-
- * delay path and offsets that would continue the propagation naturally
- * into the late lines.
- */
- for(i = 0;i < NUM_LINES;i++)
- {
- length = earlyDelay + EARLY_TAP_LENGTHS[i]*multiplier;
- State->EarlyDelayTap[i][1] = float2int(length * frequency);
-
- length = EARLY_TAP_LENGTHS[i]*multiplier;
- State->EarlyDelayCoeff[i][1] = CalcDecayCoeff(length, decayTime);
-
- length = lateDelay + (LATE_LINE_LENGTHS[i] - LATE_LINE_LENGTHS[0])*0.25f*multiplier;
- State->LateDelayTap[i][1] = State->LateFeedTap + float2int(length * frequency);
- }
-}
-
-/* Update the early reflection line lengths and gain coefficients. */
-static ALvoid UpdateEarlyLines(const ALfloat density, const ALfloat diffusion, const ALfloat decayTime, const ALuint frequency, EarlyReflections *Early)
-{
- ALfloat multiplier, length;
- ALsizei i;
-
- multiplier = CalcDelayLengthMult(density);
-
- /* Calculate the all-pass feed-back/forward coefficient. */
- Early->VecAp.Coeff = sqrtf(0.5f) * powf(diffusion, 2.0f);
-
- for(i = 0;i < NUM_LINES;i++)
- {
- /* Calculate the length (in seconds) of each all-pass line. */
- length = EARLY_ALLPASS_LENGTHS[i] * multiplier;
-
- /* Calculate the delay offset for each all-pass line. */
- Early->VecAp.Offset[i][1] = float2int(length * frequency);
-
- /* Calculate the length (in seconds) of each delay line. */
- length = EARLY_LINE_LENGTHS[i] * multiplier;
-
- /* Calculate the delay offset for each delay line. */
- Early->Offset[i][1] = float2int(length * frequency);
-
- /* Calculate the gain (coefficient) for each line. */
- Early->Coeff[i][1] = CalcDecayCoeff(length, decayTime);
- }
-}
-
-/* Update the late reverb line lengths and T60 coefficients. */
-static ALvoid UpdateLateLines(const ALfloat density, const ALfloat diffusion, const ALfloat lfDecayTime, const ALfloat mfDecayTime, const ALfloat hfDecayTime, const ALfloat lf0norm, const ALfloat hf0norm, const ALuint frequency, LateReverb *Late)
-{
- /* Scaling factor to convert the normalized reference frequencies from
- * representing 0...freq to 0...max_reference.
- */
- const ALfloat norm_weight_factor = (ALfloat)frequency / AL_EAXREVERB_MAX_HFREFERENCE;
- ALfloat multiplier, length, bandWeights[3];
- ALsizei i;
-
- /* To compensate for changes in modal density and decay time of the late
- * reverb signal, the input is attenuated based on the maximal energy of
- * the outgoing signal. This approximation is used to keep the apparent
- * energy of the signal equal for all ranges of density and decay time.
- *
- * The average length of the delay lines is used to calculate the
- * attenuation coefficient.
- */
- multiplier = CalcDelayLengthMult(density);
- length = (LATE_LINE_LENGTHS[0] + LATE_LINE_LENGTHS[1] +
- LATE_LINE_LENGTHS[2] + LATE_LINE_LENGTHS[3]) / 4.0f * multiplier;
- length += (LATE_ALLPASS_LENGTHS[0] + LATE_ALLPASS_LENGTHS[1] +
- LATE_ALLPASS_LENGTHS[2] + LATE_ALLPASS_LENGTHS[3]) / 4.0f * multiplier;
- /* The density gain calculation uses an average decay time weighted by
- * approximate bandwidth. This attempts to compensate for losses of energy
- * that reduce decay time due to scattering into highly attenuated bands.
- */
- bandWeights[0] = lf0norm*norm_weight_factor;
- bandWeights[1] = hf0norm*norm_weight_factor - lf0norm*norm_weight_factor;
- bandWeights[2] = 1.0f - hf0norm*norm_weight_factor;
- Late->DensityGain[1] = CalcDensityGain(
- CalcDecayCoeff(length,
- bandWeights[0]*lfDecayTime + bandWeights[1]*mfDecayTime + bandWeights[2]*hfDecayTime
- )
- );
-
- /* Calculate the all-pass feed-back/forward coefficient. */
- Late->VecAp.Coeff = sqrtf(0.5f) * powf(diffusion, 2.0f);
-
- for(i = 0;i < NUM_LINES;i++)
- {
- /* Calculate the length (in seconds) of each all-pass line. */
- length = LATE_ALLPASS_LENGTHS[i] * multiplier;
-
- /* Calculate the delay offset for each all-pass line. */
- Late->VecAp.Offset[i][1] = float2int(length * frequency);
-
- /* Calculate the length (in seconds) of each delay line. */
- length = LATE_LINE_LENGTHS[i] * multiplier;
-
- /* Calculate the delay offset for each delay line. */
- Late->Offset[i][1] = float2int(length*frequency + 0.5f);
-
- /* Approximate the absorption that the vector all-pass would exhibit
- * given the current diffusion so we don't have to process a full T60
- * filter for each of its four lines.
- */
- length += lerp(LATE_ALLPASS_LENGTHS[i],
- (LATE_ALLPASS_LENGTHS[0] + LATE_ALLPASS_LENGTHS[1] +
- LATE_ALLPASS_LENGTHS[2] + LATE_ALLPASS_LENGTHS[3]) / 4.0f,
- diffusion) * multiplier;
-
- /* Calculate the T60 damping coefficients for each line. */
- CalcT60DampingCoeffs(length, lfDecayTime, mfDecayTime, hfDecayTime,
- lf0norm, hf0norm, &Late->T60[i]);
- }
-}
-
-/* Creates a transform matrix given a reverb vector. The vector pans the reverb
- * reflections toward the given direction, using its magnitude (up to 1) as a
- * focal strength. This function results in a B-Format transformation matrix
- * that spatially focuses the signal in the desired direction.
- */
-static aluMatrixf GetTransformFromVector(const ALfloat *vec)
-{
- aluMatrixf focus;
- ALfloat norm[3];
- ALfloat mag;
-
- /* Normalize the panning vector according to the N3D scale, which has an
- * extra sqrt(3) term on the directional components. Converting from OpenAL
- * to B-Format also requires negating X (ACN 1) and Z (ACN 3). Note however
- * that the reverb panning vectors use left-handed coordinates, unlike the
- * rest of OpenAL which use right-handed. This is fixed by negating Z,
- * which cancels out with the B-Format Z negation.
- */
- mag = sqrtf(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
- if(mag > 1.0f)
- {
- norm[0] = vec[0] / mag * -SQRTF_3;
- norm[1] = vec[1] / mag * SQRTF_3;
- norm[2] = vec[2] / mag * SQRTF_3;
- mag = 1.0f;
- }
- else
- {
- /* If the magnitude is less than or equal to 1, just apply the sqrt(3)
- * term. There's no need to renormalize the magnitude since it would
- * just be reapplied in the matrix.
- */
- norm[0] = vec[0] * -SQRTF_3;
- norm[1] = vec[1] * SQRTF_3;
- norm[2] = vec[2] * SQRTF_3;
- }
-
- aluMatrixfSet(&focus,
- 1.0f, 0.0f, 0.0f, 0.0f,
- norm[0], 1.0f-mag, 0.0f, 0.0f,
- norm[1], 0.0f, 1.0f-mag, 0.0f,
- norm[2], 0.0f, 0.0f, 1.0f-mag
- );
-
- return focus;
-}
-
-/* Update the early and late 3D panning gains. */
-static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *ReflectionsPan, const ALfloat *LateReverbPan, const ALfloat earlyGain, const ALfloat lateGain, ReverbState *State)
-{
- aluMatrixf transform, rot;
- ALsizei i;
-
- STATIC_CAST(ALeffectState,State)->OutBuffer = Device->FOAOut.Buffer;
- STATIC_CAST(ALeffectState,State)->OutChannels = Device->FOAOut.NumChannels;
-
- /* Note: _res is transposed. */
-#define MATRIX_MULT(_res, _m1, _m2) do { \
- int row, col; \
- for(col = 0;col < 4;col++) \
- { \
- for(row = 0;row < 4;row++) \
- _res.m[col][row] = _m1.m[row][0]*_m2.m[0][col] + _m1.m[row][1]*_m2.m[1][col] + \
- _m1.m[row][2]*_m2.m[2][col] + _m1.m[row][3]*_m2.m[3][col]; \
- } \
-} while(0)
- /* Create a matrix that first converts A-Format to B-Format, then
- * transforms the B-Format signal according to the panning vector.
- */
- rot = GetTransformFromVector(ReflectionsPan);
- MATRIX_MULT(transform, rot, A2B);
- memset(&State->Early.PanGain, 0, sizeof(State->Early.PanGain));
- for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
- ComputePanGains(&Device->FOAOut, transform.m[i], earlyGain,
- State->Early.PanGain[i]);
-
- rot = GetTransformFromVector(LateReverbPan);
- MATRIX_MULT(transform, rot, A2B);
- memset(&State->Late.PanGain, 0, sizeof(State->Late.PanGain));
- for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
- ComputePanGains(&Device->FOAOut, transform.m[i], lateGain,
- State->Late.PanGain[i]);
-#undef MATRIX_MULT
-}
-
-static void ReverbState_update(ReverbState *State, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props)
-{
- const ALCdevice *Device = Context->Device;
- const ALlistener *Listener = Context->Listener;
- ALuint frequency = Device->Frequency;
- ALfloat lf0norm, hf0norm, hfRatio;
- ALfloat lfDecayTime, hfDecayTime;
- ALfloat gain, gainlf, gainhf;
- ALsizei i;
-
- /* Calculate the master filters */
- hf0norm = minf(props->Reverb.HFReference / frequency, 0.49f);
- /* Restrict the filter gains from going below -60dB to keep the filter from
- * killing most of the signal.
- */
- gainhf = maxf(props->Reverb.GainHF, 0.001f);
- BiquadFilter_setParams(&State->Filter[0].Lp, BiquadType_HighShelf, gainhf, hf0norm,
- calc_rcpQ_from_slope(gainhf, 1.0f));
- lf0norm = minf(props->Reverb.LFReference / frequency, 0.49f);
- gainlf = maxf(props->Reverb.GainLF, 0.001f);
- BiquadFilter_setParams(&State->Filter[0].Hp, BiquadType_LowShelf, gainlf, lf0norm,
- calc_rcpQ_from_slope(gainlf, 1.0f));
- for(i = 1;i < NUM_LINES;i++)
- {
- BiquadFilter_copyParams(&State->Filter[i].Lp, &State->Filter[0].Lp);
- BiquadFilter_copyParams(&State->Filter[i].Hp, &State->Filter[0].Hp);
- }
-
- /* Update the main effect delay and associated taps. */
- UpdateDelayLine(props->Reverb.ReflectionsDelay, props->Reverb.LateReverbDelay,
- props->Reverb.Density, props->Reverb.DecayTime, frequency,
- State);
-
- /* Update the early lines. */
- UpdateEarlyLines(props->Reverb.Density, props->Reverb.Diffusion,
- props->Reverb.DecayTime, frequency, &State->Early);
-
- /* Get the mixing matrix coefficients. */
- CalcMatrixCoeffs(props->Reverb.Diffusion, &State->MixX, &State->MixY);
-
- /* If the HF limit parameter is flagged, calculate an appropriate limit
- * based on the air absorption parameter.
- */
- hfRatio = props->Reverb.DecayHFRatio;
- if(props->Reverb.DecayHFLimit && props->Reverb.AirAbsorptionGainHF < 1.0f)
- hfRatio = CalcLimitedHfRatio(hfRatio, props->Reverb.AirAbsorptionGainHF,
- props->Reverb.DecayTime, Listener->Params.ReverbSpeedOfSound
- );
-
- /* Calculate the LF/HF decay times. */
- lfDecayTime = clampf(props->Reverb.DecayTime * props->Reverb.DecayLFRatio,
- AL_EAXREVERB_MIN_DECAY_TIME, AL_EAXREVERB_MAX_DECAY_TIME);
- hfDecayTime = clampf(props->Reverb.DecayTime * hfRatio,
- AL_EAXREVERB_MIN_DECAY_TIME, AL_EAXREVERB_MAX_DECAY_TIME);
-
- /* Update the late lines. */
- UpdateLateLines(props->Reverb.Density, props->Reverb.Diffusion,
- lfDecayTime, props->Reverb.DecayTime, hfDecayTime, lf0norm, hf0norm,
- frequency, &State->Late
- );
-
- /* Update early and late 3D panning. */
- gain = props->Reverb.Gain * Slot->Params.Gain * ReverbBoost;
- Update3DPanning(Device, props->Reverb.ReflectionsPan, props->Reverb.LateReverbPan,
- props->Reverb.ReflectionsGain*gain, props->Reverb.LateReverbGain*gain,
- State);
-
- /* Calculate the max update size from the smallest relevant delay. */
- State->MaxUpdate[1] = mini(MAX_UPDATE_SAMPLES,
- mini(State->Early.Offset[0][1], State->Late.Offset[0][1])
- );
-
- /* Determine if delay-line cross-fading is required. Density is essentially
- * a master control for the feedback delays, so changes the offsets of many
- * delay lines.
- */
- if(State->Params.Density != props->Reverb.Density ||
- /* Diffusion and decay times influences the decay rate (gain) of the
- * late reverb T60 filter.
- */
- State->Params.Diffusion != props->Reverb.Diffusion ||
- State->Params.DecayTime != props->Reverb.DecayTime ||
- State->Params.HFDecayTime != hfDecayTime ||
- State->Params.LFDecayTime != lfDecayTime ||
- /* HF/LF References control the weighting used to calculate the density
- * gain.
- */
- State->Params.HFReference != props->Reverb.HFReference ||
- State->Params.LFReference != props->Reverb.LFReference)
- State->FadeCount = 0;
- State->Params.Density = props->Reverb.Density;
- State->Params.Diffusion = props->Reverb.Diffusion;
- State->Params.DecayTime = props->Reverb.DecayTime;
- State->Params.HFDecayTime = hfDecayTime;
- State->Params.LFDecayTime = lfDecayTime;
- State->Params.HFReference = props->Reverb.HFReference;
- State->Params.LFReference = props->Reverb.LFReference;
-}
-
-
-/**************************************
- * Effect Processing *
- **************************************/
-
-/* Basic delay line input/output routines. */
-static inline ALfloat DelayLineOut(const DelayLineI *Delay, const ALsizei offset, const ALsizei c)
-{
- return Delay->Line[offset&Delay->Mask][c];
-}
-
-/* Cross-faded delay line output routine. Instead of interpolating the
- * offsets, this interpolates (cross-fades) the outputs at each offset.
- */
-static inline ALfloat FadedDelayLineOut(const DelayLineI *Delay, const ALsizei off0,
- const ALsizei off1, const ALsizei c,
- const ALfloat sc0, const ALfloat sc1)
-{
- return Delay->Line[off0&Delay->Mask][c]*sc0 +
- Delay->Line[off1&Delay->Mask][c]*sc1;
-}
-
-
-static inline void DelayLineIn(const DelayLineI *Delay, ALsizei offset, const ALsizei c,
- const ALfloat *restrict in, ALsizei count)
-{
- ALsizei i;
- for(i = 0;i < count;i++)
- Delay->Line[(offset++)&Delay->Mask][c] = *(in++);
-}
-
-/* Applies a scattering matrix to the 4-line (vector) input. This is used
- * for both the below vector all-pass model and to perform modal feed-back
- * delay network (FDN) mixing.
- *
- * The matrix is derived from a skew-symmetric matrix to form a 4D rotation
- * matrix with a single unitary rotational parameter:
- *
- * [ d, a, b, c ] 1 = a^2 + b^2 + c^2 + d^2
- * [ -a, d, c, -b ]
- * [ -b, -c, d, a ]
- * [ -c, b, -a, d ]
- *
- * The rotation is constructed from the effect's diffusion parameter,
- * yielding:
- *
- * 1 = x^2 + 3 y^2
- *
- * Where a, b, and c are the coefficient y with differing signs, and d is the
- * coefficient x. The final matrix is thus:
- *
- * [ x, y, -y, y ] n = sqrt(matrix_order - 1)
- * [ -y, x, y, y ] t = diffusion_parameter * atan(n)
- * [ y, -y, x, y ] x = cos(t)
- * [ -y, -y, -y, x ] y = sin(t) / n
- *
- * Any square orthogonal matrix with an order that is a power of two will
- * work (where ^T is transpose, ^-1 is inverse):
- *
- * M^T = M^-1
- *
- * Using that knowledge, finding an appropriate matrix can be accomplished
- * naively by searching all combinations of:
- *
- * M = D + S - S^T
- *
- * Where D is a diagonal matrix (of x), and S is a triangular matrix (of y)
- * whose combination of signs are being iterated.
- */
-static inline void VectorPartialScatter(ALfloat *restrict out, const ALfloat *restrict in,
- const ALfloat xCoeff, const ALfloat yCoeff)
-{
- out[0] = xCoeff*in[0] + yCoeff*( in[1] + -in[2] + in[3]);
- out[1] = xCoeff*in[1] + yCoeff*(-in[0] + in[2] + in[3]);
- out[2] = xCoeff*in[2] + yCoeff*( in[0] + -in[1] + in[3]);
- out[3] = xCoeff*in[3] + yCoeff*(-in[0] + -in[1] + -in[2] );
-}
-#define VectorScatterDelayIn(delay, o, in, xcoeff, ycoeff) \
- VectorPartialScatter((delay)->Line[(o)&(delay)->Mask], in, xcoeff, ycoeff)
-
-/* Utilizes the above, but reverses the input channels. */
-static inline void VectorScatterRevDelayIn(const DelayLineI *Delay, ALint offset,
- const ALfloat xCoeff, const ALfloat yCoeff,
- const ALfloat (*restrict in)[MAX_UPDATE_SAMPLES],
- const ALsizei count)
-{
- const DelayLineI delay = *Delay;
- ALsizei i, j;
-
- for(i = 0;i < count;++i)
- {
- ALfloat f[NUM_LINES];
- for(j = 0;j < NUM_LINES;j++)
- f[NUM_LINES-1-j] = in[j][i];
-
- VectorScatterDelayIn(&delay, offset++, f, xCoeff, yCoeff);
- }
-}
-
-/* This applies a Gerzon multiple-in/multiple-out (MIMO) vector all-pass
- * filter to the 4-line input.
- *
- * It works by vectorizing a regular all-pass filter and replacing the delay
- * element with a scattering matrix (like the one above) and a diagonal
- * matrix of delay elements.
- *
- * Two static specializations are used for transitional (cross-faded) delay
- * line processing and non-transitional processing.
- */
-static void VectorAllpass_Unfaded(ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
- const ALfloat xCoeff, const ALfloat yCoeff, ALsizei todo,
- VecAllpass *Vap)
-{
- const DelayLineI delay = Vap->Delay;
- const ALfloat feedCoeff = Vap->Coeff;
- ALsizei vap_offset[NUM_LINES];
- ALsizei i, j;
-
- ASSUME(todo > 0);
-
- for(j = 0;j < NUM_LINES;j++)
- vap_offset[j] = offset-Vap->Offset[j][0];
- for(i = 0;i < todo;i++)
- {
- ALfloat f[NUM_LINES];
-
- for(j = 0;j < NUM_LINES;j++)
- {
- ALfloat input = samples[j][i];
- ALfloat out = DelayLineOut(&delay, vap_offset[j]++, j) - feedCoeff*input;
- f[j] = input + feedCoeff*out;
-
- samples[j][i] = out;
- }
-
- VectorScatterDelayIn(&delay, offset, f, xCoeff, yCoeff);
- ++offset;
- }
-}
-static void VectorAllpass_Faded(ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
- const ALfloat xCoeff, const ALfloat yCoeff, ALfloat fade,
- ALsizei todo, VecAllpass *Vap)
-{
- const DelayLineI delay = Vap->Delay;
- const ALfloat feedCoeff = Vap->Coeff;
- ALsizei vap_offset[NUM_LINES][2];
- ALsizei i, j;
-
- ASSUME(todo > 0);
-
- fade *= 1.0f/FADE_SAMPLES;
- for(j = 0;j < NUM_LINES;j++)
- {
- vap_offset[j][0] = offset-Vap->Offset[j][0];
- vap_offset[j][1] = offset-Vap->Offset[j][1];
- }
- for(i = 0;i < todo;i++)
- {
- ALfloat f[NUM_LINES];
-
- for(j = 0;j < NUM_LINES;j++)
- {
- ALfloat input = samples[j][i];
- ALfloat out =
- FadedDelayLineOut(&delay, vap_offset[j][0]++, vap_offset[j][1]++, j,
- 1.0f-fade, fade
- ) - feedCoeff*input;
- f[j] = input + feedCoeff*out;
-
- samples[j][i] = out;
- }
- fade += FadeStep;
-
- VectorScatterDelayIn(&delay, offset, f, xCoeff, yCoeff);
- ++offset;
- }
-}
-
-/* This generates early reflections.
- *
- * This is done by obtaining the primary reflections (those arriving from the
- * same direction as the source) from the main delay line. These are
- * attenuated and all-pass filtered (based on the diffusion parameter).
- *
- * The early lines are then fed in reverse (according to the approximately
- * opposite spatial location of the A-Format lines) to create the secondary
- * reflections (those arriving from the opposite direction as the source).
- *
- * The early response is then completed by combining the primary reflections
- * with the delayed and attenuated output from the early lines.
- *
- * Finally, the early response is reversed, scattered (based on diffusion),
- * and fed into the late reverb section of the main delay line.
- *
- * Two static specializations are used for transitional (cross-faded) delay
- * line processing and non-transitional processing.
- */
-static void EarlyReflection_Unfaded(ReverbState *State, ALsizei offset, const ALsizei todo,
- ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
-{
- ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
- const DelayLineI early_delay = State->Early.Delay;
- const DelayLineI main_delay = State->Delay;
- const ALfloat mixX = State->MixX;
- const ALfloat mixY = State->MixY;
- ALsizei late_feed_tap;
- ALsizei i, j;
-
- ASSUME(todo > 0);
-
- /* First, load decorrelated samples from the main delay line as the primary
- * reflections.
- */
- for(j = 0;j < NUM_LINES;j++)
- {
- ALsizei early_delay_tap = offset - State->EarlyDelayTap[j][0];
- ALfloat coeff = State->EarlyDelayCoeff[j][0];
- for(i = 0;i < todo;i++)
- temps[j][i] = DelayLineOut(&main_delay, early_delay_tap++, j) * coeff;
- }
-
- /* Apply a vector all-pass, to help color the initial reflections based on
- * the diffusion strength.
- */
- VectorAllpass_Unfaded(temps, offset, mixX, mixY, todo, &State->Early.VecAp);
-
- /* Apply a delay and bounce to generate secondary reflections, combine with
- * the primary reflections and write out the result for mixing.
- */
- for(j = 0;j < NUM_LINES;j++)
- {
- ALint early_feedb_tap = offset - State->Early.Offset[j][0];
- ALfloat early_feedb_coeff = State->Early.Coeff[j][0];
-
- for(i = 0;i < todo;i++)
- out[j][i] = DelayLineOut(&early_delay, early_feedb_tap++, j)*early_feedb_coeff +
- temps[j][i];
- }
- for(j = 0;j < NUM_LINES;j++)
- DelayLineIn(&early_delay, offset, NUM_LINES-1-j, temps[j], todo);
-
- /* Also write the result back to the main delay line for the late reverb
- * stage to pick up at the appropriate time, appplying a scatter and
- * bounce to improve the initial diffusion in the late reverb.
- */
- late_feed_tap = offset - State->LateFeedTap;
- VectorScatterRevDelayIn(&main_delay, late_feed_tap, mixX, mixY, out, todo);
-}
-static void EarlyReflection_Faded(ReverbState *State, ALsizei offset, const ALsizei todo,
- const ALfloat fade, ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
-{
- ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
- const DelayLineI early_delay = State->Early.Delay;
- const DelayLineI main_delay = State->Delay;
- const ALfloat mixX = State->MixX;
- const ALfloat mixY = State->MixY;
- ALsizei late_feed_tap;
- ALsizei i, j;
-
- ASSUME(todo > 0);
-
- for(j = 0;j < NUM_LINES;j++)
- {
- ALsizei early_delay_tap0 = offset - State->EarlyDelayTap[j][0];
- ALsizei early_delay_tap1 = offset - State->EarlyDelayTap[j][1];
- ALfloat oldCoeff = State->EarlyDelayCoeff[j][0];
- ALfloat oldCoeffStep = -oldCoeff / FADE_SAMPLES;
- ALfloat newCoeffStep = State->EarlyDelayCoeff[j][1] / FADE_SAMPLES;
- ALfloat fadeCount = fade;
-
- for(i = 0;i < todo;i++)
- {
- const ALfloat fade0 = oldCoeff + oldCoeffStep*fadeCount;
- const ALfloat fade1 = newCoeffStep*fadeCount;
- temps[j][i] = FadedDelayLineOut(&main_delay,
- early_delay_tap0++, early_delay_tap1++, j, fade0, fade1
- );
- fadeCount += 1.0f;
- }
- }
-
- VectorAllpass_Faded(temps, offset, mixX, mixY, fade, todo, &State->Early.VecAp);
-
- for(j = 0;j < NUM_LINES;j++)
- {
- ALint feedb_tap0 = offset - State->Early.Offset[j][0];
- ALint feedb_tap1 = offset - State->Early.Offset[j][1];
- ALfloat feedb_oldCoeff = State->Early.Coeff[j][0];
- ALfloat feedb_oldCoeffStep = -feedb_oldCoeff / FADE_SAMPLES;
- ALfloat feedb_newCoeffStep = State->Early.Coeff[j][1] / FADE_SAMPLES;
- ALfloat fadeCount = fade;
-
- for(i = 0;i < todo;i++)
- {
- const ALfloat fade0 = feedb_oldCoeff + feedb_oldCoeffStep*fadeCount;
- const ALfloat fade1 = feedb_newCoeffStep*fadeCount;
- out[j][i] = FadedDelayLineOut(&early_delay,
- feedb_tap0++, feedb_tap1++, j, fade0, fade1
- ) + temps[j][i];
- fadeCount += 1.0f;
- }
- }
- for(j = 0;j < NUM_LINES;j++)
- DelayLineIn(&early_delay, offset, NUM_LINES-1-j, temps[j], todo);
-
- late_feed_tap = offset - State->LateFeedTap;
- VectorScatterRevDelayIn(&main_delay, late_feed_tap, mixX, mixY, out, todo);
-}
-
-/* Applies the two T60 damping filter sections. */
-static inline void LateT60Filter(ALfloat *restrict samples, const ALsizei todo, T60Filter *filter)
-{
- ALfloat temp[MAX_UPDATE_SAMPLES];
- BiquadFilter_process(&filter->HFFilter, temp, samples, todo);
- BiquadFilter_process(&filter->LFFilter, samples, temp, todo);
-}
-
-/* This generates the reverb tail using a modified feed-back delay network
- * (FDN).
- *
- * Results from the early reflections are mixed with the output from the late
- * delay lines.
- *
- * The late response is then completed by T60 and all-pass filtering the mix.
- *
- * Finally, the lines are reversed (so they feed their opposite directions)
- * and scattered with the FDN matrix before re-feeding the delay lines.
- *
- * Two variations are made, one for for transitional (cross-faded) delay line
- * processing and one for non-transitional processing.
- */
-static void LateReverb_Unfaded(ReverbState *State, ALsizei offset, const ALsizei todo,
- ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
-{
- ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
- const DelayLineI late_delay = State->Late.Delay;
- const DelayLineI main_delay = State->Delay;
- const ALfloat mixX = State->MixX;
- const ALfloat mixY = State->MixY;
- ALsizei i, j;
-
- ASSUME(todo > 0);
-
- /* First, load decorrelated samples from the main and feedback delay lines.
- * Filter the signal to apply its frequency-dependent decay.
- */
- for(j = 0;j < NUM_LINES;j++)
- {
- ALsizei late_delay_tap = offset - State->LateDelayTap[j][0];
- ALsizei late_feedb_tap = offset - State->Late.Offset[j][0];
- ALfloat midGain = State->Late.T60[j].MidGain[0];
- const ALfloat densityGain = State->Late.DensityGain[0] * midGain;
- for(i = 0;i < todo;i++)
- temps[j][i] = DelayLineOut(&main_delay, late_delay_tap++, j)*densityGain +
- DelayLineOut(&late_delay, late_feedb_tap++, j)*midGain;
- LateT60Filter(temps[j], todo, &State->Late.T60[j]);
- }
-
- /* Apply a vector all-pass to improve micro-surface diffusion, and write
- * out the results for mixing.
- */
- VectorAllpass_Unfaded(temps, offset, mixX, mixY, todo, &State->Late.VecAp);
-
- for(j = 0;j < NUM_LINES;j++)
- memcpy(out[j], temps[j], todo*sizeof(ALfloat));
-
- /* Finally, scatter and bounce the results to refeed the feedback buffer. */
- VectorScatterRevDelayIn(&late_delay, offset, mixX, mixY, out, todo);
-}
-static void LateReverb_Faded(ReverbState *State, ALsizei offset, const ALsizei todo,
- const ALfloat fade, ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
-{
- ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
- const DelayLineI late_delay = State->Late.Delay;
- const DelayLineI main_delay = State->Delay;
- const ALfloat mixX = State->MixX;
- const ALfloat mixY = State->MixY;
- ALsizei i, j;
-
- ASSUME(todo > 0);
-
- for(j = 0;j < NUM_LINES;j++)
- {
- const ALfloat oldMidGain = State->Late.T60[j].MidGain[0];
- const ALfloat midGain = State->Late.T60[j].MidGain[1];
- const ALfloat oldMidStep = -oldMidGain / FADE_SAMPLES;
- const ALfloat midStep = midGain / FADE_SAMPLES;
- const ALfloat oldDensityGain = State->Late.DensityGain[0] * oldMidGain;
- const ALfloat densityGain = State->Late.DensityGain[1] * midGain;
- const ALfloat oldDensityStep = -oldDensityGain / FADE_SAMPLES;
- const ALfloat densityStep = densityGain / FADE_SAMPLES;
- ALsizei late_delay_tap0 = offset - State->LateDelayTap[j][0];
- ALsizei late_delay_tap1 = offset - State->LateDelayTap[j][1];
- ALsizei late_feedb_tap0 = offset - State->Late.Offset[j][0];
- ALsizei late_feedb_tap1 = offset - State->Late.Offset[j][1];
- ALfloat fadeCount = fade;
-
- for(i = 0;i < todo;i++)
- {
- const ALfloat fade0 = oldDensityGain + oldDensityStep*fadeCount;
- const ALfloat fade1 = densityStep*fadeCount;
- const ALfloat gfade0 = oldMidGain + oldMidStep*fadeCount;
- const ALfloat gfade1 = midStep*fadeCount;
- temps[j][i] =
- FadedDelayLineOut(&main_delay, late_delay_tap0++, late_delay_tap1++, j,
- fade0, fade1) +
- FadedDelayLineOut(&late_delay, late_feedb_tap0++, late_feedb_tap1++, j,
- gfade0, gfade1);
- fadeCount += 1.0f;
- }
- LateT60Filter(temps[j], todo, &State->Late.T60[j]);
- }
-
- VectorAllpass_Faded(temps, offset, mixX, mixY, fade, todo, &State->Late.VecAp);
-
- for(j = 0;j < NUM_LINES;j++)
- memcpy(out[j], temps[j], todo*sizeof(ALfloat));
-
- VectorScatterRevDelayIn(&late_delay, offset, mixX, mixY, temps, todo);
-}
-
-static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
-{
- ALfloat (*restrict afmt)[MAX_UPDATE_SAMPLES] = State->TempSamples;
- ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES] = State->MixSamples;
- ALsizei fadeCount = State->FadeCount;
- ALsizei offset = State->Offset;
- ALsizei base, c;
-
- /* Process reverb for these samples. */
- for(base = 0;base < SamplesToDo;)
- {
- ALsizei todo = SamplesToDo - base;
- /* If cross-fading, don't do more samples than there are to fade. */
- if(FADE_SAMPLES-fadeCount > 0)
- {
- todo = mini(todo, FADE_SAMPLES-fadeCount);
- todo = mini(todo, State->MaxUpdate[0]);
- }
- todo = mini(todo, State->MaxUpdate[1]);
- /* If this is not the final update, ensure the update size is a
- * multiple of 4 for the SIMD mixers.
- */
- if(todo < SamplesToDo-base)
- todo &= ~3;
-
- /* Convert B-Format to A-Format for processing. */
- memset(afmt, 0, sizeof(*afmt)*NUM_LINES);
- for(c = 0;c < NUM_LINES;c++)
- MixRowSamples(afmt[c], B2A.m[c],
- SamplesIn, MAX_EFFECT_CHANNELS, base, todo
- );
-
- /* Process the samples for reverb. */
- for(c = 0;c < NUM_LINES;c++)
- {
- /* Band-pass the incoming samples. */
- BiquadFilter_process(&State->Filter[c].Lp, samples[0], afmt[c], todo);
- BiquadFilter_process(&State->Filter[c].Hp, samples[1], samples[0], todo);
-
- /* Feed the initial delay line. */
- DelayLineIn(&State->Delay, offset, c, samples[1], todo);
- }
-
- if(UNLIKELY(fadeCount < FADE_SAMPLES))
- {
- ALfloat fade = (ALfloat)fadeCount;
-
- /* Generate early reflections. */
- EarlyReflection_Faded(State, offset, todo, fade, samples);
- /* Mix the A-Format results to output, implicitly converting back
- * to B-Format.
- */
- for(c = 0;c < NUM_LINES;c++)
- MixSamples(samples[c], NumChannels, SamplesOut,
- State->Early.CurrentGain[c], State->Early.PanGain[c],
- SamplesToDo-base, base, todo
- );
-
- /* Generate and mix late reverb. */
- LateReverb_Faded(State, offset, todo, fade, samples);
- for(c = 0;c < NUM_LINES;c++)
- MixSamples(samples[c], NumChannels, SamplesOut,
- State->Late.CurrentGain[c], State->Late.PanGain[c],
- SamplesToDo-base, base, todo
- );
-
- /* Step fading forward. */
- fadeCount += todo;
- if(LIKELY(fadeCount >= FADE_SAMPLES))
- {
- /* Update the cross-fading delay line taps. */
- fadeCount = FADE_SAMPLES;
- for(c = 0;c < NUM_LINES;c++)
- {
- State->EarlyDelayTap[c][0] = State->EarlyDelayTap[c][1];
- State->EarlyDelayCoeff[c][0] = State->EarlyDelayCoeff[c][1];
- State->Early.VecAp.Offset[c][0] = State->Early.VecAp.Offset[c][1];
- State->Early.Offset[c][0] = State->Early.Offset[c][1];
- State->Early.Coeff[c][0] = State->Early.Coeff[c][1];
- State->LateDelayTap[c][0] = State->LateDelayTap[c][1];
- State->Late.VecAp.Offset[c][0] = State->Late.VecAp.Offset[c][1];
- State->Late.Offset[c][0] = State->Late.Offset[c][1];
- State->Late.T60[c].MidGain[0] = State->Late.T60[c].MidGain[1];
- }
- State->Late.DensityGain[0] = State->Late.DensityGain[1];
- State->MaxUpdate[0] = State->MaxUpdate[1];
- }
- }
- else
- {
- /* Generate and mix early reflections. */
- EarlyReflection_Unfaded(State, offset, todo, samples);
- for(c = 0;c < NUM_LINES;c++)
- MixSamples(samples[c], NumChannels, SamplesOut,
- State->Early.CurrentGain[c], State->Early.PanGain[c],
- SamplesToDo-base, base, todo
- );
-
- /* Generate and mix late reverb. */
- LateReverb_Unfaded(State, offset, todo, samples);
- for(c = 0;c < NUM_LINES;c++)
- MixSamples(samples[c], NumChannels, SamplesOut,
- State->Late.CurrentGain[c], State->Late.PanGain[c],
- SamplesToDo-base, base, todo
- );
- }
-
- /* Step all delays forward. */
- offset += todo;
-
- base += todo;
- }
- State->Offset = offset;
- State->FadeCount = fadeCount;
-}
-
-
-typedef struct ReverbStateFactory {
- DERIVE_FROM_TYPE(EffectStateFactory);
-} ReverbStateFactory;
-
-static ALeffectState *ReverbStateFactory_create(ReverbStateFactory* UNUSED(factory))
-{
- ReverbState *state;
-
- NEW_OBJ0(state, ReverbState)();
- if(!state) return NULL;
-
- return STATIC_CAST(ALeffectState, state);
-}
-
-DEFINE_EFFECTSTATEFACTORY_VTABLE(ReverbStateFactory);
-
-EffectStateFactory *ReverbStateFactory_getFactory(void)
-{
- static ReverbStateFactory ReverbFactory = { { GET_VTABLE2(ReverbStateFactory, EffectStateFactory) } };
-
- return STATIC_CAST(EffectStateFactory, &ReverbFactory);
-}
-
-
-void ALeaxreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EAXREVERB_DECAY_HFLIMIT:
- if(!(val >= AL_EAXREVERB_MIN_DECAY_HFLIMIT && val <= AL_EAXREVERB_MAX_DECAY_HFLIMIT))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay hflimit out of range");
- props->Reverb.DecayHFLimit = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
- param);
- }
-}
-void ALeaxreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{ ALeaxreverb_setParami(effect, context, param, vals[0]); }
-void ALeaxreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EAXREVERB_DENSITY:
- if(!(val >= AL_EAXREVERB_MIN_DENSITY && val <= AL_EAXREVERB_MAX_DENSITY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb density out of range");
- props->Reverb.Density = val;
- break;
-
- case AL_EAXREVERB_DIFFUSION:
- if(!(val >= AL_EAXREVERB_MIN_DIFFUSION && val <= AL_EAXREVERB_MAX_DIFFUSION))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb diffusion out of range");
- props->Reverb.Diffusion = val;
- break;
-
- case AL_EAXREVERB_GAIN:
- if(!(val >= AL_EAXREVERB_MIN_GAIN && val <= AL_EAXREVERB_MAX_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb gain out of range");
- props->Reverb.Gain = val;
- break;
-
- case AL_EAXREVERB_GAINHF:
- if(!(val >= AL_EAXREVERB_MIN_GAINHF && val <= AL_EAXREVERB_MAX_GAINHF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb gainhf out of range");
- props->Reverb.GainHF = val;
- break;
-
- case AL_EAXREVERB_GAINLF:
- if(!(val >= AL_EAXREVERB_MIN_GAINLF && val <= AL_EAXREVERB_MAX_GAINLF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb gainlf out of range");
- props->Reverb.GainLF = val;
- break;
-
- case AL_EAXREVERB_DECAY_TIME:
- if(!(val >= AL_EAXREVERB_MIN_DECAY_TIME && val <= AL_EAXREVERB_MAX_DECAY_TIME))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay time out of range");
- props->Reverb.DecayTime = val;
- break;
-
- case AL_EAXREVERB_DECAY_HFRATIO:
- if(!(val >= AL_EAXREVERB_MIN_DECAY_HFRATIO && val <= AL_EAXREVERB_MAX_DECAY_HFRATIO))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay hfratio out of range");
- props->Reverb.DecayHFRatio = val;
- break;
-
- case AL_EAXREVERB_DECAY_LFRATIO:
- if(!(val >= AL_EAXREVERB_MIN_DECAY_LFRATIO && val <= AL_EAXREVERB_MAX_DECAY_LFRATIO))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay lfratio out of range");
- props->Reverb.DecayLFRatio = val;
- break;
-
- case AL_EAXREVERB_REFLECTIONS_GAIN:
- if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN && val <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb reflections gain out of range");
- props->Reverb.ReflectionsGain = val;
- break;
-
- case AL_EAXREVERB_REFLECTIONS_DELAY:
- if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY && val <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb reflections delay out of range");
- props->Reverb.ReflectionsDelay = val;
- break;
-
- case AL_EAXREVERB_LATE_REVERB_GAIN:
- if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN && val <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb late reverb gain out of range");
- props->Reverb.LateReverbGain = val;
- break;
-
- case AL_EAXREVERB_LATE_REVERB_DELAY:
- if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY && val <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb late reverb delay out of range");
- props->Reverb.LateReverbDelay = val;
- break;
-
- case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
- if(!(val >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb air absorption gainhf out of range");
- props->Reverb.AirAbsorptionGainHF = val;
- break;
-
- case AL_EAXREVERB_ECHO_TIME:
- if(!(val >= AL_EAXREVERB_MIN_ECHO_TIME && val <= AL_EAXREVERB_MAX_ECHO_TIME))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb echo time out of range");
- props->Reverb.EchoTime = val;
- break;
-
- case AL_EAXREVERB_ECHO_DEPTH:
- if(!(val >= AL_EAXREVERB_MIN_ECHO_DEPTH && val <= AL_EAXREVERB_MAX_ECHO_DEPTH))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb echo depth out of range");
- props->Reverb.EchoDepth = val;
- break;
-
- case AL_EAXREVERB_MODULATION_TIME:
- if(!(val >= AL_EAXREVERB_MIN_MODULATION_TIME && val <= AL_EAXREVERB_MAX_MODULATION_TIME))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb modulation time out of range");
- props->Reverb.ModulationTime = val;
- break;
-
- case AL_EAXREVERB_MODULATION_DEPTH:
- if(!(val >= AL_EAXREVERB_MIN_MODULATION_DEPTH && val <= AL_EAXREVERB_MAX_MODULATION_DEPTH))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb modulation depth out of range");
- props->Reverb.ModulationDepth = val;
- break;
-
- case AL_EAXREVERB_HFREFERENCE:
- if(!(val >= AL_EAXREVERB_MIN_HFREFERENCE && val <= AL_EAXREVERB_MAX_HFREFERENCE))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb hfreference out of range");
- props->Reverb.HFReference = val;
- break;
-
- case AL_EAXREVERB_LFREFERENCE:
- if(!(val >= AL_EAXREVERB_MIN_LFREFERENCE && val <= AL_EAXREVERB_MAX_LFREFERENCE))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb lfreference out of range");
- props->Reverb.LFReference = val;
- break;
-
- case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
- if(!(val >= AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb room rolloff factor out of range");
- props->Reverb.RoomRolloffFactor = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x",
- param);
- }
-}
-void ALeaxreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EAXREVERB_REFLECTIONS_PAN:
- if(!(isfinite(vals[0]) && isfinite(vals[1]) && isfinite(vals[2])))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb reflections pan out of range");
- props->Reverb.ReflectionsPan[0] = vals[0];
- props->Reverb.ReflectionsPan[1] = vals[1];
- props->Reverb.ReflectionsPan[2] = vals[2];
- break;
- case AL_EAXREVERB_LATE_REVERB_PAN:
- if(!(isfinite(vals[0]) && isfinite(vals[1]) && isfinite(vals[2])))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb late reverb pan out of range");
- props->Reverb.LateReverbPan[0] = vals[0];
- props->Reverb.LateReverbPan[1] = vals[1];
- props->Reverb.LateReverbPan[2] = vals[2];
- break;
-
- default:
- ALeaxreverb_setParamf(effect, context, param, vals[0]);
- break;
- }
-}
-
-void ALeaxreverb_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EAXREVERB_DECAY_HFLIMIT:
- *val = props->Reverb.DecayHFLimit;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
- param);
- }
-}
-void ALeaxreverb_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{ ALeaxreverb_getParami(effect, context, param, vals); }
-void ALeaxreverb_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EAXREVERB_DENSITY:
- *val = props->Reverb.Density;
- break;
-
- case AL_EAXREVERB_DIFFUSION:
- *val = props->Reverb.Diffusion;
- break;
-
- case AL_EAXREVERB_GAIN:
- *val = props->Reverb.Gain;
- break;
-
- case AL_EAXREVERB_GAINHF:
- *val = props->Reverb.GainHF;
- break;
-
- case AL_EAXREVERB_GAINLF:
- *val = props->Reverb.GainLF;
- break;
-
- case AL_EAXREVERB_DECAY_TIME:
- *val = props->Reverb.DecayTime;
- break;
-
- case AL_EAXREVERB_DECAY_HFRATIO:
- *val = props->Reverb.DecayHFRatio;
- break;
-
- case AL_EAXREVERB_DECAY_LFRATIO:
- *val = props->Reverb.DecayLFRatio;
- break;
-
- case AL_EAXREVERB_REFLECTIONS_GAIN:
- *val = props->Reverb.ReflectionsGain;
- break;
-
- case AL_EAXREVERB_REFLECTIONS_DELAY:
- *val = props->Reverb.ReflectionsDelay;
- break;
-
- case AL_EAXREVERB_LATE_REVERB_GAIN:
- *val = props->Reverb.LateReverbGain;
- break;
-
- case AL_EAXREVERB_LATE_REVERB_DELAY:
- *val = props->Reverb.LateReverbDelay;
- break;
-
- case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
- *val = props->Reverb.AirAbsorptionGainHF;
- break;
-
- case AL_EAXREVERB_ECHO_TIME:
- *val = props->Reverb.EchoTime;
- break;
-
- case AL_EAXREVERB_ECHO_DEPTH:
- *val = props->Reverb.EchoDepth;
- break;
-
- case AL_EAXREVERB_MODULATION_TIME:
- *val = props->Reverb.ModulationTime;
- break;
-
- case AL_EAXREVERB_MODULATION_DEPTH:
- *val = props->Reverb.ModulationDepth;
- break;
-
- case AL_EAXREVERB_HFREFERENCE:
- *val = props->Reverb.HFReference;
- break;
-
- case AL_EAXREVERB_LFREFERENCE:
- *val = props->Reverb.LFReference;
- break;
-
- case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
- *val = props->Reverb.RoomRolloffFactor;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x",
- param);
- }
-}
-void ALeaxreverb_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_EAXREVERB_REFLECTIONS_PAN:
- vals[0] = props->Reverb.ReflectionsPan[0];
- vals[1] = props->Reverb.ReflectionsPan[1];
- vals[2] = props->Reverb.ReflectionsPan[2];
- break;
- case AL_EAXREVERB_LATE_REVERB_PAN:
- vals[0] = props->Reverb.LateReverbPan[0];
- vals[1] = props->Reverb.LateReverbPan[1];
- vals[2] = props->Reverb.LateReverbPan[2];
- break;
-
- default:
- ALeaxreverb_getParamf(effect, context, param, vals);
- break;
- }
-}
-
-DEFINE_ALEFFECT_VTABLE(ALeaxreverb);
-
-void ALreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_REVERB_DECAY_HFLIMIT:
- if(!(val >= AL_REVERB_MIN_DECAY_HFLIMIT && val <= AL_REVERB_MAX_DECAY_HFLIMIT))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb decay hflimit out of range");
- props->Reverb.DecayHFLimit = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param);
- }
-}
-void ALreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
-{ ALreverb_setParami(effect, context, param, vals[0]); }
-void ALreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{
- ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_REVERB_DENSITY:
- if(!(val >= AL_REVERB_MIN_DENSITY && val <= AL_REVERB_MAX_DENSITY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb density out of range");
- props->Reverb.Density = val;
- break;
-
- case AL_REVERB_DIFFUSION:
- if(!(val >= AL_REVERB_MIN_DIFFUSION && val <= AL_REVERB_MAX_DIFFUSION))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb diffusion out of range");
- props->Reverb.Diffusion = val;
- break;
-
- case AL_REVERB_GAIN:
- if(!(val >= AL_REVERB_MIN_GAIN && val <= AL_REVERB_MAX_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb gain out of range");
- props->Reverb.Gain = val;
- break;
-
- case AL_REVERB_GAINHF:
- if(!(val >= AL_REVERB_MIN_GAINHF && val <= AL_REVERB_MAX_GAINHF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb gainhf out of range");
- props->Reverb.GainHF = val;
- break;
-
- case AL_REVERB_DECAY_TIME:
- if(!(val >= AL_REVERB_MIN_DECAY_TIME && val <= AL_REVERB_MAX_DECAY_TIME))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb decay time out of range");
- props->Reverb.DecayTime = val;
- break;
-
- case AL_REVERB_DECAY_HFRATIO:
- if(!(val >= AL_REVERB_MIN_DECAY_HFRATIO && val <= AL_REVERB_MAX_DECAY_HFRATIO))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb decay hfratio out of range");
- props->Reverb.DecayHFRatio = val;
- break;
-
- case AL_REVERB_REFLECTIONS_GAIN:
- if(!(val >= AL_REVERB_MIN_REFLECTIONS_GAIN && val <= AL_REVERB_MAX_REFLECTIONS_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb reflections gain out of range");
- props->Reverb.ReflectionsGain = val;
- break;
-
- case AL_REVERB_REFLECTIONS_DELAY:
- if(!(val >= AL_REVERB_MIN_REFLECTIONS_DELAY && val <= AL_REVERB_MAX_REFLECTIONS_DELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb reflections delay out of range");
- props->Reverb.ReflectionsDelay = val;
- break;
-
- case AL_REVERB_LATE_REVERB_GAIN:
- if(!(val >= AL_REVERB_MIN_LATE_REVERB_GAIN && val <= AL_REVERB_MAX_LATE_REVERB_GAIN))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb late reverb gain out of range");
- props->Reverb.LateReverbGain = val;
- break;
-
- case AL_REVERB_LATE_REVERB_DELAY:
- if(!(val >= AL_REVERB_MIN_LATE_REVERB_DELAY && val <= AL_REVERB_MAX_LATE_REVERB_DELAY))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb late reverb delay out of range");
- props->Reverb.LateReverbDelay = val;
- break;
-
- case AL_REVERB_AIR_ABSORPTION_GAINHF:
- if(!(val >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb air absorption gainhf out of range");
- props->Reverb.AirAbsorptionGainHF = val;
- break;
-
- case AL_REVERB_ROOM_ROLLOFF_FACTOR:
- if(!(val >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR))
- SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb room rolloff factor out of range");
- props->Reverb.RoomRolloffFactor = val;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param);
- }
-}
-void ALreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALreverb_setParamf(effect, context, param, vals[0]); }
-
-void ALreverb_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_REVERB_DECAY_HFLIMIT:
- *val = props->Reverb.DecayHFLimit;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param);
- }
-}
-void ALreverb_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
-{ ALreverb_getParami(effect, context, param, vals); }
-void ALreverb_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{
- const ALeffectProps *props = &effect->Props;
- switch(param)
- {
- case AL_REVERB_DENSITY:
- *val = props->Reverb.Density;
- break;
-
- case AL_REVERB_DIFFUSION:
- *val = props->Reverb.Diffusion;
- break;
-
- case AL_REVERB_GAIN:
- *val = props->Reverb.Gain;
- break;
-
- case AL_REVERB_GAINHF:
- *val = props->Reverb.GainHF;
- break;
-
- case AL_REVERB_DECAY_TIME:
- *val = props->Reverb.DecayTime;
- break;
-
- case AL_REVERB_DECAY_HFRATIO:
- *val = props->Reverb.DecayHFRatio;
- break;
-
- case AL_REVERB_REFLECTIONS_GAIN:
- *val = props->Reverb.ReflectionsGain;
- break;
-
- case AL_REVERB_REFLECTIONS_DELAY:
- *val = props->Reverb.ReflectionsDelay;
- break;
-
- case AL_REVERB_LATE_REVERB_GAIN:
- *val = props->Reverb.LateReverbGain;
- break;
-
- case AL_REVERB_LATE_REVERB_DELAY:
- *val = props->Reverb.LateReverbDelay;
- break;
-
- case AL_REVERB_AIR_ABSORPTION_GAINHF:
- *val = props->Reverb.AirAbsorptionGainHF;
- break;
-
- case AL_REVERB_ROOM_ROLLOFF_FACTOR:
- *val = props->Reverb.RoomRolloffFactor;
- break;
-
- default:
- alSetError(context, AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param);
- }
-}
-void ALreverb_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALreverb_getParamf(effect, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(ALreverb);
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-28 17:30:58 +0000