From 357cf72ab33ef1807da8ea6ce4633fd8e2a89553 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Thu, 23 May 2013 21:33:16 -0700 Subject: Move remaining effects to the effects subdir --- Alc/effects/equalizer.c | 499 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 499 insertions(+) create mode 100644 Alc/effects/equalizer.c (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c new file mode 100644 index 00000000..d397a9ba --- /dev/null +++ b/Alc/effects/equalizer.c @@ -0,0 +1,499 @@ +/** + * OpenAL cross platform audio library + * Copyright (C) 2013 by Mike Gorchak + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * Or go to http://www.gnu.org/copyleft/lgpl.html + */ + +#include "config.h" + +#include +#include + +#include "alMain.h" +#include "alFilter.h" +#include "alAuxEffectSlot.h" +#include "alError.h" +#include "alu.h" + + +typedef struct ALequalizerStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALequalizerStateFactory; + +static ALequalizerStateFactory EqualizerFactory; + + +/* The document "Effects Extension Guide.pdf" says that low and high * + * frequencies are cutoff frequencies. This is not fully correct, they * + * are corner frequencies for low and high shelf filters. If they were * + * just cutoff frequencies, there would be no need in cutoff frequency * + * gains, which are present. Documentation for "Creative Proteus X2" * + * software describes 4-band equalizer functionality in a much better * + * way. This equalizer seems to be a predecessor of OpenAL 4-band * + * equalizer. With low and high shelf filters we are able to cutoff * + * frequencies below and/or above corner frequencies using attenuation * + * gains (below 1.0) and amplify all low and/or high frequencies using * + * gains above 1.0. * + * * + * Low-shelf Low Mid Band High Mid Band High-shelf * + * corner center center corner * + * frequency frequency frequency frequency * + * 50Hz..800Hz 200Hz..3000Hz 1000Hz..8000Hz 4000Hz..16000Hz * + * * + * | | | | * + * | | | | * + * B -----+ /--+--\ /--+--\ +----- * + * O |\ | | | | | | /| * + * O | \ - | - - | - / | * + * S + | \ | | | | | | / | * + * T | | | | | | | | | | * + * ---------+---------------+------------------+---------------+-------- * + * C | | | | | | | | | | * + * U - | / | | | | | | \ | * + * T | / - | - - | - \ | * + * O |/ | | | | | | \| * + * F -----+ \--+--/ \--+--/ +----- * + * F | | | | * + * | | | | * + * * + * Gains vary from 0.126 up to 7.943, which means from -18dB attenuation * + * up to +18dB amplification. Band width varies from 0.01 up to 1.0 in * + * octaves for two mid bands. * + * * + * Implementation is based on the "Cookbook formulae for audio EQ biquad * + * filter coefficients" by Robert Bristow-Johnson * + * http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt */ + +typedef enum ALEQFilterType { + LOW_SHELF, + HIGH_SHELF, + PEAKING +} ALEQFilterType; + +typedef struct ALEQFilter { + ALEQFilterType type; + ALfloat x[2]; /* History of two last input samples */ + ALfloat y[2]; /* History of two last output samples */ + ALfloat a[3]; /* Transfer function coefficients "a" */ + ALfloat b[3]; /* Transfer function coefficients "b" */ +} ALEQFilter; + +typedef struct ALequalizerState { + DERIVE_FROM_TYPE(ALeffectState); + + /* Effect gains for each channel */ + ALfloat Gain[MaxChannels]; + + /* Effect parameters */ + ALEQFilter bandfilter[4]; +} ALequalizerState; + +static ALvoid ALequalizerState_Destruct(ALequalizerState *state) +{ + (void)state; +} + +static ALboolean ALequalizerState_DeviceUpdate(ALequalizerState *state, ALCdevice *device) +{ + return AL_TRUE; + (void)state; + (void)device; +} + +static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot) +{ + ALfloat frequency = (ALfloat)device->Frequency; + ALfloat gain = sqrtf(1.0f / device->NumChan) * slot->Gain; + ALuint it; + + for(it = 0;it < MaxChannels;it++) + state->Gain[it] = 0.0f; + for(it = 0; it < device->NumChan; it++) + { + enum Channel chan = device->Speaker2Chan[it]; + state->Gain[chan] = gain; + } + + /* Calculate coefficients for the each type of filter */ + for(it = 0; it < 4; it++) + { + ALfloat gain; + ALfloat filter_frequency; + ALfloat bandwidth = 0.0f; + ALfloat w0; + ALfloat alpha = 0.0f; + + /* convert linear gains to filter gains */ + switch (it) + { + case 0: /* Low Shelf */ + gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.LowGain)) / 40.0f); + filter_frequency = slot->effect.Equalizer.LowCutoff; + break; + case 1: /* Peaking */ + gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.Mid1Gain)) / 40.0f); + filter_frequency = slot->effect.Equalizer.Mid1Center; + bandwidth = slot->effect.Equalizer.Mid1Width; + break; + case 2: /* Peaking */ + gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.Mid2Gain)) / 40.0f); + filter_frequency = slot->effect.Equalizer.Mid2Center; + bandwidth = slot->effect.Equalizer.Mid2Width; + break; + case 3: /* High Shelf */ + gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.HighGain)) / 40.0f); + filter_frequency = slot->effect.Equalizer.HighCutoff; + break; + } + + w0 = 2.0f*F_PI * filter_frequency / frequency; + + /* Calculate filter coefficients depending on filter type */ + switch(state->bandfilter[it].type) + { + case LOW_SHELF: + alpha = sinf(w0) / 2.0f * sqrtf((gain + 1.0f / gain) * + (1.0f / 0.75f - 1.0f) + 2.0f); + state->bandfilter[it].b[0] = gain * ((gain + 1.0f) - + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha); + state->bandfilter[it].b[1] = 2.0f * gain * ((gain - 1.0f) - + (gain + 1.0f) * cosf(w0)); + state->bandfilter[it].b[2] = gain * ((gain + 1.0f) - + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha); + state->bandfilter[it].a[0] = (gain + 1.0f) + + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha; + state->bandfilter[it].a[1] = -2.0f * ((gain - 1.0f) + + (gain + 1.0f) * cosf(w0)); + state->bandfilter[it].a[2] = (gain + 1.0f) + + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha; + break; + case HIGH_SHELF: + alpha = sinf(w0) / 2.0f * sqrtf((gain + 1.0f / gain) * + (1.0f / 0.75f - 1.0f) + 2.0f); + state->bandfilter[it].b[0] = gain * ((gain + 1.0f) + + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha); + state->bandfilter[it].b[1] = -2.0f * gain * ((gain - 1.0f) + + (gain + 1.0f) * + cosf(w0)); + state->bandfilter[it].b[2] = gain * ((gain + 1.0f) + + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha); + state->bandfilter[it].a[0] = (gain + 1.0f) - + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha; + state->bandfilter[it].a[1] = 2.0f * ((gain - 1.0f) - + (gain + 1.0f) * cosf(w0)); + state->bandfilter[it].a[2] = (gain + 1.0f) - + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha; + break; + case PEAKING: + alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0)); + state->bandfilter[it].b[0] = 1.0f + alpha * gain; + state->bandfilter[it].b[1] = -2.0f * cosf(w0); + state->bandfilter[it].b[2] = 1.0f - alpha * gain; + state->bandfilter[it].a[0] = 1.0f + alpha / gain; + state->bandfilter[it].a[1] = -2.0f * cosf(w0); + state->bandfilter[it].a[2] = 1.0f - alpha / gain; + break; + } + } +} + +static ALvoid ALequalizerState_Process(ALequalizerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +{ + ALuint base; + ALuint it; + ALuint kt; + ALuint ft; + + for(base = 0;base < SamplesToDo;) + { + ALfloat temps[64]; + ALuint td = minu(SamplesToDo-base, 64); + + for(it = 0;it < td;it++) + { + ALfloat smp = SamplesIn[base+it]; + ALfloat tempsmp; + + for(ft = 0;ft < 4;ft++) + { + ALEQFilter *filter = &state->bandfilter[ft]; + + tempsmp = filter->b[0] / filter->a[0] * smp + + filter->b[1] / filter->a[0] * filter->x[0] + + filter->b[2] / filter->a[0] * filter->x[1] - + filter->a[1] / filter->a[0] * filter->y[0] - + filter->a[2] / filter->a[0] * filter->y[1]; + + filter->x[1] = filter->x[0]; + filter->x[0] = smp; + filter->y[1] = filter->y[0]; + filter->y[0] = tempsmp; + smp = tempsmp; + } + + temps[it] = smp; + } + + for(kt = 0;kt < MaxChannels;kt++) + { + ALfloat gain = state->Gain[kt]; + if(!(gain > 0.00001f)) + continue; + + for(it = 0;it < td;it++) + SamplesOut[kt][base+it] += gain * temps[it]; + } + + base += td; + } +} + +static ALeffectStateFactory *ALequalizerState_getCreator(void) +{ + return STATIC_CAST(ALeffectStateFactory, &EqualizerFactory); +} + +DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState); + + +ALeffectState *ALequalizerStateFactory_create(void) +{ + ALequalizerState *state; + int it; + + state = malloc(sizeof(*state)); + if(!state) return NULL; + SET_VTABLE2(ALequalizerState, ALeffectState, state); + + state->bandfilter[0].type = LOW_SHELF; + state->bandfilter[1].type = PEAKING; + state->bandfilter[2].type = PEAKING; + state->bandfilter[3].type = HIGH_SHELF; + + /* Initialize sample history only on filter creation to avoid */ + /* sound clicks if filter settings were changed in runtime. */ + for(it = 0; it < 4; it++) + { + state->bandfilter[it].x[0] = 0.0f; + state->bandfilter[it].x[1] = 0.0f; + state->bandfilter[it].y[0] = 0.0f; + state->bandfilter[it].y[1] = 0.0f; + } + + return STATIC_CAST(ALeffectState, state); +} + +static ALvoid ALequalizerStateFactory_destroy(ALeffectState *effect) +{ + ALequalizerState *state = STATIC_UPCAST(ALequalizerState, ALeffectState, effect); + ALequalizerState_Destruct(state); + free(state); +} + +DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALequalizerStateFactory); + + +static void init_equalizer_factory(void) +{ + SET_VTABLE2(ALequalizerStateFactory, ALeffectStateFactory, &EqualizerFactory); +} + +ALeffectStateFactory *ALequalizerStateFactory_getFactory(void) +{ + static pthread_once_t once = PTHREAD_ONCE_INIT; + pthread_once(&once, init_equalizer_factory); + return STATIC_CAST(ALeffectStateFactory, &EqualizerFactory); +} + + +void equalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +{ + effect=effect; + val=val; + + switch(param) + { + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void equalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +{ + equalizer_SetParami(effect, context, param, vals[0]); +} +void equalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +{ + switch(param) + { + case AL_EQUALIZER_LOW_GAIN: + if(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN) + effect->Equalizer.LowGain = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_LOW_CUTOFF: + if(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF) + effect->Equalizer.LowCutoff = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_MID1_GAIN: + if(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN) + effect->Equalizer.Mid1Gain = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_MID1_CENTER: + if(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER) + effect->Equalizer.Mid1Center = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_MID1_WIDTH: + if(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH) + effect->Equalizer.Mid1Width = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_MID2_GAIN: + if(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN) + effect->Equalizer.Mid2Gain = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_MID2_CENTER: + if(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER) + effect->Equalizer.Mid2Center = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_MID2_WIDTH: + if(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH) + effect->Equalizer.Mid2Width = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_HIGH_GAIN: + if(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN) + effect->Equalizer.HighGain = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + case AL_EQUALIZER_HIGH_CUTOFF: + if(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF) + effect->Equalizer.HighCutoff = val; + else + alSetError(context, AL_INVALID_VALUE); + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void equalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +{ + equalizer_SetParamf(effect, context, param, vals[0]); +} + +void equalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +{ + effect=effect; + val=val; + + switch(param) + { + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void equalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +{ + equalizer_GetParami(effect, context, param, vals); +} +void equalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +{ + switch(param) + { + case AL_EQUALIZER_LOW_GAIN: + *val = effect->Equalizer.LowGain; + break; + + case AL_EQUALIZER_LOW_CUTOFF: + *val = effect->Equalizer.LowCutoff; + break; + + case AL_EQUALIZER_MID1_GAIN: + *val = effect->Equalizer.Mid1Gain; + break; + + case AL_EQUALIZER_MID1_CENTER: + *val = effect->Equalizer.Mid1Center; + break; + + case AL_EQUALIZER_MID1_WIDTH: + *val = effect->Equalizer.Mid1Width; + break; + + case AL_EQUALIZER_MID2_GAIN: + *val = effect->Equalizer.Mid2Gain; + break; + + case AL_EQUALIZER_MID2_CENTER: + *val = effect->Equalizer.Mid2Center; + break; + + case AL_EQUALIZER_MID2_WIDTH: + *val = effect->Equalizer.Mid2Width; + break; + + case AL_EQUALIZER_HIGH_GAIN: + *val = effect->Equalizer.HighGain; + break; + + case AL_EQUALIZER_HIGH_CUTOFF: + *val = effect->Equalizer.HighCutoff; + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void equalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +{ + equalizer_GetParamf(effect, context, param, vals); +} -- cgit v1.2.3 From e157238ce7467b6d3dbabb66f1308bb0bd87473e Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Fri, 24 May 2013 23:26:59 -0700 Subject: Use vtables for setting effect properties --- Alc/effects/chorus.c | 26 ++++---- Alc/effects/dedicated.c | 26 ++++---- Alc/effects/distortion.c | 26 ++++---- Alc/effects/echo.c | 26 ++++---- Alc/effects/equalizer.c | 26 ++++---- Alc/effects/flanger.c | 26 ++++---- Alc/effects/modulator.c | 28 ++++---- Alc/effects/null.c | 18 +++--- Alc/effects/reverb.c | 51 ++++++++------- OpenAL32/Include/alEffect.h | 154 +++++++++++++------------------------------- OpenAL32/alEffect.c | 90 +++----------------------- 11 files changed, 191 insertions(+), 306 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index e5a20b5d..c74bf0b5 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -290,7 +290,7 @@ ALeffectStateFactory *ALchorusStateFactory_getFactory(void) } -void chorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALchorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { switch(param) { @@ -313,11 +313,11 @@ void chorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint break; } } -void chorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALchorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - chorus_SetParami(effect, context, param, vals[0]); + ALchorus_SetParami(effect, context, param, vals[0]); } -void chorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALchorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -354,12 +354,12 @@ void chorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo break; } } -void chorus_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALchorus_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - chorus_SetParamf(effect, context, param, vals[0]); + ALchorus_SetParamf(effect, context, param, vals[0]); } -void chorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALchorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { switch(param) { @@ -376,11 +376,11 @@ void chorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint break; } } -void chorus_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALchorus_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - chorus_GetParami(effect, context, param, vals); + ALchorus_GetParami(effect, context, param, vals); } -void chorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALchorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -405,7 +405,9 @@ void chorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo break; } } -void chorus_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALchorus_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - chorus_GetParamf(effect, context, param, vals); + ALchorus_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALchorus); diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index bd266b0e..6b3ce1ae 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -131,13 +131,13 @@ ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void) } -void ded_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALdedicated_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void ded_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALdedicated_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ded_SetParami(effect, context, param, vals[0]); + ALdedicated_SetParami(effect, context, param, vals[0]); } -void ded_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALdedicated_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -153,18 +153,18 @@ void ded_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat break; } } -void ded_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALdedicated_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ded_SetParamf(effect, context, param, vals[0]); + ALdedicated_SetParamf(effect, context, param, vals[0]); } -void ded_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALdedicated_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void ded_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALdedicated_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ded_GetParami(effect, context, param, vals); + ALdedicated_GetParami(effect, context, param, vals); } -void ded_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALdedicated_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -177,7 +177,9 @@ void ded_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat break; } } -void ded_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALdedicated_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ded_GetParamf(effect, context, param, vals); + ALdedicated_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALdedicated); diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index 7828377c..e92fb9a8 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -286,7 +286,7 @@ ALeffectStateFactory *ALdistortionStateFactory_getFactory(void) } -void distortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALdistortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { effect=effect; val=val; @@ -298,11 +298,11 @@ void distortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, A break; } } -void distortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALdistortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - distortion_SetParami(effect, context, param, vals[0]); + ALdistortion_SetParami(effect, context, param, vals[0]); } -void distortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALdistortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -346,12 +346,12 @@ void distortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, A break; } } -void distortion_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALdistortion_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - distortion_SetParamf(effect, context, param, vals[0]); + ALdistortion_SetParamf(effect, context, param, vals[0]); } -void distortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALdistortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { effect=effect; val=val; @@ -363,11 +363,11 @@ void distortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, A break; } } -void distortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALdistortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - distortion_GetParami(effect, context, param, vals); + ALdistortion_GetParami(effect, context, param, vals); } -void distortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALdistortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -396,7 +396,9 @@ void distortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, A break; } } -void distortion_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALdistortion_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - distortion_GetParamf(effect, context, param, vals); + ALdistortion_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALdistortion); diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index d5915295..8f679c41 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -228,13 +228,13 @@ ALeffectStateFactory *ALechoStateFactory_getFactory(void) } -void echo_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALecho_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void echo_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALecho_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - echo_SetParami(effect, context, param, vals[0]); + ALecho_SetParami(effect, context, param, vals[0]); } -void echo_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALecho_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -278,18 +278,18 @@ void echo_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat break; } } -void echo_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALecho_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - echo_SetParamf(effect, context, param, vals[0]); + ALecho_SetParamf(effect, context, param, vals[0]); } -void echo_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALecho_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void echo_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALecho_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - echo_GetParami(effect, context, param, vals); + ALecho_GetParami(effect, context, param, vals); } -void echo_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALecho_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -318,7 +318,9 @@ void echo_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat break; } } -void echo_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALecho_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - echo_GetParamf(effect, context, param, vals); + ALecho_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALecho); diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index d397a9ba..adcd40f4 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -328,7 +328,7 @@ ALeffectStateFactory *ALequalizerStateFactory_getFactory(void) } -void equalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALequalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { effect=effect; val=val; @@ -340,11 +340,11 @@ void equalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void equalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALequalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - equalizer_SetParami(effect, context, param, vals[0]); + ALequalizer_SetParami(effect, context, param, vals[0]); } -void equalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALequalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -423,12 +423,12 @@ void equalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void equalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALequalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - equalizer_SetParamf(effect, context, param, vals[0]); + ALequalizer_SetParamf(effect, context, param, vals[0]); } -void equalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALequalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { effect=effect; val=val; @@ -440,11 +440,11 @@ void equalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void equalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALequalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - equalizer_GetParami(effect, context, param, vals); + ALequalizer_GetParami(effect, context, param, vals); } -void equalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALequalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -493,7 +493,9 @@ void equalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void equalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALequalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - equalizer_GetParamf(effect, context, param, vals); + ALequalizer_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALequalizer); diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index a0f94a46..de98a06d 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -290,7 +290,7 @@ ALeffectStateFactory *ALflangerStateFactory_getFactory(void) } -void flanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALflanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { switch(param) { @@ -313,11 +313,11 @@ void flanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALin break; } } -void flanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALflanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - flanger_SetParami(effect, context, param, vals[0]); + ALflanger_SetParami(effect, context, param, vals[0]); } -void flanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALflanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -354,12 +354,12 @@ void flanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfl break; } } -void flanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALflanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - flanger_SetParamf(effect, context, param, vals[0]); + ALflanger_SetParamf(effect, context, param, vals[0]); } -void flanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALflanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { switch(param) { @@ -376,11 +376,11 @@ void flanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALin break; } } -void flanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALflanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - flanger_GetParami(effect, context, param, vals); + ALflanger_GetParami(effect, context, param, vals); } -void flanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALflanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -405,7 +405,9 @@ void flanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfl break; } } -void flanger_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALflanger_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - flanger_GetParamf(effect, context, param, vals); + ALflanger_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALflanger); diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index ec99bd53..e48a6d94 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -245,7 +245,7 @@ ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void) } -void mod_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALmodulator_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -268,17 +268,17 @@ void mod_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat break; } } -void mod_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALmodulator_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - mod_SetParamf(effect, context, param, vals[0]); + ALmodulator_SetParamf(effect, context, param, vals[0]); } -void mod_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { switch(param) { case AL_RING_MODULATOR_FREQUENCY: case AL_RING_MODULATOR_HIGHPASS_CUTOFF: - mod_SetParamf(effect, context, param, (ALfloat)val); + ALmodulator_SetParamf(effect, context, param, (ALfloat)val); break; case AL_RING_MODULATOR_WAVEFORM: @@ -293,12 +293,12 @@ void mod_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint va break; } } -void mod_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALmodulator_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - mod_SetParami(effect, context, param, vals[0]); + ALmodulator_SetParami(effect, context, param, vals[0]); } -void mod_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALmodulator_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { switch(param) { @@ -317,11 +317,11 @@ void mod_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *v break; } } -void mod_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALmodulator_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - mod_GetParami(effect, context, param, vals); + ALmodulator_GetParami(effect, context, param, vals); } -void mod_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALmodulator_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -337,7 +337,9 @@ void mod_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat break; } } -void mod_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALmodulator_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - mod_GetParamf(effect, context, param, vals); + ALmodulator_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALmodulator); diff --git a/Alc/effects/null.c b/Alc/effects/null.c index 8636d573..cdca1adf 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -85,20 +85,22 @@ ALeffectStateFactory *ALnullStateFactory_getFactory(void) } -void null_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALnull_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void null_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALnull_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { (void)effect;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); } -void null_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALnull_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void null_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALnull_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { (void)effect;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); } -void null_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALnull_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void null_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALnull_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { (void)effect;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); } -void null_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALnull_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } -void null_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALnull_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { (void)effect;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); } + +DEFINE_ALEFFECT_VTABLE(ALnull); diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index a13a5693..eb47f27f 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1307,7 +1307,7 @@ ALeffectStateFactory *ALreverbStateFactory_getFactory(void) } -void eaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALeaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { switch(param) { @@ -1323,11 +1323,11 @@ void eaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void eaxreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALeaxreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - eaxreverb_SetParami(effect, context, param, vals[0]); + ALeaxreverb_SetParami(effect, context, param, vals[0]); } -void eaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALeaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -1476,7 +1476,7 @@ void eaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void eaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { switch(param) { @@ -1506,12 +1506,12 @@ void eaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, c break; default: - eaxreverb_SetParamf(effect, context, param, vals[0]); + ALeaxreverb_SetParamf(effect, context, param, vals[0]); break; } } -void eaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALeaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { switch(param) { @@ -1524,11 +1524,11 @@ void eaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void eaxreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALeaxreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - eaxreverb_GetParami(effect, context, param, vals); + ALeaxreverb_GetParami(effect, context, param, vals); } -void eaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -1617,7 +1617,7 @@ void eaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL break; } } -void eaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALeaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { switch(param) { @@ -1637,13 +1637,14 @@ void eaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, A break; default: - eaxreverb_GetParamf(effect, context, param, vals); + ALeaxreverb_GetParamf(effect, context, param, vals); break; } } +DEFINE_ALEFFECT_VTABLE(ALeaxreverb); -void reverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { switch(param) { @@ -1659,11 +1660,11 @@ void reverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint break; } } -void reverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - reverb_SetParami(effect, context, param, vals[0]); + ALreverb_SetParami(effect, context, param, vals[0]); } -void reverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { switch(param) { @@ -1756,12 +1757,12 @@ void reverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo break; } } -void reverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - reverb_SetParamf(effect, context, param, vals[0]); + ALreverb_SetParamf(effect, context, param, vals[0]); } -void reverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { switch(param) { @@ -1774,11 +1775,11 @@ void reverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint break; } } -void reverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - reverb_GetParami(effect, context, param, vals); + ALreverb_GetParami(effect, context, param, vals); } -void reverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { switch(param) { @@ -1835,7 +1836,9 @@ void reverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo break; } } -void reverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - reverb_GetParamf(effect, context, param, vals); + ALreverb_GetParamf(effect, context, param, vals); } + +DEFINE_ALEFFECT_VTABLE(ALreverb); diff --git a/OpenAL32/Include/alEffect.h b/OpenAL32/Include/alEffect.h index a3d40b82..cea785dc 100644 --- a/OpenAL32/Include/alEffect.h +++ b/OpenAL32/Include/alEffect.h @@ -7,6 +7,8 @@ extern "C" { #endif +typedef struct ALeffect ALeffect; + enum { EAXREVERB = 0, REVERB, @@ -25,7 +27,39 @@ extern ALboolean DisabledEffects[MAX_EFFECTS]; extern ALfloat ReverbBoost; extern ALboolean EmulateEAXReverb; -typedef struct ALeffect +struct ALeffectVtable { + void (*const SetParami)(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); + void (*const SetParamiv)(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); + void (*const SetParamf)(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); + void (*const SetParamfv)(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); + + void (*const GetParami)(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); + void (*const GetParamiv)(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); + void (*const GetParamf)(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); + void (*const GetParamfv)(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); +}; + +#define DEFINE_ALEFFECT_VTABLE(T) \ +const struct ALeffectVtable T##_vtable = { \ + T##_SetParami, T##_SetParamiv, \ + T##_SetParamf, T##_SetParamfv, \ + T##_GetParami, T##_GetParamiv, \ + T##_GetParamf, T##_GetParamfv, \ +} + +extern const struct ALeffectVtable ALeaxreverb_vtable; +extern const struct ALeffectVtable ALreverb_vtable; +extern const struct ALeffectVtable ALchorus_vtable; +extern const struct ALeffectVtable ALdistortion_vtable; +extern const struct ALeffectVtable ALecho_vtable; +extern const struct ALeffectVtable ALequalizer_vtable; +extern const struct ALeffectVtable ALflanger_vtable; +extern const struct ALeffectVtable ALmodulator_vtable; +extern const struct ALeffectVtable ALnull_vtable; +extern const struct ALeffectVtable ALdedicated_vtable; + + +struct ALeffect { // Effect type (AL_EFFECT_NULL, ...) ALenum type; @@ -119,123 +153,25 @@ typedef struct ALeffect ALfloat EQBandwidth; } Distortion; - void (*SetParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint val); - void (*SetParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); - void (*SetParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); - void (*SetParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); - - void (*GetParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); - void (*GetParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); - void (*GetParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); - void (*GetParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); + const struct ALeffectVtable *vtbl; /* Self ID */ ALuint id; -} ALeffect; +}; -#define ALeffect_SetParami(x, c, p, v) ((x)->SetParami((x),(c),(p),(v))) -#define ALeffect_SetParamiv(x, c, p, v) ((x)->SetParamiv((x),(c),(p),(v))) -#define ALeffect_SetParamf(x, c, p, v) ((x)->SetParamf((x),(c),(p),(v))) -#define ALeffect_SetParamfv(x, c, p, v) ((x)->SetParamfv((x),(c),(p),(v))) +#define ALeffect_SetParami(x, c, p, v) ((x)->vtbl->SetParami((x),(c),(p),(v))) +#define ALeffect_SetParamiv(x, c, p, v) ((x)->vtbl->SetParamiv((x),(c),(p),(v))) +#define ALeffect_SetParamf(x, c, p, v) ((x)->vtbl->SetParamf((x),(c),(p),(v))) +#define ALeffect_SetParamfv(x, c, p, v) ((x)->vtbl->SetParamfv((x),(c),(p),(v))) -#define ALeffect_GetParami(x, c, p, v) ((x)->GetParami((x),(c),(p),(v))) -#define ALeffect_GetParamiv(x, c, p, v) ((x)->GetParamiv((x),(c),(p),(v))) -#define ALeffect_GetParamf(x, c, p, v) ((x)->GetParamf((x),(c),(p),(v))) -#define ALeffect_GetParamfv(x, c, p, v) ((x)->GetParamfv((x),(c),(p),(v))) +#define ALeffect_GetParami(x, c, p, v) ((x)->vtbl->GetParami((x),(c),(p),(v))) +#define ALeffect_GetParamiv(x, c, p, v) ((x)->vtbl->GetParamiv((x),(c),(p),(v))) +#define ALeffect_GetParamf(x, c, p, v) ((x)->vtbl->GetParamf((x),(c),(p),(v))) +#define ALeffect_GetParamfv(x, c, p, v) ((x)->vtbl->GetParamfv((x),(c),(p),(v))) static __inline ALboolean IsReverbEffect(ALenum type) { return type == AL_EFFECT_REVERB || type == AL_EFFECT_EAXREVERB; } -void eaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void eaxreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void eaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void eaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void eaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void eaxreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void eaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void eaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void reverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void reverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void reverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void reverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void reverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void reverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void reverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void reverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void chorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void chorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void chorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void chorus_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void chorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void chorus_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void chorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void chorus_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void distortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void distortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void distortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void distortion_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void distortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void distortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void distortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void distortion_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void echo_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void echo_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void echo_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void echo_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void echo_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void echo_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void echo_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void echo_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void equalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void equalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void equalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void equalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void equalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void equalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void equalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void equalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void flanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void flanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void flanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void flanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void flanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void flanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void flanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void flanger_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void mod_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void mod_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void mod_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void mod_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void mod_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void mod_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void mod_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void mod_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void ded_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void ded_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void ded_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void ded_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void ded_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void ded_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void ded_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void ded_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - -void null_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val); -void null_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); -void null_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); -void null_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); -void null_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); -void null_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); -void null_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); -void null_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); - ALenum InitEffect(ALeffect *effect); ALvoid ReleaseALEffects(ALCdevice *device); diff --git a/OpenAL32/alEffect.c b/OpenAL32/alEffect.c index 23176beb..dded17b1 100644 --- a/OpenAL32/alEffect.c +++ b/OpenAL32/alEffect.c @@ -395,14 +395,7 @@ static void InitEffectParams(ALeffect *effect, ALenum type) effect->Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE; effect->Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR; effect->Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT; - effect->SetParami = eaxreverb_SetParami; - effect->SetParamiv = eaxreverb_SetParamiv; - effect->SetParamf = eaxreverb_SetParamf; - effect->SetParamfv = eaxreverb_SetParamfv; - effect->GetParami = eaxreverb_GetParami; - effect->GetParamiv = eaxreverb_GetParamiv; - effect->GetParamf = eaxreverb_GetParamf; - effect->GetParamfv = eaxreverb_GetParamfv; + effect->vtbl = &ALeaxreverb_vtable; break; case AL_EFFECT_REVERB: effect->Reverb.Density = AL_REVERB_DEFAULT_DENSITY; @@ -418,14 +411,7 @@ static void InitEffectParams(ALeffect *effect, ALenum type) effect->Reverb.AirAbsorptionGainHF = AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF; effect->Reverb.RoomRolloffFactor = AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR; effect->Reverb.DecayHFLimit = AL_REVERB_DEFAULT_DECAY_HFLIMIT; - effect->SetParami = reverb_SetParami; - effect->SetParamiv = reverb_SetParamiv; - effect->SetParamf = reverb_SetParamf; - effect->SetParamfv = reverb_SetParamfv; - effect->GetParami = reverb_GetParami; - effect->GetParamiv = reverb_GetParamiv; - effect->GetParamf = reverb_GetParamf; - effect->GetParamfv = reverb_GetParamfv; + effect->vtbl = &ALreverb_vtable; break; case AL_EFFECT_CHORUS: effect->Chorus.Waveform = AL_CHORUS_DEFAULT_WAVEFORM; @@ -434,14 +420,7 @@ static void InitEffectParams(ALeffect *effect, ALenum type) effect->Chorus.Depth = AL_CHORUS_DEFAULT_DEPTH; effect->Chorus.Feedback = AL_CHORUS_DEFAULT_FEEDBACK; effect->Chorus.Delay = AL_CHORUS_DEFAULT_DELAY; - effect->SetParami = chorus_SetParami; - effect->SetParamiv = chorus_SetParamiv; - effect->SetParamf = chorus_SetParamf; - effect->SetParamfv = chorus_SetParamfv; - effect->GetParami = chorus_GetParami; - effect->GetParamiv = chorus_GetParamiv; - effect->GetParamf = chorus_GetParamf; - effect->GetParamfv = chorus_GetParamfv; + effect->vtbl = &ALchorus_vtable; break; case AL_EFFECT_DISTORTION: effect->Distortion.Edge = AL_DISTORTION_DEFAULT_EDGE; @@ -449,14 +428,7 @@ static void InitEffectParams(ALeffect *effect, ALenum type) effect->Distortion.LowpassCutoff = AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF; effect->Distortion.EQCenter = AL_DISTORTION_DEFAULT_EQCENTER; effect->Distortion.EQBandwidth = AL_DISTORTION_DEFAULT_EQBANDWIDTH; - effect->SetParami = distortion_SetParami; - effect->SetParamiv = distortion_SetParamiv; - effect->SetParamf = distortion_SetParamf; - effect->SetParamfv = distortion_SetParamfv; - effect->GetParami = distortion_GetParami; - effect->GetParamiv = distortion_GetParamiv; - effect->GetParamf = distortion_GetParamf; - effect->GetParamfv = distortion_GetParamfv; + effect->vtbl = &ALdistortion_vtable; break; case AL_EFFECT_ECHO: effect->Echo.Delay = AL_ECHO_DEFAULT_DELAY; @@ -464,14 +436,7 @@ static void InitEffectParams(ALeffect *effect, ALenum type) effect->Echo.Damping = AL_ECHO_DEFAULT_DAMPING; effect->Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK; effect->Echo.Spread = AL_ECHO_DEFAULT_SPREAD; - effect->SetParami = echo_SetParami; - effect->SetParamiv = echo_SetParamiv; - effect->SetParamf = echo_SetParamf; - effect->SetParamfv = echo_SetParamfv; - effect->GetParami = echo_GetParami; - effect->GetParamiv = echo_GetParamiv; - effect->GetParamf = echo_GetParamf; - effect->GetParamfv = echo_GetParamfv; + effect->vtbl = &ALecho_vtable; break; case AL_EFFECT_EQUALIZER: effect->Equalizer.LowCutoff = AL_EQUALIZER_DEFAULT_LOW_CUTOFF; @@ -484,14 +449,7 @@ static void InitEffectParams(ALeffect *effect, ALenum type) effect->Equalizer.Mid2Width = AL_EQUALIZER_DEFAULT_MID2_WIDTH; effect->Equalizer.HighCutoff = AL_EQUALIZER_DEFAULT_HIGH_CUTOFF; effect->Equalizer.HighGain = AL_EQUALIZER_DEFAULT_HIGH_GAIN; - effect->SetParami = equalizer_SetParami; - effect->SetParamiv = equalizer_SetParamiv; - effect->SetParamf = equalizer_SetParamf; - effect->SetParamfv = equalizer_SetParamfv; - effect->GetParami = equalizer_GetParami; - effect->GetParamiv = equalizer_GetParamiv; - effect->GetParamf = equalizer_GetParamf; - effect->GetParamfv = equalizer_GetParamfv; + effect->vtbl = &ALequalizer_vtable; break; case AL_EFFECT_FLANGER: effect->Flanger.Waveform = AL_FLANGER_DEFAULT_WAVEFORM; @@ -500,49 +458,21 @@ static void InitEffectParams(ALeffect *effect, ALenum type) effect->Flanger.Depth = AL_FLANGER_DEFAULT_DEPTH; effect->Flanger.Feedback = AL_FLANGER_DEFAULT_FEEDBACK; effect->Flanger.Delay = AL_FLANGER_DEFAULT_DELAY; - effect->SetParami = flanger_SetParami; - effect->SetParamiv = flanger_SetParamiv; - effect->SetParamf = flanger_SetParamf; - effect->SetParamfv = flanger_SetParamfv; - effect->GetParami = flanger_GetParami; - effect->GetParamiv = flanger_GetParamiv; - effect->GetParamf = flanger_GetParamf; - effect->GetParamfv = flanger_GetParamfv; + effect->vtbl = &ALflanger_vtable; break; case AL_EFFECT_RING_MODULATOR: effect->Modulator.Frequency = AL_RING_MODULATOR_DEFAULT_FREQUENCY; effect->Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF; effect->Modulator.Waveform = AL_RING_MODULATOR_DEFAULT_WAVEFORM; - effect->SetParami = mod_SetParami; - effect->SetParamiv = mod_SetParamiv; - effect->SetParamf = mod_SetParamf; - effect->SetParamfv = mod_SetParamfv; - effect->GetParami = mod_GetParami; - effect->GetParamiv = mod_GetParamiv; - effect->GetParamf = mod_GetParamf; - effect->GetParamfv = mod_GetParamfv; + effect->vtbl = &ALmodulator_vtable; break; case AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT: case AL_EFFECT_DEDICATED_DIALOGUE: effect->Dedicated.Gain = 1.0f; - effect->SetParami = ded_SetParami; - effect->SetParamiv = ded_SetParamiv; - effect->SetParamf = ded_SetParamf; - effect->SetParamfv = ded_SetParamfv; - effect->GetParami = ded_GetParami; - effect->GetParamiv = ded_GetParamiv; - effect->GetParamf = ded_GetParamf; - effect->GetParamfv = ded_GetParamfv; + effect->vtbl = &ALdedicated_vtable; break; default: - effect->SetParami = null_SetParami; - effect->SetParamiv = null_SetParamiv; - effect->SetParamf = null_SetParamf; - effect->SetParamfv = null_SetParamfv; - effect->GetParami = null_GetParami; - effect->GetParamiv = null_GetParamiv; - effect->GetParamf = null_GetParamf; - effect->GetParamfv = null_GetParamfv; + effect->vtbl = &ALnull_vtable; break; } effect->type = type; -- cgit v1.2.3 From 6571d805400f018b51835a8e37752409af9b1c4d Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Sat, 25 May 2013 21:04:00 -0700 Subject: Use a Delete method for deletable objects --- Alc/effects/chorus.c | 11 ++--------- Alc/effects/dedicated.c | 11 ++--------- Alc/effects/distortion.c | 11 ++--------- Alc/effects/echo.c | 11 ++--------- Alc/effects/equalizer.c | 11 ++--------- Alc/effects/flanger.c | 11 ++--------- Alc/effects/modulator.c | 11 ++--------- Alc/effects/null.c | 16 +++------------- Alc/effects/reverb.c | 11 ++--------- OpenAL32/Include/alAuxEffectSlot.h | 15 +++++---------- OpenAL32/Include/alMain.h | 5 ++++- 11 files changed, 28 insertions(+), 96 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index c74bf0b5..22241af5 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -243,9 +243,9 @@ static ALvoid ALchorusState_Process(ALchorusState *state, ALuint SamplesToDo, co ProcessSinusoid(state, SamplesToDo, SamplesIn, SamplesOut); } -static ALeffectStateFactory *ALchorusState_getCreator(void) +static void ALchorusState_Delete(ALchorusState *state) { - return STATIC_CAST(ALeffectStateFactory, &ChorusFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState); @@ -267,13 +267,6 @@ static ALeffectState *ALchorusStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALchorusStateFactory_destroy(ALeffectState *effect) -{ - ALchorusState *state = STATIC_UPCAST(ALchorusState, ALeffectState, effect); - ALchorusState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALchorusStateFactory); diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 6b3ce1ae..184fe292 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -85,9 +85,9 @@ static ALvoid ALdedicatedState_Process(ALdedicatedState *state, ALuint SamplesTo } } -static ALeffectStateFactory *ALdedicatedState_getCreator(void) +static void ALdedicatedState_Delete(ALdedicatedState *state) { - return STATIC_CAST(ALeffectStateFactory, &DedicatedFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState); @@ -108,13 +108,6 @@ ALeffectState *ALdedicatedStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALdedicatedStateFactory_destroy(ALeffectState *effect) -{ - ALdedicatedState *state = STATIC_UPCAST(ALdedicatedState, ALeffectState, effect); - ALdedicatedState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdedicatedStateFactory); diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index e92fb9a8..cc6669af 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -234,9 +234,9 @@ static ALvoid ALdistortionState_Process(ALdistortionState *state, ALuint Samples } } -static ALeffectStateFactory *ALdistortionState_getCreator(void) +static void ALdistortionState_Delete(ALdistortionState *state) { - return STATIC_CAST(ALeffectStateFactory, &DistortionFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState); @@ -263,13 +263,6 @@ static ALeffectState *ALdistortionStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALdistortionStateFactory_destroy(ALeffectState *effect) -{ - ALdistortionState *state = STATIC_UPCAST(ALdistortionState, ALeffectState, effect); - ALdistortionState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdistortionStateFactory); diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 8f679c41..533461ac 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -175,9 +175,9 @@ static ALvoid ALechoState_Process(ALechoState *state, ALuint SamplesToDo, const state->Offset = offset; } -static ALeffectStateFactory *ALechoState_getCreator(void) +static void ALechoState_Delete(ALechoState *state) { - return STATIC_CAST(ALeffectStateFactory, &EchoFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALechoState); @@ -205,13 +205,6 @@ ALeffectState *ALechoStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALechoStateFactory_destroy(ALeffectState *effect) -{ - ALechoState *state = STATIC_UPCAST(ALechoState, ALeffectState, effect); - ALechoState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALechoStateFactory); diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index adcd40f4..3d5f35d5 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -270,9 +270,9 @@ static ALvoid ALequalizerState_Process(ALequalizerState *state, ALuint SamplesTo } } -static ALeffectStateFactory *ALequalizerState_getCreator(void) +static void ALequalizerState_Delete(ALequalizerState *state) { - return STATIC_CAST(ALeffectStateFactory, &EqualizerFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState); @@ -305,13 +305,6 @@ ALeffectState *ALequalizerStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALequalizerStateFactory_destroy(ALeffectState *effect) -{ - ALequalizerState *state = STATIC_UPCAST(ALequalizerState, ALeffectState, effect); - ALequalizerState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALequalizerStateFactory); diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index de98a06d..12e16de2 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -243,9 +243,9 @@ static ALvoid ALflangerState_Process(ALflangerState *state, ALuint SamplesToDo, ProcessSinusoid(state, SamplesToDo, SamplesIn, SamplesOut); } -static ALeffectStateFactory *ALflangerState_getCreator(void) +static void ALflangerState_Delete(ALflangerState *state) { - return STATIC_CAST(ALeffectStateFactory, &FlangerFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALflangerState); @@ -267,13 +267,6 @@ ALeffectState *ALflangerStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALflangerStateFactory_destroy(ALeffectState *effect) -{ - ALflangerState *state = STATIC_UPCAST(ALflangerState, ALeffectState, effect); - ALflangerState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALflangerStateFactory); diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index e48a6d94..3f9ff8a5 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -197,9 +197,9 @@ static ALvoid ALmodulatorState_Process(ALmodulatorState *state, ALuint SamplesTo } } -static ALeffectStateFactory *ALmodulatorState_getCreator(void) +static void ALmodulatorState_Delete(ALmodulatorState *state) { - return STATIC_CAST(ALeffectStateFactory, &ModulatorFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState); @@ -222,13 +222,6 @@ static ALeffectState *ALmodulatorStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALmodulatorStateFactory_destroy(ALeffectState *effect) -{ - ALmodulatorState *state = STATIC_UPCAST(ALmodulatorState, ALeffectState, effect); - ALmodulatorState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALmodulatorStateFactory); diff --git a/Alc/effects/null.c b/Alc/effects/null.c index 76d650da..3d617b64 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -60,12 +60,10 @@ static ALvoid ALnullState_Process(ALnullState *state, ALuint samplesToDo, const (void)samplesOut; } -/* This returns the ALeffectStateFactory that creates these ALeffectState - * object types. - */ -static ALeffectStateFactory *ALnullState_getCreator(void) +/* This frees the memory used by the object, after it has been destructed. */ +static void ALnullState_Delete(ALnullState *state) { - return STATIC_CAST(ALeffectStateFactory, &NullFactory); + free(state); } /* Define the forwards and the ALeffectState vtable for this type. */ @@ -85,14 +83,6 @@ ALeffectState *ALnullStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -/* Destroys (destructs and frees) the ALeffectState. */ -static ALvoid ALnullStateFactory_destroy(ALeffectState *effect) -{ - ALnullState *state = STATIC_UPCAST(ALnullState, ALeffectState, effect); - ALnullState_Destruct(state); - free(state); -} - /* Define the ALeffectStateFactory vtable for this type. */ DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALnullStateFactory); diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index b634dd1c..2421225d 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1174,9 +1174,9 @@ static ALvoid ALreverbState_Destruct(ALreverbState *State) State->SampleBuffer = NULL; } -static ALeffectStateFactory *ALreverbState_getCreator(void) +static void ALreverbState_Delete(ALreverbState *state) { - return STATIC_CAST(ALeffectStateFactory, &ReverbFactory); + free(state); } DEFINE_ALEFFECTSTATE_VTABLE(ALreverbState); @@ -1274,13 +1274,6 @@ static ALeffectState *ALreverbStateFactory_create(void) return STATIC_CAST(ALeffectState, state); } -static ALvoid ALreverbStateFactory_destroy(ALeffectState *effect) -{ - ALreverbState *state = STATIC_UPCAST(ALreverbState, ALeffectState, effect); - ALreverbState_Destruct(state); - free(state); -} - DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALreverbStateFactory); diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h index ff88fe7b..d7062ff7 100644 --- a/OpenAL32/Include/alAuxEffectSlot.h +++ b/OpenAL32/Include/alAuxEffectSlot.h @@ -18,7 +18,8 @@ struct ALeffectStateVtable { ALboolean (*const DeviceUpdate)(ALeffectState *state, ALCdevice *device); ALvoid (*const Update)(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot); ALvoid (*const Process)(ALeffectState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]); - ALeffectStateFactory *(*const getCreator)(void); + + void (*const Delete)(ALeffectState *state); }; struct ALeffectState { @@ -29,7 +30,6 @@ struct ALeffectState { #define ALeffectState_DeviceUpdate(a,b) ((a)->vtbl->DeviceUpdate((a),(b))) #define ALeffectState_Update(a,b,c) ((a)->vtbl->Update((a),(b),(c))) #define ALeffectState_Process(a,b,c,d) ((a)->vtbl->Process((a),(b),(c),(d))) -#define ALeffectState_getCreator(a) ((a)->vtbl->getCreator()) #define DEFINE_ALEFFECTSTATE_VTABLE(T) \ static ALvoid T##_ALeffectState_Destruct(ALeffectState *state) \ @@ -40,21 +40,20 @@ static ALvoid T##_ALeffectState_Update(ALeffectState *state, ALCdevice *device, { T##_Update(STATIC_UPCAST(T, ALeffectState, state), device, slot); } \ static ALvoid T##_ALeffectState_Process(ALeffectState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]) \ { T##_Process(STATIC_UPCAST(T, ALeffectState, state), samplesToDo, samplesIn, samplesOut); } \ -static ALeffectStateFactory* T##_ALeffectState_getCreator(void) \ -{ return T##_getCreator(); } \ +static ALvoid T##_ALeffectState_Delete(ALeffectState *state) \ +{ T##_Delete(STATIC_UPCAST(T, ALeffectState, state)); } \ \ static const struct ALeffectStateVtable T##_ALeffectState_vtable = { \ T##_ALeffectState_Destruct, \ T##_ALeffectState_DeviceUpdate, \ T##_ALeffectState_Update, \ T##_ALeffectState_Process, \ - T##_ALeffectState_getCreator, \ + T##_ALeffectState_Delete, \ } struct ALeffectStateFactoryVtable { ALeffectState *(*const create)(void); - ALvoid (*const destroy)(ALeffectState *state); }; struct ALeffectStateFactory { @@ -62,17 +61,13 @@ struct ALeffectStateFactory { }; #define ALeffectStateFactory_create(p) ((p)->vtbl->create()) -#define ALeffectStateFactory_destroy(p,a) ((p)->vtbl->destroy((a))) #define DEFINE_ALEFFECTSTATEFACTORY_VTABLE(T) \ static ALeffectState* T##_ALeffectStateFactory_create(void) \ { return T##_create(); } \ -static ALvoid T##_ALeffectStateFactory_destroy(ALeffectState *state) \ -{ T##_destroy(state); } \ \ static const struct ALeffectStateFactoryVtable T##_ALeffectStateFactory_vtable = { \ T##_ALeffectStateFactory_create, \ - T##_ALeffectStateFactory_destroy \ } diff --git a/OpenAL32/Include/alMain.h b/OpenAL32/Include/alMain.h index ca0df2ad..a7c79b2a 100644 --- a/OpenAL32/Include/alMain.h +++ b/OpenAL32/Include/alMain.h @@ -70,7 +70,10 @@ static const union { #define SET_VTABLE1(T1, obj) ((obj)->vtbl = &(T1##_vtable)) #define SET_VTABLE2(T1, T2, obj) SET_VTABLE1(T1##_##T2, STATIC_CAST(T2, (obj))) -#define DELETE_OBJ(obj) ((obj)->vtbl->getCreator()->vtbl->destroy((obj))) +#define DELETE_OBJ(obj) do { \ + (obj)->vtbl->Destruct((obj)); \ + (obj)->vtbl->Delete((obj)); \ +} while(0) #ifdef _WIN32 -- cgit v1.2.3 From d1c5599c8ead4905d46e5d86f3f0547d3a925d44 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Sat, 25 May 2013 22:07:31 -0700 Subject: Use an ALeffectProps union to store the effect properties --- Alc/ALu.c | 12 +- Alc/effects/chorus.c | 40 ++++--- Alc/effects/dedicated.c | 12 +- Alc/effects/distortion.c | 44 ++++---- Alc/effects/echo.c | 32 +++--- Alc/effects/equalizer.c | 74 +++++++------ Alc/effects/flanger.c | 40 ++++--- Alc/effects/modulator.c | 30 ++--- Alc/effects/reverb.c | 222 +++++++++++++++++++------------------ OpenAL32/Include/alAuxEffectSlot.h | 3 +- OpenAL32/Include/alEffect.h | 14 ++- OpenAL32/alAuxEffectSlot.c | 32 +++--- OpenAL32/alEffect.c | 206 +++++++++++++++++----------------- 13 files changed, 400 insertions(+), 361 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/ALu.c b/Alc/ALu.c index 3c1e4ad5..2f005b77 100644 --- a/Alc/ALu.c +++ b/Alc/ALu.c @@ -447,7 +447,7 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext) if(!Slot && i == 0) Slot = Device->DefaultSlot; - if(Slot && Slot->effect.type == AL_EFFECT_NULL) + if(Slot && Slot->EffectType == AL_EFFECT_NULL) Slot = NULL; ALSource->Params.Send[i].Slot = Slot; ALSource->Params.Send[i].Gain = WetGain[i]; @@ -551,7 +551,7 @@ ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext) if(!Slot && i == 0) Slot = Device->DefaultSlot; - if(!Slot || Slot->effect.type == AL_EFFECT_NULL) + if(!Slot || Slot->EffectType == AL_EFFECT_NULL) { Slot = NULL; RoomRolloff[i] = 0.0f; @@ -561,12 +561,12 @@ ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext) else if(Slot->AuxSendAuto) { RoomRolloff[i] = RoomRolloffBase; - if(IsReverbEffect(Slot->effect.type)) + if(IsReverbEffect(Slot->EffectType)) { - RoomRolloff[i] += Slot->effect.Reverb.RoomRolloffFactor; - DecayDistance[i] = Slot->effect.Reverb.DecayTime * + RoomRolloff[i] += Slot->EffectProps.Reverb.RoomRolloffFactor; + DecayDistance[i] = Slot->EffectProps.Reverb.DecayTime * SPEEDOFSOUNDMETRESPERSEC; - RoomAirAbsorption[i] = Slot->effect.Reverb.AirAbsorptionGainHF; + RoomAirAbsorption[i] = Slot->EffectProps.Reverb.AirAbsorptionGainHF; } else { diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index 22241af5..4dc6cd98 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -111,17 +111,17 @@ static ALvoid ALchorusState_Update(ALchorusState *state, ALCdevice *Device, cons state->Gain[1][it] = 0.0f; } - state->waveform = Slot->effect.Chorus.Waveform; - state->depth = Slot->effect.Chorus.Depth; - state->feedback = Slot->effect.Chorus.Feedback; - state->delay = fastf2i(Slot->effect.Chorus.Delay * frequency); + state->waveform = Slot->EffectProps.Chorus.Waveform; + state->depth = Slot->EffectProps.Chorus.Depth; + state->feedback = Slot->EffectProps.Chorus.Feedback; + state->delay = fastf2i(Slot->EffectProps.Chorus.Delay * frequency); /* Gains for left and right sides */ ComputeAngleGains(Device, atan2f(-1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[0]); ComputeAngleGains(Device, atan2f(+1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[1]); - phase = Slot->effect.Chorus.Phase; - rate = Slot->effect.Chorus.Rate; + phase = Slot->EffectProps.Chorus.Phase; + rate = Slot->EffectProps.Chorus.Rate; /* Calculate LFO coefficient */ switch (state->waveform) @@ -285,18 +285,19 @@ ALeffectStateFactory *ALchorusStateFactory_getFactory(void) 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) - effect->Chorus.Waveform = val; + props->Chorus.Waveform = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_CHORUS_PHASE: if(val >= AL_CHORUS_MIN_PHASE && val <= AL_CHORUS_MAX_PHASE) - effect->Chorus.Phase = val; + props->Chorus.Phase = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -312,32 +313,33 @@ void ALchorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, co } 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) - effect->Chorus.Rate = val; + props->Chorus.Rate = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_CHORUS_DEPTH: if(val >= AL_CHORUS_MIN_DEPTH && val <= AL_CHORUS_MAX_DEPTH) - effect->Chorus.Depth = val; + props->Chorus.Depth = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_CHORUS_FEEDBACK: if(val >= AL_CHORUS_MIN_FEEDBACK && val <= AL_CHORUS_MAX_FEEDBACK) - effect->Chorus.Feedback = val; + props->Chorus.Feedback = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_CHORUS_DELAY: if(val >= AL_CHORUS_MIN_DELAY && val <= AL_CHORUS_MAX_DELAY) - effect->Chorus.Delay = val; + props->Chorus.Delay = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -354,14 +356,15 @@ void ALchorus_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, co void ALchorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_CHORUS_WAVEFORM: - *val = effect->Chorus.Waveform; + *val = props->Chorus.Waveform; break; case AL_CHORUS_PHASE: - *val = effect->Chorus.Phase; + *val = props->Chorus.Phase; break; default: @@ -375,22 +378,23 @@ void ALchorus_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, AL } void ALchorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_CHORUS_RATE: - *val = effect->Chorus.Rate; + *val = props->Chorus.Rate; break; case AL_CHORUS_DEPTH: - *val = effect->Chorus.Depth; + *val = props->Chorus.Depth; break; case AL_CHORUS_FEEDBACK: - *val = effect->Chorus.Feedback; + *val = props->Chorus.Feedback; break; case AL_CHORUS_DELAY: - *val = effect->Chorus.Delay; + *val = props->Chorus.Delay; break; default: diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 184fe292..35d26cc0 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -60,13 +60,13 @@ static ALvoid ALdedicatedState_Update(ALdedicatedState *state, ALCdevice *device ALfloat Gain; ALsizei s; - Gain = Slot->Gain * Slot->effect.Dedicated.Gain; + Gain = Slot->Gain * Slot->EffectProps.Dedicated.Gain; for(s = 0;s < MaxChannels;s++) state->gains[s] = 0.0f; - if(Slot->effect.type == AL_EFFECT_DEDICATED_DIALOGUE) + if(Slot->EffectType == AL_EFFECT_DEDICATED_DIALOGUE) ComputeAngleGains(device, atan2f(0.0f, 1.0f), 0.0f, Gain, state->gains); - else if(Slot->effect.type == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT) + else if(Slot->EffectType == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT) state->gains[LFE] = Gain; } @@ -132,11 +132,12 @@ void ALdedicated_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum 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)) - effect->Dedicated.Gain = val; + props->Dedicated.Gain = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -159,10 +160,11 @@ void ALdedicated_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, } void ALdedicated_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_DEDICATED_GAIN: - *val = effect->Dedicated.Gain; + *val = props->Dedicated.Gain; break; default: diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index cc6669af..5be2215e 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -99,14 +99,14 @@ static ALvoid ALdistortionState_Update(ALdistortionState *state, ALCdevice *Devi } /* Store distorted signal attenuation settings */ - state->attenuation = Slot->effect.Distortion.Gain; + state->attenuation = Slot->EffectProps.Distortion.Gain; /* Store waveshaper edge settings */ - edge = sinf(Slot->effect.Distortion.Edge * (F_PI/2.0f)); + edge = sinf(Slot->EffectProps.Distortion.Edge * (F_PI/2.0f)); state->edge_coeff = 2.0f * edge / (1.0f-edge); /* Lowpass filter */ - cutoff = Slot->effect.Distortion.LowpassCutoff; + cutoff = Slot->EffectProps.Distortion.LowpassCutoff; /* Bandwidth value is constant in octaves */ bandwidth = (cutoff / 2.0f) / (cutoff * 0.67f); w0 = 2.0f*F_PI * cutoff / (frequency*4.0f); @@ -119,9 +119,9 @@ static ALvoid ALdistortionState_Update(ALdistortionState *state, ALCdevice *Devi state->lowpass.a[2] = 1.0f - alpha; /* Bandpass filter */ - cutoff = Slot->effect.Distortion.EQCenter; + cutoff = Slot->EffectProps.Distortion.EQCenter; /* Convert bandwidth in Hz to octaves */ - bandwidth = Slot->effect.Distortion.EQBandwidth / (cutoff * 0.67f); + bandwidth = Slot->EffectProps.Distortion.EQBandwidth / (cutoff * 0.67f); w0 = 2.0f*F_PI * cutoff / (frequency*4.0f); alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0)); state->bandpass.b[0] = alpha; @@ -281,15 +281,15 @@ ALeffectStateFactory *ALdistortionStateFactory_getFactory(void) void ALdistortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { - effect=effect; - val=val; - + const ALeffectProps *props = &effect->Props; switch(param) { default: alSetError(context, AL_INVALID_ENUM); break; } + (void)props; + (void)val; } void ALdistortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { @@ -297,39 +297,40 @@ void ALdistortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum 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) - effect->Distortion.Edge = val; + props->Distortion.Edge = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_DISTORTION_GAIN: if(val >= AL_DISTORTION_MIN_GAIN && val <= AL_DISTORTION_MAX_GAIN) - effect->Distortion.Gain = val; + props->Distortion.Gain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_DISTORTION_LOWPASS_CUTOFF: if(val >= AL_DISTORTION_MIN_LOWPASS_CUTOFF && val <= AL_DISTORTION_MAX_LOWPASS_CUTOFF) - effect->Distortion.LowpassCutoff = val; + props->Distortion.LowpassCutoff = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_DISTORTION_EQCENTER: if(val >= AL_DISTORTION_MIN_EQCENTER && val <= AL_DISTORTION_MAX_EQCENTER) - effect->Distortion.EQCenter = val; + props->Distortion.EQCenter = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_DISTORTION_EQBANDWIDTH: if(val >= AL_DISTORTION_MIN_EQBANDWIDTH && val <= AL_DISTORTION_MAX_EQBANDWIDTH) - effect->Distortion.EQBandwidth = val; + props->Distortion.EQBandwidth = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -346,15 +347,15 @@ void ALdistortion_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param void ALdistortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { - effect=effect; - val=val; - + const ALeffectProps *props = &effect->Props; switch(param) { default: alSetError(context, AL_INVALID_ENUM); break; } + (void)props; + (void)val; } void ALdistortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { @@ -362,26 +363,27 @@ void ALdistortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param } void ALdistortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_DISTORTION_EDGE: - *val = effect->Distortion.Edge; + *val = props->Distortion.Edge; break; case AL_DISTORTION_GAIN: - *val = effect->Distortion.Gain; + *val = props->Distortion.Gain; break; case AL_DISTORTION_LOWPASS_CUTOFF: - *val = effect->Distortion.LowpassCutoff; + *val = props->Distortion.LowpassCutoff; break; case AL_DISTORTION_EQCENTER: - *val = effect->Distortion.EQCenter; + *val = props->Distortion.EQCenter; break; case AL_DISTORTION_EQBANDWIDTH: - *val = effect->Distortion.EQBandwidth; + *val = props->Distortion.EQBandwidth; break; default: diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 533461ac..d1f734bf 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -96,16 +96,16 @@ static ALvoid ALechoState_Update(ALechoState *state, ALCdevice *Device, const AL ALfloat dirGain; ALuint i; - state->Tap[0].delay = fastf2u(Slot->effect.Echo.Delay * frequency) + 1; - state->Tap[1].delay = fastf2u(Slot->effect.Echo.LRDelay * frequency); + state->Tap[0].delay = fastf2u(Slot->EffectProps.Echo.Delay * frequency) + 1; + state->Tap[1].delay = fastf2u(Slot->EffectProps.Echo.LRDelay * frequency); state->Tap[1].delay += state->Tap[0].delay; - lrpan = Slot->effect.Echo.Spread; + lrpan = Slot->EffectProps.Echo.Spread; - state->FeedGain = Slot->effect.Echo.Feedback; + state->FeedGain = Slot->EffectProps.Echo.Feedback; cw = cosf(F_PI*2.0f * LOWPASSFREQREF / frequency); - g = 1.0f - Slot->effect.Echo.Damping; + g = 1.0f - Slot->EffectProps.Echo.Damping; state->iirFilter.coeff = lpCoeffCalc(g, cw); gain = Slot->Gain; @@ -229,39 +229,40 @@ void ALecho_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, cons } 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) - effect->Echo.Delay = val; + props->Echo.Delay = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_ECHO_LRDELAY: if(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY) - effect->Echo.LRDelay = val; + props->Echo.LRDelay = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_ECHO_DAMPING: if(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING) - effect->Echo.Damping = val; + props->Echo.Damping = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_ECHO_FEEDBACK: if(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK) - effect->Echo.Feedback = val; + props->Echo.Feedback = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_ECHO_SPREAD: if(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD) - effect->Echo.Spread = val; + props->Echo.Spread = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -284,26 +285,27 @@ void ALecho_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALin } void ALecho_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_ECHO_DELAY: - *val = effect->Echo.Delay; + *val = props->Echo.Delay; break; case AL_ECHO_LRDELAY: - *val = effect->Echo.LRDelay; + *val = props->Echo.LRDelay; break; case AL_ECHO_DAMPING: - *val = effect->Echo.Damping; + *val = props->Echo.Damping; break; case AL_ECHO_FEEDBACK: - *val = effect->Echo.Feedback; + *val = props->Echo.Feedback; break; case AL_ECHO_SPREAD: - *val = effect->Echo.Spread; + *val = props->Echo.Spread; break; default: diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 3d5f35d5..df95716f 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -141,22 +141,22 @@ static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device switch (it) { case 0: /* Low Shelf */ - gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.LowGain)) / 40.0f); - filter_frequency = slot->effect.Equalizer.LowCutoff; + gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.LowGain)) / 40.0f); + filter_frequency = slot->EffectProps.Equalizer.LowCutoff; break; case 1: /* Peaking */ - gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.Mid1Gain)) / 40.0f); - filter_frequency = slot->effect.Equalizer.Mid1Center; - bandwidth = slot->effect.Equalizer.Mid1Width; + gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.Mid1Gain)) / 40.0f); + filter_frequency = slot->EffectProps.Equalizer.Mid1Center; + bandwidth = slot->EffectProps.Equalizer.Mid1Width; break; case 2: /* Peaking */ - gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.Mid2Gain)) / 40.0f); - filter_frequency = slot->effect.Equalizer.Mid2Center; - bandwidth = slot->effect.Equalizer.Mid2Width; + gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.Mid2Gain)) / 40.0f); + filter_frequency = slot->EffectProps.Equalizer.Mid2Center; + bandwidth = slot->EffectProps.Equalizer.Mid2Width; break; case 3: /* High Shelf */ - gain = powf(10.0f, (20.0f * log10f(slot->effect.Equalizer.HighGain)) / 40.0f); - filter_frequency = slot->effect.Equalizer.HighCutoff; + gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.HighGain)) / 40.0f); + filter_frequency = slot->EffectProps.Equalizer.HighCutoff; break; } @@ -323,15 +323,15 @@ ALeffectStateFactory *ALequalizerStateFactory_getFactory(void) void ALequalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { - effect=effect; - val=val; - + ALeffectProps *props = &effect->Props; switch(param) { default: alSetError(context, AL_INVALID_ENUM); break; } + (void)props; + (void)val; } void ALequalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { @@ -339,74 +339,75 @@ void ALequalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum 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) - effect->Equalizer.LowGain = val; + props->Equalizer.LowGain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_LOW_CUTOFF: if(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF) - effect->Equalizer.LowCutoff = val; + props->Equalizer.LowCutoff = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_MID1_GAIN: if(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN) - effect->Equalizer.Mid1Gain = val; + props->Equalizer.Mid1Gain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_MID1_CENTER: if(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER) - effect->Equalizer.Mid1Center = val; + props->Equalizer.Mid1Center = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_MID1_WIDTH: if(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH) - effect->Equalizer.Mid1Width = val; + props->Equalizer.Mid1Width = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_MID2_GAIN: if(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN) - effect->Equalizer.Mid2Gain = val; + props->Equalizer.Mid2Gain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_MID2_CENTER: if(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER) - effect->Equalizer.Mid2Center = val; + props->Equalizer.Mid2Center = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_MID2_WIDTH: if(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH) - effect->Equalizer.Mid2Width = val; + props->Equalizer.Mid2Width = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_HIGH_GAIN: if(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN) - effect->Equalizer.HighGain = val; + props->Equalizer.HighGain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EQUALIZER_HIGH_CUTOFF: if(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF) - effect->Equalizer.HighCutoff = val; + props->Equalizer.HighCutoff = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -423,15 +424,15 @@ void ALequalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, void ALequalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { - effect=effect; - val=val; - + ALeffectProps *props = &effect->Props; switch(param) { default: alSetError(context, AL_INVALID_ENUM); break; } + (void)props; + (void)val; } void ALequalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { @@ -439,46 +440,47 @@ void ALequalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, } void ALequalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_EQUALIZER_LOW_GAIN: - *val = effect->Equalizer.LowGain; + *val = props->Equalizer.LowGain; break; case AL_EQUALIZER_LOW_CUTOFF: - *val = effect->Equalizer.LowCutoff; + *val = props->Equalizer.LowCutoff; break; case AL_EQUALIZER_MID1_GAIN: - *val = effect->Equalizer.Mid1Gain; + *val = props->Equalizer.Mid1Gain; break; case AL_EQUALIZER_MID1_CENTER: - *val = effect->Equalizer.Mid1Center; + *val = props->Equalizer.Mid1Center; break; case AL_EQUALIZER_MID1_WIDTH: - *val = effect->Equalizer.Mid1Width; + *val = props->Equalizer.Mid1Width; break; case AL_EQUALIZER_MID2_GAIN: - *val = effect->Equalizer.Mid2Gain; + *val = props->Equalizer.Mid2Gain; break; case AL_EQUALIZER_MID2_CENTER: - *val = effect->Equalizer.Mid2Center; + *val = props->Equalizer.Mid2Center; break; case AL_EQUALIZER_MID2_WIDTH: - *val = effect->Equalizer.Mid2Width; + *val = props->Equalizer.Mid2Width; break; case AL_EQUALIZER_HIGH_GAIN: - *val = effect->Equalizer.HighGain; + *val = props->Equalizer.HighGain; break; case AL_EQUALIZER_HIGH_CUTOFF: - *val = effect->Equalizer.HighCutoff; + *val = props->Equalizer.HighCutoff; break; default: diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index 12e16de2..1983c5e0 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -111,17 +111,17 @@ static ALvoid ALflangerState_Update(ALflangerState *state, ALCdevice *Device, co state->Gain[1][it] = 0.0f; } - state->waveform = Slot->effect.Flanger.Waveform; - state->depth = Slot->effect.Flanger.Depth; - state->feedback = Slot->effect.Flanger.Feedback; - state->delay = fastf2i(Slot->effect.Flanger.Delay * frequency); + state->waveform = Slot->EffectProps.Flanger.Waveform; + state->depth = Slot->EffectProps.Flanger.Depth; + state->feedback = Slot->EffectProps.Flanger.Feedback; + state->delay = fastf2i(Slot->EffectProps.Flanger.Delay * frequency); /* Gains for left and right sides */ ComputeAngleGains(Device, atan2f(-1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[0]); ComputeAngleGains(Device, atan2f(+1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[1]); - phase = Slot->effect.Flanger.Phase; - rate = Slot->effect.Flanger.Rate; + phase = Slot->EffectProps.Flanger.Phase; + rate = Slot->EffectProps.Flanger.Rate; /* Calculate LFO coefficient */ switch(state->waveform) @@ -285,18 +285,19 @@ ALeffectStateFactory *ALflangerStateFactory_getFactory(void) 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) - effect->Flanger.Waveform = val; + props->Flanger.Waveform = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_FLANGER_PHASE: if(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE) - effect->Flanger.Phase = val; + props->Flanger.Phase = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -312,32 +313,33 @@ void ALflanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, c } 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) - effect->Flanger.Rate = val; + props->Flanger.Rate = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_FLANGER_DEPTH: if(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH) - effect->Flanger.Depth = val; + props->Flanger.Depth = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_FLANGER_FEEDBACK: if(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK) - effect->Flanger.Feedback = val; + props->Flanger.Feedback = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_FLANGER_DELAY: if(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY) - effect->Flanger.Delay = val; + props->Flanger.Delay = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -354,14 +356,15 @@ void ALflanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, c void ALflanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_FLANGER_WAVEFORM: - *val = effect->Flanger.Waveform; + *val = props->Flanger.Waveform; break; case AL_FLANGER_PHASE: - *val = effect->Flanger.Phase; + *val = props->Flanger.Phase; break; default: @@ -375,22 +378,23 @@ void ALflanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, A } void ALflanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_FLANGER_RATE: - *val = effect->Flanger.Rate; + *val = props->Flanger.Rate; break; case AL_FLANGER_DEPTH: - *val = effect->Flanger.Depth; + *val = props->Flanger.Depth; break; case AL_FLANGER_FEEDBACK: - *val = effect->Flanger.Feedback; + *val = props->Flanger.Feedback; break; case AL_FLANGER_DELAY: - *val = effect->Flanger.Delay; + *val = props->Flanger.Delay; break; default: diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index 3f9ff8a5..bd994adb 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -152,18 +152,18 @@ static ALvoid ALmodulatorState_Update(ALmodulatorState *state, ALCdevice *Device ALfloat gain, cw, a = 0.0f; ALuint index; - if(Slot->effect.Modulator.Waveform == AL_RING_MODULATOR_SINUSOID) + if(Slot->EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SINUSOID) state->Waveform = SINUSOID; - else if(Slot->effect.Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH) + else if(Slot->EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH) state->Waveform = SAWTOOTH; - else if(Slot->effect.Modulator.Waveform == AL_RING_MODULATOR_SQUARE) + else if(Slot->EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SQUARE) state->Waveform = SQUARE; - state->step = fastf2u(Slot->effect.Modulator.Frequency*WAVEFORM_FRACONE / + state->step = fastf2u(Slot->EffectProps.Modulator.Frequency*WAVEFORM_FRACONE / Device->Frequency); if(state->step == 0) state->step = 1; - cw = cosf(F_PI*2.0f * Slot->effect.Modulator.HighPassCutoff / + cw = cosf(F_PI*2.0f * Slot->EffectProps.Modulator.HighPassCutoff / Device->Frequency); a = (2.0f-cw) - sqrtf(powf(2.0f-cw, 2.0f) - 1.0f); state->iirFilter.coeff = a; @@ -240,18 +240,19 @@ ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void) 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) - effect->Modulator.Frequency = val; + props->Modulator.Frequency = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_RING_MODULATOR_HIGHPASS_CUTOFF: if(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF) - effect->Modulator.HighPassCutoff = val; + props->Modulator.HighPassCutoff = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -267,6 +268,7 @@ void ALmodulator_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, } void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { + ALeffectProps *props = &effect->Props; switch(param) { case AL_RING_MODULATOR_FREQUENCY: @@ -276,7 +278,7 @@ void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, case AL_RING_MODULATOR_WAVEFORM: if(val >= AL_RING_MODULATOR_MIN_WAVEFORM && val <= AL_RING_MODULATOR_MAX_WAVEFORM) - effect->Modulator.Waveform = val; + props->Modulator.Waveform = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -293,16 +295,17 @@ void ALmodulator_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, void ALmodulator_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_RING_MODULATOR_FREQUENCY: - *val = (ALint)effect->Modulator.Frequency; + *val = (ALint)props->Modulator.Frequency; break; case AL_RING_MODULATOR_HIGHPASS_CUTOFF: - *val = (ALint)effect->Modulator.HighPassCutoff; + *val = (ALint)props->Modulator.HighPassCutoff; break; case AL_RING_MODULATOR_WAVEFORM: - *val = effect->Modulator.Waveform; + *val = props->Modulator.Waveform; break; default: @@ -316,13 +319,14 @@ void ALmodulator_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, } void ALmodulator_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + ALeffectProps *props = &effect->Props; switch(param) { case AL_RING_MODULATOR_FREQUENCY: - *val = effect->Modulator.Frequency; + *val = props->Modulator.Frequency; break; case AL_RING_MODULATOR_HIGHPASS_CUTOFF: - *val = effect->Modulator.HighPassCutoff; + *val = props->Modulator.HighPassCutoff; break; default: diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index 2421225d..b283b67f 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1085,70 +1085,70 @@ static ALvoid ALreverbState_Update(ALreverbState *State, ALCdevice *Device, cons ALuint frequency = Device->Frequency; ALfloat cw, x, y, hfRatio; - if(Slot->effect.type == AL_EFFECT_EAXREVERB && !EmulateEAXReverb) + if(Slot->EffectType == AL_EFFECT_EAXREVERB && !EmulateEAXReverb) State->IsEax = AL_TRUE; - else if(Slot->effect.type == AL_EFFECT_REVERB || EmulateEAXReverb) + else if(Slot->EffectType == AL_EFFECT_REVERB || EmulateEAXReverb) State->IsEax = AL_FALSE; // Calculate the master low-pass filter (from the master effect HF gain). if(State->IsEax) - cw = CalcI3DL2HFreq(Slot->effect.Reverb.HFReference, frequency); + cw = CalcI3DL2HFreq(Slot->EffectProps.Reverb.HFReference, frequency); else cw = CalcI3DL2HFreq(LOWPASSFREQREF, frequency); // This is done with 2 chained 1-pole filters, so no need to square g. - State->LpFilter.coeff = lpCoeffCalc(Slot->effect.Reverb.GainHF, cw); + State->LpFilter.coeff = lpCoeffCalc(Slot->EffectProps.Reverb.GainHF, cw); if(State->IsEax) { // Update the modulator line. - UpdateModulator(Slot->effect.Reverb.ModulationTime, - Slot->effect.Reverb.ModulationDepth, + UpdateModulator(Slot->EffectProps.Reverb.ModulationTime, + Slot->EffectProps.Reverb.ModulationDepth, frequency, State); } // Update the initial effect delay. - UpdateDelayLine(Slot->effect.Reverb.ReflectionsDelay, - Slot->effect.Reverb.LateReverbDelay, + UpdateDelayLine(Slot->EffectProps.Reverb.ReflectionsDelay, + Slot->EffectProps.Reverb.LateReverbDelay, frequency, State); // Update the early lines. - UpdateEarlyLines(Slot->effect.Reverb.Gain, - Slot->effect.Reverb.ReflectionsGain, - Slot->effect.Reverb.LateReverbDelay, State); + UpdateEarlyLines(Slot->EffectProps.Reverb.Gain, + Slot->EffectProps.Reverb.ReflectionsGain, + Slot->EffectProps.Reverb.LateReverbDelay, State); // Update the decorrelator. - UpdateDecorrelator(Slot->effect.Reverb.Density, frequency, State); + UpdateDecorrelator(Slot->EffectProps.Reverb.Density, frequency, State); // Get the mixing matrix coefficients (x and y). - CalcMatrixCoeffs(Slot->effect.Reverb.Diffusion, &x, &y); + CalcMatrixCoeffs(Slot->EffectProps.Reverb.Diffusion, &x, &y); // Then divide x into y to simplify the matrix calculation. State->Late.MixCoeff = y / x; // If the HF limit parameter is flagged, calculate an appropriate limit // based on the air absorption parameter. - hfRatio = Slot->effect.Reverb.DecayHFRatio; - if(Slot->effect.Reverb.DecayHFLimit && - Slot->effect.Reverb.AirAbsorptionGainHF < 1.0f) + hfRatio = Slot->EffectProps.Reverb.DecayHFRatio; + if(Slot->EffectProps.Reverb.DecayHFLimit && + Slot->EffectProps.Reverb.AirAbsorptionGainHF < 1.0f) hfRatio = CalcLimitedHfRatio(hfRatio, - Slot->effect.Reverb.AirAbsorptionGainHF, - Slot->effect.Reverb.DecayTime); + Slot->EffectProps.Reverb.AirAbsorptionGainHF, + Slot->EffectProps.Reverb.DecayTime); // Update the late lines. - UpdateLateLines(Slot->effect.Reverb.Gain, Slot->effect.Reverb.LateReverbGain, - x, Slot->effect.Reverb.Density, Slot->effect.Reverb.DecayTime, - Slot->effect.Reverb.Diffusion, hfRatio, cw, frequency, State); + UpdateLateLines(Slot->EffectProps.Reverb.Gain, Slot->EffectProps.Reverb.LateReverbGain, + x, Slot->EffectProps.Reverb.Density, Slot->EffectProps.Reverb.DecayTime, + Slot->EffectProps.Reverb.Diffusion, hfRatio, cw, frequency, State); if(State->IsEax) { // Update the echo line. - UpdateEchoLine(Slot->effect.Reverb.Gain, Slot->effect.Reverb.LateReverbGain, - Slot->effect.Reverb.EchoTime, Slot->effect.Reverb.DecayTime, - Slot->effect.Reverb.Diffusion, Slot->effect.Reverb.EchoDepth, + UpdateEchoLine(Slot->EffectProps.Reverb.Gain, Slot->EffectProps.Reverb.LateReverbGain, + Slot->EffectProps.Reverb.EchoTime, Slot->EffectProps.Reverb.DecayTime, + Slot->EffectProps.Reverb.Diffusion, Slot->EffectProps.Reverb.EchoDepth, hfRatio, cw, frequency, State); // Update early and late 3D panning. - Update3DPanning(Device, Slot->effect.Reverb.ReflectionsPan, - Slot->effect.Reverb.LateReverbPan, Slot->Gain, State); + Update3DPanning(Device, Slot->EffectProps.Reverb.ReflectionsPan, + Slot->EffectProps.Reverb.LateReverbPan, Slot->Gain, State); } else { @@ -1292,11 +1292,12 @@ ALeffectStateFactory *ALreverbStateFactory_getFactory(void) 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) - effect->Reverb.DecayHFLimit = val; + props->Reverb.DecayHFLimit = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -1312,144 +1313,145 @@ void ALeaxreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, } 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) - effect->Reverb.Density = val; + props->Reverb.Density = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_DIFFUSION: if(val >= AL_EAXREVERB_MIN_DIFFUSION && val <= AL_EAXREVERB_MAX_DIFFUSION) - effect->Reverb.Diffusion = val; + props->Reverb.Diffusion = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_GAIN: if(val >= AL_EAXREVERB_MIN_GAIN && val <= AL_EAXREVERB_MAX_GAIN) - effect->Reverb.Gain = val; + props->Reverb.Gain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_GAINHF: if(val >= AL_EAXREVERB_MIN_GAINHF && val <= AL_EAXREVERB_MAX_GAINHF) - effect->Reverb.GainHF = val; + props->Reverb.GainHF = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_GAINLF: if(val >= AL_EAXREVERB_MIN_GAINLF && val <= AL_EAXREVERB_MAX_GAINLF) - effect->Reverb.GainLF = val; + props->Reverb.GainLF = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_DECAY_TIME: if(val >= AL_EAXREVERB_MIN_DECAY_TIME && val <= AL_EAXREVERB_MAX_DECAY_TIME) - effect->Reverb.DecayTime = val; + props->Reverb.DecayTime = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_DECAY_HFRATIO: if(val >= AL_EAXREVERB_MIN_DECAY_HFRATIO && val <= AL_EAXREVERB_MAX_DECAY_HFRATIO) - effect->Reverb.DecayHFRatio = val; + props->Reverb.DecayHFRatio = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_DECAY_LFRATIO: if(val >= AL_EAXREVERB_MIN_DECAY_LFRATIO && val <= AL_EAXREVERB_MAX_DECAY_LFRATIO) - effect->Reverb.DecayLFRatio = val; + props->Reverb.DecayLFRatio = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_REFLECTIONS_GAIN: if(val >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN && val <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN) - effect->Reverb.ReflectionsGain = val; + props->Reverb.ReflectionsGain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_REFLECTIONS_DELAY: if(val >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY && val <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY) - effect->Reverb.ReflectionsDelay = val; + props->Reverb.ReflectionsDelay = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_LATE_REVERB_GAIN: if(val >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN && val <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN) - effect->Reverb.LateReverbGain = val; + props->Reverb.LateReverbGain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_LATE_REVERB_DELAY: if(val >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY && val <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY) - effect->Reverb.LateReverbDelay = val; + props->Reverb.LateReverbDelay = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_AIR_ABSORPTION_GAINHF: if(val >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF) - effect->Reverb.AirAbsorptionGainHF = val; + props->Reverb.AirAbsorptionGainHF = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_ECHO_TIME: if(val >= AL_EAXREVERB_MIN_ECHO_TIME && val <= AL_EAXREVERB_MAX_ECHO_TIME) - effect->Reverb.EchoTime = val; + props->Reverb.EchoTime = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_ECHO_DEPTH: if(val >= AL_EAXREVERB_MIN_ECHO_DEPTH && val <= AL_EAXREVERB_MAX_ECHO_DEPTH) - effect->Reverb.EchoDepth = val; + props->Reverb.EchoDepth = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_MODULATION_TIME: if(val >= AL_EAXREVERB_MIN_MODULATION_TIME && val <= AL_EAXREVERB_MAX_MODULATION_TIME) - effect->Reverb.ModulationTime = val; + props->Reverb.ModulationTime = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_MODULATION_DEPTH: if(val >= AL_EAXREVERB_MIN_MODULATION_DEPTH && val <= AL_EAXREVERB_MAX_MODULATION_DEPTH) - effect->Reverb.ModulationDepth = val; + props->Reverb.ModulationDepth = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_HFREFERENCE: if(val >= AL_EAXREVERB_MIN_HFREFERENCE && val <= AL_EAXREVERB_MAX_HFREFERENCE) - effect->Reverb.HFReference = val; + props->Reverb.HFReference = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_LFREFERENCE: if(val >= AL_EAXREVERB_MIN_LFREFERENCE && val <= AL_EAXREVERB_MAX_LFREFERENCE) - effect->Reverb.LFReference = val; + props->Reverb.LFReference = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR: if(val >= AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR) - effect->Reverb.RoomRolloffFactor = val; + props->Reverb.RoomRolloffFactor = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -1461,15 +1463,16 @@ void ALeaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum 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])) { LockContext(context); - effect->Reverb.ReflectionsPan[0] = vals[0]; - effect->Reverb.ReflectionsPan[1] = vals[1]; - effect->Reverb.ReflectionsPan[2] = vals[2]; + props->Reverb.ReflectionsPan[0] = vals[0]; + props->Reverb.ReflectionsPan[1] = vals[1]; + props->Reverb.ReflectionsPan[2] = vals[2]; UnlockContext(context); } else @@ -1479,9 +1482,9 @@ void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, if(isfinite(vals[0]) && isfinite(vals[1]) && isfinite(vals[2])) { LockContext(context); - effect->Reverb.LateReverbPan[0] = vals[0]; - effect->Reverb.LateReverbPan[1] = vals[1]; - effect->Reverb.LateReverbPan[2] = vals[2]; + props->Reverb.LateReverbPan[0] = vals[0]; + props->Reverb.LateReverbPan[1] = vals[1]; + props->Reverb.LateReverbPan[2] = vals[2]; UnlockContext(context); } else @@ -1496,10 +1499,11 @@ void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, void ALeaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_EAXREVERB_DECAY_HFLIMIT: - *val = effect->Reverb.DecayHFLimit; + *val = props->Reverb.DecayHFLimit; break; default: @@ -1513,86 +1517,87 @@ void ALeaxreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, } void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_EAXREVERB_DENSITY: - *val = effect->Reverb.Density; + *val = props->Reverb.Density; break; case AL_EAXREVERB_DIFFUSION: - *val = effect->Reverb.Diffusion; + *val = props->Reverb.Diffusion; break; case AL_EAXREVERB_GAIN: - *val = effect->Reverb.Gain; + *val = props->Reverb.Gain; break; case AL_EAXREVERB_GAINHF: - *val = effect->Reverb.GainHF; + *val = props->Reverb.GainHF; break; case AL_EAXREVERB_GAINLF: - *val = effect->Reverb.GainLF; + *val = props->Reverb.GainLF; break; case AL_EAXREVERB_DECAY_TIME: - *val = effect->Reverb.DecayTime; + *val = props->Reverb.DecayTime; break; case AL_EAXREVERB_DECAY_HFRATIO: - *val = effect->Reverb.DecayHFRatio; + *val = props->Reverb.DecayHFRatio; break; case AL_EAXREVERB_DECAY_LFRATIO: - *val = effect->Reverb.DecayLFRatio; + *val = props->Reverb.DecayLFRatio; break; case AL_EAXREVERB_REFLECTIONS_GAIN: - *val = effect->Reverb.ReflectionsGain; + *val = props->Reverb.ReflectionsGain; break; case AL_EAXREVERB_REFLECTIONS_DELAY: - *val = effect->Reverb.ReflectionsDelay; + *val = props->Reverb.ReflectionsDelay; break; case AL_EAXREVERB_LATE_REVERB_GAIN: - *val = effect->Reverb.LateReverbGain; + *val = props->Reverb.LateReverbGain; break; case AL_EAXREVERB_LATE_REVERB_DELAY: - *val = effect->Reverb.LateReverbDelay; + *val = props->Reverb.LateReverbDelay; break; case AL_EAXREVERB_AIR_ABSORPTION_GAINHF: - *val = effect->Reverb.AirAbsorptionGainHF; + *val = props->Reverb.AirAbsorptionGainHF; break; case AL_EAXREVERB_ECHO_TIME: - *val = effect->Reverb.EchoTime; + *val = props->Reverb.EchoTime; break; case AL_EAXREVERB_ECHO_DEPTH: - *val = effect->Reverb.EchoDepth; + *val = props->Reverb.EchoDepth; break; case AL_EAXREVERB_MODULATION_TIME: - *val = effect->Reverb.ModulationTime; + *val = props->Reverb.ModulationTime; break; case AL_EAXREVERB_MODULATION_DEPTH: - *val = effect->Reverb.ModulationDepth; + *val = props->Reverb.ModulationDepth; break; case AL_EAXREVERB_HFREFERENCE: - *val = effect->Reverb.HFReference; + *val = props->Reverb.HFReference; break; case AL_EAXREVERB_LFREFERENCE: - *val = effect->Reverb.LFReference; + *val = props->Reverb.LFReference; break; case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR: - *val = effect->Reverb.RoomRolloffFactor; + *val = props->Reverb.RoomRolloffFactor; break; default: @@ -1602,20 +1607,21 @@ void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, } void ALeaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_EAXREVERB_REFLECTIONS_PAN: LockContext(context); - vals[0] = effect->Reverb.ReflectionsPan[0]; - vals[1] = effect->Reverb.ReflectionsPan[1]; - vals[2] = effect->Reverb.ReflectionsPan[2]; + vals[0] = props->Reverb.ReflectionsPan[0]; + vals[1] = props->Reverb.ReflectionsPan[1]; + vals[2] = props->Reverb.ReflectionsPan[2]; UnlockContext(context); break; case AL_EAXREVERB_LATE_REVERB_PAN: LockContext(context); - vals[0] = effect->Reverb.LateReverbPan[0]; - vals[1] = effect->Reverb.LateReverbPan[1]; - vals[2] = effect->Reverb.LateReverbPan[2]; + vals[0] = props->Reverb.LateReverbPan[0]; + vals[1] = props->Reverb.LateReverbPan[1]; + vals[2] = props->Reverb.LateReverbPan[2]; UnlockContext(context); break; @@ -1629,11 +1635,12 @@ 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) - effect->Reverb.DecayHFLimit = val; + props->Reverb.DecayHFLimit = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -1649,88 +1656,89 @@ void ALreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, co } 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) - effect->Reverb.Density = val; + props->Reverb.Density = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_DIFFUSION: if(val >= AL_REVERB_MIN_DIFFUSION && val <= AL_REVERB_MAX_DIFFUSION) - effect->Reverb.Diffusion = val; + props->Reverb.Diffusion = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_GAIN: if(val >= AL_REVERB_MIN_GAIN && val <= AL_REVERB_MAX_GAIN) - effect->Reverb.Gain = val; + props->Reverb.Gain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_GAINHF: if(val >= AL_REVERB_MIN_GAINHF && val <= AL_REVERB_MAX_GAINHF) - effect->Reverb.GainHF = val; + props->Reverb.GainHF = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_DECAY_TIME: if(val >= AL_REVERB_MIN_DECAY_TIME && val <= AL_REVERB_MAX_DECAY_TIME) - effect->Reverb.DecayTime = val; + props->Reverb.DecayTime = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_DECAY_HFRATIO: if(val >= AL_REVERB_MIN_DECAY_HFRATIO && val <= AL_REVERB_MAX_DECAY_HFRATIO) - effect->Reverb.DecayHFRatio = val; + props->Reverb.DecayHFRatio = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_REFLECTIONS_GAIN: if(val >= AL_REVERB_MIN_REFLECTIONS_GAIN && val <= AL_REVERB_MAX_REFLECTIONS_GAIN) - effect->Reverb.ReflectionsGain = val; + props->Reverb.ReflectionsGain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_REFLECTIONS_DELAY: if(val >= AL_REVERB_MIN_REFLECTIONS_DELAY && val <= AL_REVERB_MAX_REFLECTIONS_DELAY) - effect->Reverb.ReflectionsDelay = val; + props->Reverb.ReflectionsDelay = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_LATE_REVERB_GAIN: if(val >= AL_REVERB_MIN_LATE_REVERB_GAIN && val <= AL_REVERB_MAX_LATE_REVERB_GAIN) - effect->Reverb.LateReverbGain = val; + props->Reverb.LateReverbGain = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_LATE_REVERB_DELAY: if(val >= AL_REVERB_MIN_LATE_REVERB_DELAY && val <= AL_REVERB_MAX_LATE_REVERB_DELAY) - effect->Reverb.LateReverbDelay = val; + props->Reverb.LateReverbDelay = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_AIR_ABSORPTION_GAINHF: if(val >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF) - effect->Reverb.AirAbsorptionGainHF = val; + props->Reverb.AirAbsorptionGainHF = val; else alSetError(context, AL_INVALID_VALUE); break; case AL_REVERB_ROOM_ROLLOFF_FACTOR: if(val >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR) - effect->Reverb.RoomRolloffFactor = val; + props->Reverb.RoomRolloffFactor = val; else alSetError(context, AL_INVALID_VALUE); break; @@ -1747,10 +1755,11 @@ void ALreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, co void ALreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_REVERB_DECAY_HFLIMIT: - *val = effect->Reverb.DecayHFLimit; + *val = props->Reverb.DecayHFLimit; break; default: @@ -1764,54 +1773,55 @@ void ALreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, AL } void ALreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + const ALeffectProps *props = &effect->Props; switch(param) { case AL_REVERB_DENSITY: - *val = effect->Reverb.Density; + *val = props->Reverb.Density; break; case AL_REVERB_DIFFUSION: - *val = effect->Reverb.Diffusion; + *val = props->Reverb.Diffusion; break; case AL_REVERB_GAIN: - *val = effect->Reverb.Gain; + *val = props->Reverb.Gain; break; case AL_REVERB_GAINHF: - *val = effect->Reverb.GainHF; + *val = props->Reverb.GainHF; break; case AL_REVERB_DECAY_TIME: - *val = effect->Reverb.DecayTime; + *val = props->Reverb.DecayTime; break; case AL_REVERB_DECAY_HFRATIO: - *val = effect->Reverb.DecayHFRatio; + *val = props->Reverb.DecayHFRatio; break; case AL_REVERB_REFLECTIONS_GAIN: - *val = effect->Reverb.ReflectionsGain; + *val = props->Reverb.ReflectionsGain; break; case AL_REVERB_REFLECTIONS_DELAY: - *val = effect->Reverb.ReflectionsDelay; + *val = props->Reverb.ReflectionsDelay; break; case AL_REVERB_LATE_REVERB_GAIN: - *val = effect->Reverb.LateReverbGain; + *val = props->Reverb.LateReverbGain; break; case AL_REVERB_LATE_REVERB_DELAY: - *val = effect->Reverb.LateReverbDelay; + *val = props->Reverb.LateReverbDelay; break; case AL_REVERB_AIR_ABSORPTION_GAINHF: - *val = effect->Reverb.AirAbsorptionGainHF; + *val = props->Reverb.AirAbsorptionGainHF; break; case AL_REVERB_ROOM_ROLLOFF_FACTOR: - *val = effect->Reverb.RoomRolloffFactor; + *val = props->Reverb.RoomRolloffFactor; break; default: diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h index d7062ff7..24614fa4 100644 --- a/OpenAL32/Include/alAuxEffectSlot.h +++ b/OpenAL32/Include/alAuxEffectSlot.h @@ -73,7 +73,8 @@ static const struct ALeffectStateFactoryVtable T##_ALeffectStateFactory_vtable = struct ALeffectslot { - ALeffect effect; + ALenum EffectType; + ALeffectProps EffectProps; volatile ALfloat Gain; volatile ALboolean AuxSendAuto; diff --git a/OpenAL32/Include/alEffect.h b/OpenAL32/Include/alEffect.h index cea785dc..c0bbb40a 100644 --- a/OpenAL32/Include/alEffect.h +++ b/OpenAL32/Include/alEffect.h @@ -59,11 +59,7 @@ extern const struct ALeffectVtable ALnull_vtable; extern const struct ALeffectVtable ALdedicated_vtable; -struct ALeffect -{ - // Effect type (AL_EFFECT_NULL, ...) - ALenum type; - +typedef union ALeffectProps { struct { // Shared Reverb Properties ALfloat Density; @@ -152,6 +148,14 @@ struct ALeffect ALfloat EQCenter; ALfloat EQBandwidth; } Distortion; +} ALeffectProps; + +struct ALeffect +{ + // Effect type (AL_EFFECT_NULL, ...) + ALenum type; + + ALeffectProps Props; const struct ALeffectVtable *vtbl; diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c index 0b2cce21..e2d9b42d 100644 --- a/OpenAL32/alAuxEffectSlot.c +++ b/OpenAL32/alAuxEffectSlot.c @@ -294,10 +294,6 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum pa al_throwerr(Context, AL_INVALID_NAME); switch(param) { - case AL_EFFECTSLOT_EFFECT: - *value = Slot->effect.id; - break; - case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO: *value = Slot->AuxSendAuto; break; @@ -479,7 +475,7 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e ALenum newtype = (effect ? effect->type : AL_EFFECT_NULL); ALeffectStateFactory *factory; - if(newtype != EffectSlot->effect.type) + if(newtype != EffectSlot->EffectType) { ALeffectState *State; FPUCtl oldMode; @@ -507,9 +503,15 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e State = ExchangePtr((XchgPtr*)&EffectSlot->EffectState, State); if(!effect) - memset(&EffectSlot->effect, 0, sizeof(EffectSlot->effect)); + { + memset(&EffectSlot->EffectProps, 0, sizeof(EffectSlot->EffectProps)); + EffectSlot->EffectType = AL_EFFECT_NULL; + } else - memcpy(&EffectSlot->effect, effect, sizeof(*effect)); + { + memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props)); + EffectSlot->EffectType = effect->type; + } /* FIXME: This should be done asynchronously, but since the EffectState * object was changed, it needs an update before its Process method can @@ -525,13 +527,13 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e } else { - ALCdevice_Lock(Device); - if(!effect) - memset(&EffectSlot->effect, 0, sizeof(EffectSlot->effect)); - else - memcpy(&EffectSlot->effect, effect, sizeof(*effect)); - ALCdevice_Unlock(Device); - EffectSlot->NeedsUpdate = AL_TRUE; + if(effect) + { + ALCdevice_Lock(Device); + memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props)); + ALCdevice_Unlock(Device); + EffectSlot->NeedsUpdate = AL_TRUE; + } } return AL_NO_ERROR; @@ -543,6 +545,8 @@ ALenum InitEffectSlot(ALeffectslot *slot) ALeffectStateFactory *factory; ALint i, c; + slot->EffectType = AL_EFFECT_NULL; + factory = getFactoryByType(AL_EFFECT_NULL); if(!(slot->EffectState=ALeffectStateFactory_create(factory))) return AL_OUT_OF_MEMORY; diff --git a/OpenAL32/alEffect.c b/OpenAL32/alEffect.c index dded17b1..827a2439 100644 --- a/OpenAL32/alEffect.c +++ b/OpenAL32/alEffect.c @@ -368,107 +368,107 @@ static void InitEffectParams(ALeffect *effect, ALenum type) switch(type) { case AL_EFFECT_EAXREVERB: - effect->Reverb.Density = AL_EAXREVERB_DEFAULT_DENSITY; - effect->Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION; - effect->Reverb.Gain = AL_EAXREVERB_DEFAULT_GAIN; - effect->Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF; - effect->Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF; - effect->Reverb.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME; - effect->Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO; - effect->Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO; - effect->Reverb.ReflectionsGain = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN; - effect->Reverb.ReflectionsDelay = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY; - effect->Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ; - effect->Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ; - effect->Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ; - effect->Reverb.LateReverbGain = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN; - effect->Reverb.LateReverbDelay = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY; - effect->Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ; - effect->Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ; - effect->Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ; - effect->Reverb.EchoTime = AL_EAXREVERB_DEFAULT_ECHO_TIME; - effect->Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH; - effect->Reverb.ModulationTime = AL_EAXREVERB_DEFAULT_MODULATION_TIME; - effect->Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH; - effect->Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF; - effect->Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE; - effect->Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE; - effect->Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR; - effect->Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT; + effect->Props.Reverb.Density = AL_EAXREVERB_DEFAULT_DENSITY; + effect->Props.Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION; + effect->Props.Reverb.Gain = AL_EAXREVERB_DEFAULT_GAIN; + effect->Props.Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF; + effect->Props.Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF; + effect->Props.Reverb.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME; + effect->Props.Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO; + effect->Props.Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO; + effect->Props.Reverb.ReflectionsGain = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN; + effect->Props.Reverb.ReflectionsDelay = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY; + effect->Props.Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ; + effect->Props.Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ; + effect->Props.Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ; + effect->Props.Reverb.LateReverbGain = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN; + effect->Props.Reverb.LateReverbDelay = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY; + effect->Props.Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ; + effect->Props.Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ; + effect->Props.Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ; + effect->Props.Reverb.EchoTime = AL_EAXREVERB_DEFAULT_ECHO_TIME; + effect->Props.Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH; + effect->Props.Reverb.ModulationTime = AL_EAXREVERB_DEFAULT_MODULATION_TIME; + effect->Props.Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH; + effect->Props.Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF; + effect->Props.Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE; + effect->Props.Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE; + effect->Props.Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR; + effect->Props.Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT; effect->vtbl = &ALeaxreverb_vtable; break; case AL_EFFECT_REVERB: - effect->Reverb.Density = AL_REVERB_DEFAULT_DENSITY; - effect->Reverb.Diffusion = AL_REVERB_DEFAULT_DIFFUSION; - effect->Reverb.Gain = AL_REVERB_DEFAULT_GAIN; - effect->Reverb.GainHF = AL_REVERB_DEFAULT_GAINHF; - effect->Reverb.DecayTime = AL_REVERB_DEFAULT_DECAY_TIME; - effect->Reverb.DecayHFRatio = AL_REVERB_DEFAULT_DECAY_HFRATIO; - effect->Reverb.ReflectionsGain = AL_REVERB_DEFAULT_REFLECTIONS_GAIN; - effect->Reverb.ReflectionsDelay = AL_REVERB_DEFAULT_REFLECTIONS_DELAY; - effect->Reverb.LateReverbGain = AL_REVERB_DEFAULT_LATE_REVERB_GAIN; - effect->Reverb.LateReverbDelay = AL_REVERB_DEFAULT_LATE_REVERB_DELAY; - effect->Reverb.AirAbsorptionGainHF = AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF; - effect->Reverb.RoomRolloffFactor = AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR; - effect->Reverb.DecayHFLimit = AL_REVERB_DEFAULT_DECAY_HFLIMIT; + effect->Props.Reverb.Density = AL_REVERB_DEFAULT_DENSITY; + effect->Props.Reverb.Diffusion = AL_REVERB_DEFAULT_DIFFUSION; + effect->Props.Reverb.Gain = AL_REVERB_DEFAULT_GAIN; + effect->Props.Reverb.GainHF = AL_REVERB_DEFAULT_GAINHF; + effect->Props.Reverb.DecayTime = AL_REVERB_DEFAULT_DECAY_TIME; + effect->Props.Reverb.DecayHFRatio = AL_REVERB_DEFAULT_DECAY_HFRATIO; + effect->Props.Reverb.ReflectionsGain = AL_REVERB_DEFAULT_REFLECTIONS_GAIN; + effect->Props.Reverb.ReflectionsDelay = AL_REVERB_DEFAULT_REFLECTIONS_DELAY; + effect->Props.Reverb.LateReverbGain = AL_REVERB_DEFAULT_LATE_REVERB_GAIN; + effect->Props.Reverb.LateReverbDelay = AL_REVERB_DEFAULT_LATE_REVERB_DELAY; + effect->Props.Reverb.AirAbsorptionGainHF = AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF; + effect->Props.Reverb.RoomRolloffFactor = AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR; + effect->Props.Reverb.DecayHFLimit = AL_REVERB_DEFAULT_DECAY_HFLIMIT; effect->vtbl = &ALreverb_vtable; break; case AL_EFFECT_CHORUS: - effect->Chorus.Waveform = AL_CHORUS_DEFAULT_WAVEFORM; - effect->Chorus.Phase = AL_CHORUS_DEFAULT_PHASE; - effect->Chorus.Rate = AL_CHORUS_DEFAULT_RATE; - effect->Chorus.Depth = AL_CHORUS_DEFAULT_DEPTH; - effect->Chorus.Feedback = AL_CHORUS_DEFAULT_FEEDBACK; - effect->Chorus.Delay = AL_CHORUS_DEFAULT_DELAY; + effect->Props.Chorus.Waveform = AL_CHORUS_DEFAULT_WAVEFORM; + effect->Props.Chorus.Phase = AL_CHORUS_DEFAULT_PHASE; + effect->Props.Chorus.Rate = AL_CHORUS_DEFAULT_RATE; + effect->Props.Chorus.Depth = AL_CHORUS_DEFAULT_DEPTH; + effect->Props.Chorus.Feedback = AL_CHORUS_DEFAULT_FEEDBACK; + effect->Props.Chorus.Delay = AL_CHORUS_DEFAULT_DELAY; effect->vtbl = &ALchorus_vtable; break; case AL_EFFECT_DISTORTION: - effect->Distortion.Edge = AL_DISTORTION_DEFAULT_EDGE; - effect->Distortion.Gain = AL_DISTORTION_DEFAULT_GAIN; - effect->Distortion.LowpassCutoff = AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF; - effect->Distortion.EQCenter = AL_DISTORTION_DEFAULT_EQCENTER; - effect->Distortion.EQBandwidth = AL_DISTORTION_DEFAULT_EQBANDWIDTH; + effect->Props.Distortion.Edge = AL_DISTORTION_DEFAULT_EDGE; + effect->Props.Distortion.Gain = AL_DISTORTION_DEFAULT_GAIN; + effect->Props.Distortion.LowpassCutoff = AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF; + effect->Props.Distortion.EQCenter = AL_DISTORTION_DEFAULT_EQCENTER; + effect->Props.Distortion.EQBandwidth = AL_DISTORTION_DEFAULT_EQBANDWIDTH; effect->vtbl = &ALdistortion_vtable; break; case AL_EFFECT_ECHO: - effect->Echo.Delay = AL_ECHO_DEFAULT_DELAY; - effect->Echo.LRDelay = AL_ECHO_DEFAULT_LRDELAY; - effect->Echo.Damping = AL_ECHO_DEFAULT_DAMPING; - effect->Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK; - effect->Echo.Spread = AL_ECHO_DEFAULT_SPREAD; + effect->Props.Echo.Delay = AL_ECHO_DEFAULT_DELAY; + effect->Props.Echo.LRDelay = AL_ECHO_DEFAULT_LRDELAY; + effect->Props.Echo.Damping = AL_ECHO_DEFAULT_DAMPING; + effect->Props.Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK; + effect->Props.Echo.Spread = AL_ECHO_DEFAULT_SPREAD; effect->vtbl = &ALecho_vtable; break; case AL_EFFECT_EQUALIZER: - effect->Equalizer.LowCutoff = AL_EQUALIZER_DEFAULT_LOW_CUTOFF; - effect->Equalizer.LowGain = AL_EQUALIZER_DEFAULT_LOW_GAIN; - effect->Equalizer.Mid1Center = AL_EQUALIZER_DEFAULT_MID1_CENTER; - effect->Equalizer.Mid1Gain = AL_EQUALIZER_DEFAULT_MID1_GAIN; - effect->Equalizer.Mid1Width = AL_EQUALIZER_DEFAULT_MID1_WIDTH; - effect->Equalizer.Mid2Center = AL_EQUALIZER_DEFAULT_MID2_CENTER; - effect->Equalizer.Mid2Gain = AL_EQUALIZER_DEFAULT_MID2_GAIN; - effect->Equalizer.Mid2Width = AL_EQUALIZER_DEFAULT_MID2_WIDTH; - effect->Equalizer.HighCutoff = AL_EQUALIZER_DEFAULT_HIGH_CUTOFF; - effect->Equalizer.HighGain = AL_EQUALIZER_DEFAULT_HIGH_GAIN; + effect->Props.Equalizer.LowCutoff = AL_EQUALIZER_DEFAULT_LOW_CUTOFF; + effect->Props.Equalizer.LowGain = AL_EQUALIZER_DEFAULT_LOW_GAIN; + effect->Props.Equalizer.Mid1Center = AL_EQUALIZER_DEFAULT_MID1_CENTER; + effect->Props.Equalizer.Mid1Gain = AL_EQUALIZER_DEFAULT_MID1_GAIN; + effect->Props.Equalizer.Mid1Width = AL_EQUALIZER_DEFAULT_MID1_WIDTH; + effect->Props.Equalizer.Mid2Center = AL_EQUALIZER_DEFAULT_MID2_CENTER; + effect->Props.Equalizer.Mid2Gain = AL_EQUALIZER_DEFAULT_MID2_GAIN; + effect->Props.Equalizer.Mid2Width = AL_EQUALIZER_DEFAULT_MID2_WIDTH; + effect->Props.Equalizer.HighCutoff = AL_EQUALIZER_DEFAULT_HIGH_CUTOFF; + effect->Props.Equalizer.HighGain = AL_EQUALIZER_DEFAULT_HIGH_GAIN; effect->vtbl = &ALequalizer_vtable; break; case AL_EFFECT_FLANGER: - effect->Flanger.Waveform = AL_FLANGER_DEFAULT_WAVEFORM; - effect->Flanger.Phase = AL_FLANGER_DEFAULT_PHASE; - effect->Flanger.Rate = AL_FLANGER_DEFAULT_RATE; - effect->Flanger.Depth = AL_FLANGER_DEFAULT_DEPTH; - effect->Flanger.Feedback = AL_FLANGER_DEFAULT_FEEDBACK; - effect->Flanger.Delay = AL_FLANGER_DEFAULT_DELAY; + effect->Props.Flanger.Waveform = AL_FLANGER_DEFAULT_WAVEFORM; + effect->Props.Flanger.Phase = AL_FLANGER_DEFAULT_PHASE; + effect->Props.Flanger.Rate = AL_FLANGER_DEFAULT_RATE; + effect->Props.Flanger.Depth = AL_FLANGER_DEFAULT_DEPTH; + effect->Props.Flanger.Feedback = AL_FLANGER_DEFAULT_FEEDBACK; + effect->Props.Flanger.Delay = AL_FLANGER_DEFAULT_DELAY; effect->vtbl = &ALflanger_vtable; break; case AL_EFFECT_RING_MODULATOR: - effect->Modulator.Frequency = AL_RING_MODULATOR_DEFAULT_FREQUENCY; - effect->Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF; - effect->Modulator.Waveform = AL_RING_MODULATOR_DEFAULT_WAVEFORM; + effect->Props.Modulator.Frequency = AL_RING_MODULATOR_DEFAULT_FREQUENCY; + effect->Props.Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF; + effect->Props.Modulator.Waveform = AL_RING_MODULATOR_DEFAULT_WAVEFORM; effect->vtbl = &ALmodulator_vtable; break; case AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT: case AL_EFFECT_DEDICATED_DIALOGUE: - effect->Dedicated.Gain = 1.0f; + effect->Props.Dedicated.Gain = 1.0f; effect->vtbl = &ALdedicated_vtable; break; default: @@ -641,33 +641,33 @@ ALvoid LoadReverbPreset(const char *name, ALeffect *effect) TRACE("Loading reverb '%s'\n", reverblist[i].name); props = &reverblist[i].props; - effect->Reverb.Density = props->flDensity; - effect->Reverb.Diffusion = props->flDiffusion; - effect->Reverb.Gain = props->flGain; - effect->Reverb.GainHF = props->flGainHF; - effect->Reverb.GainLF = props->flGainLF; - effect->Reverb.DecayTime = props->flDecayTime; - effect->Reverb.DecayHFRatio = props->flDecayHFRatio; - effect->Reverb.DecayLFRatio = props->flDecayLFRatio; - effect->Reverb.ReflectionsGain = props->flReflectionsGain; - effect->Reverb.ReflectionsDelay = props->flReflectionsDelay; - effect->Reverb.ReflectionsPan[0] = props->flReflectionsPan[0]; - effect->Reverb.ReflectionsPan[1] = props->flReflectionsPan[1]; - effect->Reverb.ReflectionsPan[2] = props->flReflectionsPan[2]; - effect->Reverb.LateReverbGain = props->flLateReverbGain; - effect->Reverb.LateReverbDelay = props->flLateReverbDelay; - effect->Reverb.LateReverbPan[0] = props->flLateReverbPan[0]; - effect->Reverb.LateReverbPan[1] = props->flLateReverbPan[1]; - effect->Reverb.LateReverbPan[2] = props->flLateReverbPan[2]; - effect->Reverb.EchoTime = props->flEchoTime; - effect->Reverb.EchoDepth = props->flEchoDepth; - effect->Reverb.ModulationTime = props->flModulationTime; - effect->Reverb.ModulationDepth = props->flModulationDepth; - effect->Reverb.AirAbsorptionGainHF = props->flAirAbsorptionGainHF; - effect->Reverb.HFReference = props->flHFReference; - effect->Reverb.LFReference = props->flLFReference; - effect->Reverb.RoomRolloffFactor = props->flRoomRolloffFactor; - effect->Reverb.DecayHFLimit = props->iDecayHFLimit; + effect->Props.Reverb.Density = props->flDensity; + effect->Props.Reverb.Diffusion = props->flDiffusion; + effect->Props.Reverb.Gain = props->flGain; + effect->Props.Reverb.GainHF = props->flGainHF; + effect->Props.Reverb.GainLF = props->flGainLF; + effect->Props.Reverb.DecayTime = props->flDecayTime; + effect->Props.Reverb.DecayHFRatio = props->flDecayHFRatio; + effect->Props.Reverb.DecayLFRatio = props->flDecayLFRatio; + effect->Props.Reverb.ReflectionsGain = props->flReflectionsGain; + effect->Props.Reverb.ReflectionsDelay = props->flReflectionsDelay; + effect->Props.Reverb.ReflectionsPan[0] = props->flReflectionsPan[0]; + effect->Props.Reverb.ReflectionsPan[1] = props->flReflectionsPan[1]; + effect->Props.Reverb.ReflectionsPan[2] = props->flReflectionsPan[2]; + effect->Props.Reverb.LateReverbGain = props->flLateReverbGain; + effect->Props.Reverb.LateReverbDelay = props->flLateReverbDelay; + effect->Props.Reverb.LateReverbPan[0] = props->flLateReverbPan[0]; + effect->Props.Reverb.LateReverbPan[1] = props->flLateReverbPan[1]; + effect->Props.Reverb.LateReverbPan[2] = props->flLateReverbPan[2]; + effect->Props.Reverb.EchoTime = props->flEchoTime; + effect->Props.Reverb.EchoDepth = props->flEchoDepth; + effect->Props.Reverb.ModulationTime = props->flModulationTime; + effect->Props.Reverb.ModulationDepth = props->flModulationDepth; + effect->Props.Reverb.AirAbsorptionGainHF = props->flAirAbsorptionGainHF; + effect->Props.Reverb.HFReference = props->flHFReference; + effect->Props.Reverb.LFReference = props->flLFReference; + effect->Props.Reverb.RoomRolloffFactor = props->flRoomRolloffFactor; + effect->Props.Reverb.DecayHFLimit = props->iDecayHFLimit; return; } -- cgit v1.2.3 From 82caba6bbe251d50731785e529cd55a6ecf91664 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Sun, 26 May 2013 08:54:34 -0700 Subject: Use the helper macros in more places --- Alc/effects/chorus.c | 4 +- Alc/effects/echo.c | 45 ++++---- Alc/effects/equalizer.c | 100 ++++++---------- Alc/effects/flanger.c | 54 ++++----- Alc/effects/modulator.c | 33 +++--- Alc/effects/null.c | 48 ++++---- Alc/effects/reverb.c | 296 ++++++++++++++++++++---------------------------- 7 files changed, 237 insertions(+), 343 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index 783e5642..6a1a2d9c 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -301,8 +301,7 @@ void ALchorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALchorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) @@ -391,7 +390,6 @@ void ALchorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf default: SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); - break; } } void ALchorus_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index d1f734bf..8e4205fc 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -222,7 +222,7 @@ ALeffectStateFactory *ALechoStateFactory_getFactory(void) void ALecho_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) -{ (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } void ALecho_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { ALecho_SetParami(effect, context, param, vals[0]); @@ -233,43 +233,37 @@ void ALecho_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo switch(param) { case AL_ECHO_DELAY: - if(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY) - props->Echo.Delay = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Echo.Delay = val; break; case AL_ECHO_LRDELAY: - if(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY) - props->Echo.LRDelay = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Echo.LRDelay = val; break; case AL_ECHO_DAMPING: - if(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING) - props->Echo.Damping = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Echo.Damping = val; break; case AL_ECHO_FEEDBACK: - if(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK) - props->Echo.Feedback = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Echo.Feedback = val; break; case AL_ECHO_SPREAD: - if(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD) - props->Echo.Spread = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Echo.Spread = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALecho_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) @@ -278,7 +272,7 @@ void ALecho_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, cons } void ALecho_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) -{ (void)effect;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); } +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } void ALecho_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALecho_GetParami(effect, context, param, vals); @@ -309,8 +303,7 @@ void ALecho_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALecho_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index df95716f..441c785f 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -322,17 +322,7 @@ ALeffectStateFactory *ALequalizerStateFactory_getFactory(void) void ALequalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) -{ - ALeffectProps *props = &effect->Props; - switch(param) - { - default: - alSetError(context, AL_INVALID_ENUM); - break; - } - (void)props; - (void)val; -} +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } void ALequalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { ALequalizer_SetParami(effect, context, param, vals[0]); @@ -343,78 +333,67 @@ void ALequalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, switch(param) { case AL_EQUALIZER_LOW_GAIN: - if(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN) - props->Equalizer.LowGain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.LowGain = val; break; case AL_EQUALIZER_LOW_CUTOFF: - if(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF) - props->Equalizer.LowCutoff = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.LowCutoff = val; break; case AL_EQUALIZER_MID1_GAIN: - if(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN) - props->Equalizer.Mid1Gain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.Mid1Gain = val; break; case AL_EQUALIZER_MID1_CENTER: - if(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER) - props->Equalizer.Mid1Center = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.Mid1Center = val; break; case AL_EQUALIZER_MID1_WIDTH: - if(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH) - props->Equalizer.Mid1Width = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.Mid1Width = val; break; case AL_EQUALIZER_MID2_GAIN: - if(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN) - props->Equalizer.Mid2Gain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.Mid2Gain = val; break; case AL_EQUALIZER_MID2_CENTER: - if(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER) - props->Equalizer.Mid2Center = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.Mid2Center = val; break; case AL_EQUALIZER_MID2_WIDTH: - if(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH) - props->Equalizer.Mid2Width = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.Mid2Width = val; break; case AL_EQUALIZER_HIGH_GAIN: - if(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN) - props->Equalizer.HighGain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.HighGain = val; break; case AL_EQUALIZER_HIGH_CUTOFF: - if(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF) - props->Equalizer.HighCutoff = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Equalizer.HighCutoff = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALequalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) @@ -423,17 +402,7 @@ void ALequalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, } void ALequalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) -{ - ALeffectProps *props = &effect->Props; - switch(param) - { - default: - alSetError(context, AL_INVALID_ENUM); - break; - } - (void)props; - (void)val; -} +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } void ALequalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALequalizer_GetParami(effect, context, param, vals); @@ -484,8 +453,7 @@ void ALequalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALequalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index 1983c5e0..db8240ce 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -289,22 +289,19 @@ void ALflanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL switch(param) { case AL_FLANGER_WAVEFORM: - if(val >= AL_FLANGER_MIN_WAVEFORM && val <= AL_FLANGER_MAX_WAVEFORM) - props->Flanger.Waveform = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_FLANGER_MIN_WAVEFORM && val <= AL_FLANGER_MAX_WAVEFORM)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Flanger.Waveform = val; break; case AL_FLANGER_PHASE: - if(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE) - props->Flanger.Phase = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Flanger.Phase = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALflanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) @@ -317,36 +314,31 @@ void ALflanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL switch(param) { case AL_FLANGER_RATE: - if(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE) - props->Flanger.Rate = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Flanger.Rate = val; break; case AL_FLANGER_DEPTH: - if(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH) - props->Flanger.Depth = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Flanger.Depth = val; break; case AL_FLANGER_FEEDBACK: - if(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK) - props->Flanger.Feedback = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Flanger.Feedback = val; break; case AL_FLANGER_DELAY: - if(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY) - props->Flanger.Delay = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Flanger.Delay = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALflanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) @@ -368,8 +360,7 @@ void ALflanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALflanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) @@ -398,8 +389,7 @@ void ALflanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALflanger_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index bd994adb..a7b84d30 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -244,22 +244,19 @@ void ALmodulator_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, switch(param) { case AL_RING_MODULATOR_FREQUENCY: - if(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY) - props->Modulator.Frequency = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Modulator.HighPassCutoff = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Modulator.HighPassCutoff = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALmodulator_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) @@ -277,15 +274,13 @@ void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, break; case AL_RING_MODULATOR_WAVEFORM: - if(val >= AL_RING_MODULATOR_MIN_WAVEFORM && val <= AL_RING_MODULATOR_MAX_WAVEFORM) - props->Modulator.Waveform = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_RING_MODULATOR_MIN_WAVEFORM && val <= AL_RING_MODULATOR_MAX_WAVEFORM)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Modulator.Waveform = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALmodulator_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) @@ -309,8 +304,7 @@ void ALmodulator_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALmodulator_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) @@ -330,8 +324,7 @@ void ALmodulator_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALmodulator_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) diff --git a/Alc/effects/null.c b/Alc/effects/null.c index 3d617b64..aed19a82 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -102,84 +102,84 @@ ALeffectStateFactory *ALnullStateFactory_getFactory(void) void ALnull_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { + (void)effect; + (void)val; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)val; } void ALnull_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { + (void)effect; + (void)vals; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)vals; } void ALnull_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { + (void)effect; + (void)val; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)val; } void ALnull_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { + (void)effect; + (void)vals; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)vals; } void ALnull_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { + (void)effect; + (void)val; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)val; } void ALnull_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { + (void)effect; + (void)vals; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)vals; } void ALnull_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { + (void)effect; + (void)val; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)val; } void ALnull_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { + (void)effect; + (void)vals; switch(param) { default: - alSetError(context, AL_INVALID_ENUM); + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - (void)effect; - (void)vals; } DEFINE_ALEFFECT_VTABLE(ALnull); diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index b283b67f..380361e5 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1296,15 +1296,13 @@ void ALeaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, switch(param) { case AL_EAXREVERB_DECAY_HFLIMIT: - if(val >= AL_EAXREVERB_MIN_DECAY_HFLIMIT && val <= AL_EAXREVERB_MAX_DECAY_HFLIMIT) - props->Reverb.DecayHFLimit = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_DECAY_HFLIMIT && val <= AL_EAXREVERB_MAX_DECAY_HFLIMIT)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.DecayHFLimit = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALeaxreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) @@ -1317,148 +1315,127 @@ void ALeaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, switch(param) { case AL_EAXREVERB_DENSITY: - if(val >= AL_EAXREVERB_MIN_DENSITY && val <= AL_EAXREVERB_MAX_DENSITY) - props->Reverb.Density = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_DENSITY && val <= AL_EAXREVERB_MAX_DENSITY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.Density = val; break; case AL_EAXREVERB_DIFFUSION: - if(val >= AL_EAXREVERB_MIN_DIFFUSION && val <= AL_EAXREVERB_MAX_DIFFUSION) - props->Reverb.Diffusion = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_DIFFUSION && val <= AL_EAXREVERB_MAX_DIFFUSION)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.Diffusion = val; break; case AL_EAXREVERB_GAIN: - if(val >= AL_EAXREVERB_MIN_GAIN && val <= AL_EAXREVERB_MAX_GAIN) - props->Reverb.Gain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_GAIN && val <= AL_EAXREVERB_MAX_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.Gain = val; break; case AL_EAXREVERB_GAINHF: - if(val >= AL_EAXREVERB_MIN_GAINHF && val <= AL_EAXREVERB_MAX_GAINHF) - props->Reverb.GainHF = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_GAINHF && val <= AL_EAXREVERB_MAX_GAINHF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.GainHF = val; break; case AL_EAXREVERB_GAINLF: - if(val >= AL_EAXREVERB_MIN_GAINLF && val <= AL_EAXREVERB_MAX_GAINLF) - props->Reverb.GainLF = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_GAINLF && val <= AL_EAXREVERB_MAX_GAINLF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.GainLF = val; break; case AL_EAXREVERB_DECAY_TIME: - if(val >= AL_EAXREVERB_MIN_DECAY_TIME && val <= AL_EAXREVERB_MAX_DECAY_TIME) - props->Reverb.DecayTime = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_DECAY_TIME && val <= AL_EAXREVERB_MAX_DECAY_TIME)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.DecayTime = val; break; case AL_EAXREVERB_DECAY_HFRATIO: - if(val >= AL_EAXREVERB_MIN_DECAY_HFRATIO && val <= AL_EAXREVERB_MAX_DECAY_HFRATIO) - props->Reverb.DecayHFRatio = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_DECAY_HFRATIO && val <= AL_EAXREVERB_MAX_DECAY_HFRATIO)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.DecayHFRatio = val; break; case AL_EAXREVERB_DECAY_LFRATIO: - if(val >= AL_EAXREVERB_MIN_DECAY_LFRATIO && val <= AL_EAXREVERB_MAX_DECAY_LFRATIO) - props->Reverb.DecayLFRatio = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_DECAY_LFRATIO && val <= AL_EAXREVERB_MAX_DECAY_LFRATIO)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.DecayLFRatio = val; break; case AL_EAXREVERB_REFLECTIONS_GAIN: - if(val >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN && val <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN) - props->Reverb.ReflectionsGain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN && val <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.ReflectionsGain = val; break; case AL_EAXREVERB_REFLECTIONS_DELAY: - if(val >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY && val <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY) - props->Reverb.ReflectionsDelay = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY && val <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.LateReverbGain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN && val <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.LateReverbDelay = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY && val <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.AirAbsorptionGainHF = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.AirAbsorptionGainHF = val; break; case AL_EAXREVERB_ECHO_TIME: - if(val >= AL_EAXREVERB_MIN_ECHO_TIME && val <= AL_EAXREVERB_MAX_ECHO_TIME) - props->Reverb.EchoTime = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_ECHO_TIME && val <= AL_EAXREVERB_MAX_ECHO_TIME)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.EchoTime = val; break; case AL_EAXREVERB_ECHO_DEPTH: - if(val >= AL_EAXREVERB_MIN_ECHO_DEPTH && val <= AL_EAXREVERB_MAX_ECHO_DEPTH) - props->Reverb.EchoDepth = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_ECHO_DEPTH && val <= AL_EAXREVERB_MAX_ECHO_DEPTH)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.EchoDepth = val; break; case AL_EAXREVERB_MODULATION_TIME: - if(val >= AL_EAXREVERB_MIN_MODULATION_TIME && val <= AL_EAXREVERB_MAX_MODULATION_TIME) - props->Reverb.ModulationTime = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_MODULATION_TIME && val <= AL_EAXREVERB_MAX_MODULATION_TIME)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.ModulationTime = val; break; case AL_EAXREVERB_MODULATION_DEPTH: - if(val >= AL_EAXREVERB_MIN_MODULATION_DEPTH && val <= AL_EAXREVERB_MAX_MODULATION_DEPTH) - props->Reverb.ModulationDepth = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_MODULATION_DEPTH && val <= AL_EAXREVERB_MAX_MODULATION_DEPTH)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.ModulationDepth = val; break; case AL_EAXREVERB_HFREFERENCE: - if(val >= AL_EAXREVERB_MIN_HFREFERENCE && val <= AL_EAXREVERB_MAX_HFREFERENCE) - props->Reverb.HFReference = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_HFREFERENCE && val <= AL_EAXREVERB_MAX_HFREFERENCE)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.HFReference = val; break; case AL_EAXREVERB_LFREFERENCE: - if(val >= AL_EAXREVERB_MIN_LFREFERENCE && val <= AL_EAXREVERB_MAX_LFREFERENCE) - props->Reverb.LFReference = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_LFREFERENCE && val <= AL_EAXREVERB_MAX_LFREFERENCE)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.RoomRolloffFactor = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.RoomRolloffFactor = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) @@ -1467,28 +1444,22 @@ void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, switch(param) { case AL_EAXREVERB_REFLECTIONS_PAN: - if(isfinite(vals[0]) && isfinite(vals[1]) && isfinite(vals[2])) - { - LockContext(context); - props->Reverb.ReflectionsPan[0] = vals[0]; - props->Reverb.ReflectionsPan[1] = vals[1]; - props->Reverb.ReflectionsPan[2] = vals[2]; - UnlockContext(context); - } - else - alSetError(context, AL_INVALID_VALUE); + if(!(isfinite(vals[0]) && isfinite(vals[1]) && isfinite(vals[2]))) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + LockContext(context); + props->Reverb.ReflectionsPan[0] = vals[0]; + props->Reverb.ReflectionsPan[1] = vals[1]; + props->Reverb.ReflectionsPan[2] = vals[2]; + UnlockContext(context); break; case AL_EAXREVERB_LATE_REVERB_PAN: - if(isfinite(vals[0]) && isfinite(vals[1]) && isfinite(vals[2])) - { - LockContext(context); - props->Reverb.LateReverbPan[0] = vals[0]; - props->Reverb.LateReverbPan[1] = vals[1]; - props->Reverb.LateReverbPan[2] = vals[2]; - UnlockContext(context); - } - else - alSetError(context, AL_INVALID_VALUE); + if(!(isfinite(vals[0]) && isfinite(vals[1]) && isfinite(vals[2]))) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + LockContext(context); + props->Reverb.LateReverbPan[0] = vals[0]; + props->Reverb.LateReverbPan[1] = vals[1]; + props->Reverb.LateReverbPan[2] = vals[2]; + UnlockContext(context); break; default: @@ -1507,8 +1478,7 @@ void ALeaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALeaxreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) @@ -1601,8 +1571,7 @@ void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALeaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) @@ -1639,15 +1608,13 @@ void ALreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi switch(param) { case AL_REVERB_DECAY_HFLIMIT: - if(val >= AL_REVERB_MIN_DECAY_HFLIMIT && val <= AL_REVERB_MAX_DECAY_HFLIMIT) - props->Reverb.DecayHFLimit = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_DECAY_HFLIMIT && val <= AL_REVERB_MAX_DECAY_HFLIMIT)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.DecayHFLimit = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) @@ -1660,92 +1627,79 @@ void ALreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf switch(param) { case AL_REVERB_DENSITY: - if(val >= AL_REVERB_MIN_DENSITY && val <= AL_REVERB_MAX_DENSITY) - props->Reverb.Density = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_DENSITY && val <= AL_REVERB_MAX_DENSITY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.Density = val; break; case AL_REVERB_DIFFUSION: - if(val >= AL_REVERB_MIN_DIFFUSION && val <= AL_REVERB_MAX_DIFFUSION) - props->Reverb.Diffusion = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_DIFFUSION && val <= AL_REVERB_MAX_DIFFUSION)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.Diffusion = val; break; case AL_REVERB_GAIN: - if(val >= AL_REVERB_MIN_GAIN && val <= AL_REVERB_MAX_GAIN) - props->Reverb.Gain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_GAIN && val <= AL_REVERB_MAX_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.Gain = val; break; case AL_REVERB_GAINHF: - if(val >= AL_REVERB_MIN_GAINHF && val <= AL_REVERB_MAX_GAINHF) - props->Reverb.GainHF = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_GAINHF && val <= AL_REVERB_MAX_GAINHF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.GainHF = val; break; case AL_REVERB_DECAY_TIME: - if(val >= AL_REVERB_MIN_DECAY_TIME && val <= AL_REVERB_MAX_DECAY_TIME) - props->Reverb.DecayTime = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_DECAY_TIME && val <= AL_REVERB_MAX_DECAY_TIME)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.DecayTime = val; break; case AL_REVERB_DECAY_HFRATIO: - if(val >= AL_REVERB_MIN_DECAY_HFRATIO && val <= AL_REVERB_MAX_DECAY_HFRATIO) - props->Reverb.DecayHFRatio = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_DECAY_HFRATIO && val <= AL_REVERB_MAX_DECAY_HFRATIO)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.DecayHFRatio = val; break; case AL_REVERB_REFLECTIONS_GAIN: - if(val >= AL_REVERB_MIN_REFLECTIONS_GAIN && val <= AL_REVERB_MAX_REFLECTIONS_GAIN) - props->Reverb.ReflectionsGain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_REFLECTIONS_GAIN && val <= AL_REVERB_MAX_REFLECTIONS_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.ReflectionsGain = val; break; case AL_REVERB_REFLECTIONS_DELAY: - if(val >= AL_REVERB_MIN_REFLECTIONS_DELAY && val <= AL_REVERB_MAX_REFLECTIONS_DELAY) - props->Reverb.ReflectionsDelay = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_REFLECTIONS_DELAY && val <= AL_REVERB_MAX_REFLECTIONS_DELAY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.LateReverbGain = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_LATE_REVERB_GAIN && val <= AL_REVERB_MAX_LATE_REVERB_GAIN)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.LateReverbDelay = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_LATE_REVERB_DELAY && val <= AL_REVERB_MAX_LATE_REVERB_DELAY)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.AirAbsorptionGainHF = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + 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) - props->Reverb.RoomRolloffFactor = val; - else - alSetError(context, AL_INVALID_VALUE); + if(!(val >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR)) + SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE); + props->Reverb.RoomRolloffFactor = val; break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) @@ -1763,8 +1717,7 @@ void ALreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) @@ -1825,8 +1778,7 @@ void ALreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf break; default: - alSetError(context, AL_INVALID_ENUM); - break; + SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } void ALreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) -- cgit v1.2.3 From 0a4be3470e5cd48c95bef5a30a169ea671646132 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Sun, 26 May 2013 17:04:45 -0700 Subject: Pre-apply the a[0] EQ filter coefficient Saves 20 fp divisions per sample --- Alc/effects/equalizer.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 441c785f..f9744fb9 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -216,6 +216,12 @@ static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device state->bandfilter[it].a[2] = 1.0f - alpha / gain; break; } + state->bandfilter[it].b[0] /= state->bandfilter[it].a[0]; + state->bandfilter[it].b[1] /= state->bandfilter[it].a[0]; + state->bandfilter[it].b[2] /= state->bandfilter[it].a[0]; + state->bandfilter[it].a[0] /= state->bandfilter[it].a[0]; + state->bandfilter[it].a[1] /= state->bandfilter[it].a[0]; + state->bandfilter[it].a[2] /= state->bandfilter[it].a[0]; } } @@ -240,11 +246,11 @@ static ALvoid ALequalizerState_Process(ALequalizerState *state, ALuint SamplesTo { ALEQFilter *filter = &state->bandfilter[ft]; - tempsmp = filter->b[0] / filter->a[0] * smp + - filter->b[1] / filter->a[0] * filter->x[0] + - filter->b[2] / filter->a[0] * filter->x[1] - - filter->a[1] / filter->a[0] * filter->y[0] - - filter->a[2] / filter->a[0] * filter->y[1]; + tempsmp = filter->b[0] * smp + + filter->b[1] * filter->x[0] + + filter->b[2] * filter->x[1] - + filter->a[1] * filter->y[0] - + filter->a[2] * filter->y[1]; filter->x[1] = filter->x[0]; filter->x[0] = smp; -- cgit v1.2.3 From 06c8442af67fcb38241d2f13a649fc8d4dedaa85 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Sun, 26 May 2013 17:10:57 -0700 Subject: Rename a variable --- Alc/effects/equalizer.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index f9744fb9..1264e93c 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -240,23 +240,23 @@ static ALvoid ALequalizerState_Process(ALequalizerState *state, ALuint SamplesTo for(it = 0;it < td;it++) { ALfloat smp = SamplesIn[base+it]; - ALfloat tempsmp; for(ft = 0;ft < 4;ft++) { ALEQFilter *filter = &state->bandfilter[ft]; + ALfloat outsmp; - tempsmp = filter->b[0] * smp + - filter->b[1] * filter->x[0] + - filter->b[2] * filter->x[1] - - filter->a[1] * filter->y[0] - - filter->a[2] * filter->y[1]; + outsmp = filter->b[0] * smp + + filter->b[1] * filter->x[0] + + filter->b[2] * filter->x[1] - + filter->a[1] * filter->y[0] - + filter->a[2] * filter->y[1]; filter->x[1] = filter->x[0]; filter->x[0] = smp; filter->y[1] = filter->y[0]; - filter->y[0] = tempsmp; - smp = tempsmp; + filter->y[0] = outsmp; + smp = outsmp; } temps[it] = smp; -- cgit v1.2.3 From 334a7c1d59961277263a7a69575325aeef0987ee Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 27 May 2013 13:16:17 -0700 Subject: Cleanup the ALeffectStateFactory_create methods Get rid of the ALeffectStateFactory_create macro, and use the VCALL_NOARGS helper (requires adding the 'this' factory parameter). --- Alc/effects/chorus.c | 3 ++- Alc/effects/dedicated.c | 3 ++- Alc/effects/distortion.c | 3 ++- Alc/effects/echo.c | 3 ++- Alc/effects/equalizer.c | 3 ++- Alc/effects/flanger.c | 3 ++- Alc/effects/modulator.c | 3 ++- Alc/effects/null.c | 3 ++- Alc/effects/reverb.c | 3 ++- OpenAL32/Include/alAuxEffectSlot.h | 8 +++----- OpenAL32/alAuxEffectSlot.c | 4 ++-- 11 files changed, 23 insertions(+), 16 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index 6a1a2d9c..34caf62d 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -251,9 +251,10 @@ static void ALchorusState_Delete(ALchorusState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState); -static ALeffectState *ALchorusStateFactory_create(void) +static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *factory) { ALchorusState *state; + (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 9ed68af2..4d3485fb 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -93,10 +93,11 @@ static void ALdedicatedState_Delete(ALdedicatedState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState); -ALeffectState *ALdedicatedStateFactory_create(void) +ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *factory) { ALdedicatedState *state; ALsizei s; + (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index 950ce109..84440cce 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -242,9 +242,10 @@ static void ALdistortionState_Delete(ALdistortionState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState); -static ALeffectState *ALdistortionStateFactory_create(void) +static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *factory) { ALdistortionState *state; + (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 8e4205fc..b2b50836 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -183,9 +183,10 @@ static void ALechoState_Delete(ALechoState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALechoState); -ALeffectState *ALechoStateFactory_create(void) +ALeffectState *ALechoStateFactory_create(ALechoStateFactory *factory) { ALechoState *state; + (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 1264e93c..3a77c63f 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -284,10 +284,11 @@ static void ALequalizerState_Delete(ALequalizerState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState); -ALeffectState *ALequalizerStateFactory_create(void) +ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *factory) { ALequalizerState *state; int it; + (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index db8240ce..28499cd1 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -251,9 +251,10 @@ static void ALflangerState_Delete(ALflangerState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALflangerState); -ALeffectState *ALflangerStateFactory_create(void) +ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *factory) { ALflangerState *state; + (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index a7b84d30..0a8a4512 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -205,9 +205,10 @@ static void ALmodulatorState_Delete(ALmodulatorState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState); -static ALeffectState *ALmodulatorStateFactory_create(void) +static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *factory) { ALmodulatorState *state; + (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/null.c b/Alc/effects/null.c index aed19a82..f7262ca5 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -71,9 +71,10 @@ DEFINE_ALEFFECTSTATE_VTABLE(ALnullState); /* Creates ALeffectState objects of the appropriate type. */ -ALeffectState *ALnullStateFactory_create(void) +ALeffectState *ALnullStateFactory_create(ALnullStateFactory *factory) { ALnullState *state; + (void)factory; state = calloc(1, sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index 380361e5..7dcabe3a 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1182,10 +1182,11 @@ static void ALreverbState_Delete(ALreverbState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALreverbState); -static ALeffectState *ALreverbStateFactory_create(void) +static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory *factory) { ALreverbState *state; ALuint index; + (void)factory; state = malloc(sizeof(ALreverbState)); if(!state) return NULL; diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h index d496df8d..60724654 100644 --- a/OpenAL32/Include/alAuxEffectSlot.h +++ b/OpenAL32/Include/alAuxEffectSlot.h @@ -48,18 +48,16 @@ static const struct ALeffectStateVtable T##_ALeffectState_vtable = { \ struct ALeffectStateFactoryVtable { - ALeffectState *(*const create)(void); + ALeffectState *(*const create)(ALeffectStateFactory *factory); }; struct ALeffectStateFactory { const struct ALeffectStateFactoryVtable *vtbl; }; -#define ALeffectStateFactory_create(p) ((p)->vtbl->create()) - #define DEFINE_ALEFFECTSTATEFACTORY_VTABLE(T) \ -static ALeffectState* T##_ALeffectStateFactory_create(void) \ -{ return T##_create(); } \ +static ALeffectState* T##_ALeffectStateFactory_create(ALeffectStateFactory *factory) \ +{ return T##_create(STATIC_UPCAST(T, ALeffectStateFactory, factory)); } \ \ static const struct ALeffectStateFactoryVtable T##_ALeffectStateFactory_vtable = { \ T##_ALeffectStateFactory_create, \ diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c index 14dd8816..878597d9 100644 --- a/OpenAL32/alAuxEffectSlot.c +++ b/OpenAL32/alAuxEffectSlot.c @@ -486,7 +486,7 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e ERR("Failed to find factory for effect type 0x%04x\n", newtype); return AL_INVALID_ENUM; } - State = ALeffectStateFactory_create(factory); + State = VCALL_NOARGS(factory,create); if(!State) return AL_OUT_OF_MEMORY; @@ -548,7 +548,7 @@ ALenum InitEffectSlot(ALeffectslot *slot) slot->EffectType = AL_EFFECT_NULL; factory = getFactoryByType(AL_EFFECT_NULL); - if(!(slot->EffectState=ALeffectStateFactory_create(factory))) + if(!(slot->EffectState=VCALL_NOARGS(factory,create))) return AL_OUT_OF_MEMORY; slot->Gain = 1.0; -- cgit v1.2.3 From b1ae44206f66114fb7d3a76e912fbdeaeb792c7b Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 27 May 2013 15:32:02 -0700 Subject: Move ALEQFilter to alFilter.c/h and rename it to ALfilterState --- Alc/effects/equalizer.c | 117 ++++---------------------------------------- OpenAL32/Include/alFilter.h | 43 ++++++++++++++++ OpenAL32/alFilter.c | 78 +++++++++++++++++++++++++++++ 3 files changed, 131 insertions(+), 107 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 3a77c63f..9a1543e4 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -78,20 +78,6 @@ static ALequalizerStateFactory EqualizerFactory; * filter coefficients" by Robert Bristow-Johnson * * http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt */ -typedef enum ALEQFilterType { - LOW_SHELF, - HIGH_SHELF, - PEAKING -} ALEQFilterType; - -typedef struct ALEQFilter { - ALEQFilterType type; - ALfloat x[2]; /* History of two last input samples */ - ALfloat y[2]; /* History of two last output samples */ - ALfloat a[3]; /* Transfer function coefficients "a" */ - ALfloat b[3]; /* Transfer function coefficients "b" */ -} ALEQFilter; - typedef struct ALequalizerState { DERIVE_FROM_TYPE(ALeffectState); @@ -99,7 +85,7 @@ typedef struct ALequalizerState { ALfloat Gain[MaxChannels]; /* Effect parameters */ - ALEQFilter bandfilter[4]; + ALfilterState filter[4]; } ALequalizerState; static ALvoid ALequalizerState_Destruct(ALequalizerState *state) @@ -131,11 +117,10 @@ static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device /* Calculate coefficients for the each type of filter */ for(it = 0; it < 4; it++) { - ALfloat gain; + ALfilterType type = ALfilterType_Peaking; ALfloat filter_frequency; ALfloat bandwidth = 0.0f; - ALfloat w0; - ALfloat alpha = 0.0f; + ALfloat gain; /* convert linear gains to filter gains */ switch (it) @@ -143,85 +128,28 @@ static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device case 0: /* Low Shelf */ gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.LowGain)) / 40.0f); filter_frequency = slot->EffectProps.Equalizer.LowCutoff; + type = ALfilterType_LowShelf; break; case 1: /* Peaking */ gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.Mid1Gain)) / 40.0f); filter_frequency = slot->EffectProps.Equalizer.Mid1Center; bandwidth = slot->EffectProps.Equalizer.Mid1Width; + type = ALfilterType_Peaking; break; case 2: /* Peaking */ gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.Mid2Gain)) / 40.0f); filter_frequency = slot->EffectProps.Equalizer.Mid2Center; bandwidth = slot->EffectProps.Equalizer.Mid2Width; + type = ALfilterType_Peaking; break; case 3: /* High Shelf */ gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.HighGain)) / 40.0f); filter_frequency = slot->EffectProps.Equalizer.HighCutoff; + type = ALfilterType_HighShelf; break; } - w0 = 2.0f*F_PI * filter_frequency / frequency; - - /* Calculate filter coefficients depending on filter type */ - switch(state->bandfilter[it].type) - { - case LOW_SHELF: - alpha = sinf(w0) / 2.0f * sqrtf((gain + 1.0f / gain) * - (1.0f / 0.75f - 1.0f) + 2.0f); - state->bandfilter[it].b[0] = gain * ((gain + 1.0f) - - (gain - 1.0f) * cosf(w0) + - 2.0f * sqrtf(gain) * alpha); - state->bandfilter[it].b[1] = 2.0f * gain * ((gain - 1.0f) - - (gain + 1.0f) * cosf(w0)); - state->bandfilter[it].b[2] = gain * ((gain + 1.0f) - - (gain - 1.0f) * cosf(w0) - - 2.0f * sqrtf(gain) * alpha); - state->bandfilter[it].a[0] = (gain + 1.0f) + - (gain - 1.0f) * cosf(w0) + - 2.0f * sqrtf(gain) * alpha; - state->bandfilter[it].a[1] = -2.0f * ((gain - 1.0f) + - (gain + 1.0f) * cosf(w0)); - state->bandfilter[it].a[2] = (gain + 1.0f) + - (gain - 1.0f) * cosf(w0) - - 2.0f * sqrtf(gain) * alpha; - break; - case HIGH_SHELF: - alpha = sinf(w0) / 2.0f * sqrtf((gain + 1.0f / gain) * - (1.0f / 0.75f - 1.0f) + 2.0f); - state->bandfilter[it].b[0] = gain * ((gain + 1.0f) + - (gain - 1.0f) * cosf(w0) + - 2.0f * sqrtf(gain) * alpha); - state->bandfilter[it].b[1] = -2.0f * gain * ((gain - 1.0f) + - (gain + 1.0f) * - cosf(w0)); - state->bandfilter[it].b[2] = gain * ((gain + 1.0f) + - (gain - 1.0f) * cosf(w0) - - 2.0f * sqrtf(gain) * alpha); - state->bandfilter[it].a[0] = (gain + 1.0f) - - (gain - 1.0f) * cosf(w0) + - 2.0f * sqrtf(gain) * alpha; - state->bandfilter[it].a[1] = 2.0f * ((gain - 1.0f) - - (gain + 1.0f) * cosf(w0)); - state->bandfilter[it].a[2] = (gain + 1.0f) - - (gain - 1.0f) * cosf(w0) - - 2.0f * sqrtf(gain) * alpha; - break; - case PEAKING: - alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0)); - state->bandfilter[it].b[0] = 1.0f + alpha * gain; - state->bandfilter[it].b[1] = -2.0f * cosf(w0); - state->bandfilter[it].b[2] = 1.0f - alpha * gain; - state->bandfilter[it].a[0] = 1.0f + alpha / gain; - state->bandfilter[it].a[1] = -2.0f * cosf(w0); - state->bandfilter[it].a[2] = 1.0f - alpha / gain; - break; - } - state->bandfilter[it].b[0] /= state->bandfilter[it].a[0]; - state->bandfilter[it].b[1] /= state->bandfilter[it].a[0]; - state->bandfilter[it].b[2] /= state->bandfilter[it].a[0]; - state->bandfilter[it].a[0] /= state->bandfilter[it].a[0]; - state->bandfilter[it].a[1] /= state->bandfilter[it].a[0]; - state->bandfilter[it].a[2] /= state->bandfilter[it].a[0]; + ALfilterState_setParams(&state->filter[it], type, gain, filter_frequency/frequency, bandwidth); } } @@ -242,22 +170,7 @@ static ALvoid ALequalizerState_Process(ALequalizerState *state, ALuint SamplesTo ALfloat smp = SamplesIn[base+it]; for(ft = 0;ft < 4;ft++) - { - ALEQFilter *filter = &state->bandfilter[ft]; - ALfloat outsmp; - - outsmp = filter->b[0] * smp + - filter->b[1] * filter->x[0] + - filter->b[2] * filter->x[1] - - filter->a[1] * filter->y[0] - - filter->a[2] * filter->y[1]; - - filter->x[1] = filter->x[0]; - filter->x[0] = smp; - filter->y[1] = filter->y[0]; - filter->y[0] = outsmp; - smp = outsmp; - } + smp = ALfilterState_processSingle(&state->filter[ft], smp); temps[it] = smp; } @@ -294,20 +207,10 @@ ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *factory) if(!state) return NULL; SET_VTABLE2(ALequalizerState, ALeffectState, state); - state->bandfilter[0].type = LOW_SHELF; - state->bandfilter[1].type = PEAKING; - state->bandfilter[2].type = PEAKING; - state->bandfilter[3].type = HIGH_SHELF; - /* Initialize sample history only on filter creation to avoid */ /* sound clicks if filter settings were changed in runtime. */ for(it = 0; it < 4; it++) - { - state->bandfilter[it].x[0] = 0.0f; - state->bandfilter[it].x[1] = 0.0f; - state->bandfilter[it].y[0] = 0.0f; - state->bandfilter[it].y[1] = 0.0f; - } + ALfilterState_clear(&state->filter[it]); return STATIC_CAST(ALeffectState, state); } diff --git a/OpenAL32/Include/alFilter.h b/OpenAL32/Include/alFilter.h index 94feb3ee..f70b839e 100644 --- a/OpenAL32/Include/alFilter.h +++ b/OpenAL32/Include/alFilter.h @@ -46,6 +46,49 @@ static __inline ALfloat lpFilter2PC(const FILTER *iir, ALfloat input) ALfloat lpCoeffCalc(ALfloat g, ALfloat cw); +typedef enum ALfilterType { + ALfilterType_HighShelf, + ALfilterType_LowShelf, + ALfilterType_Peaking, +} ALfilterType; + +typedef struct ALfilterState { + ALfloat x[2]; /* History of two last input samples */ + ALfloat y[2]; /* History of two last output samples */ + ALfloat a[3]; /* Transfer function coefficients "a" */ + ALfloat b[3]; /* Transfer function coefficients "b" */ +} ALfilterState; + +void ALfilterState_clear(ALfilterState *filter); +void ALfilterState_setParams(ALfilterState *filter, ALfilterType type, ALfloat gain, ALfloat freq_scale, ALfloat bandwidth); + +static __inline ALfloat ALfilterState_processSingle(ALfilterState *filter, ALfloat sample) +{ + ALfloat outsmp; + + outsmp = filter->b[0] * sample + + filter->b[1] * filter->x[0] + + filter->b[2] * filter->x[1] - + filter->a[1] * filter->y[0] - + filter->a[2] * filter->y[1]; + filter->x[1] = filter->x[0]; + filter->x[0] = sample; + filter->y[1] = filter->y[0]; + filter->y[0] = outsmp; + + return outsmp; +} + +static __inline ALfloat ALfilterState_processSingleC(const ALfilterState *filter, ALfloat sample) +{ + return filter->b[0] * sample + + filter->b[1] * filter->x[0] + + filter->b[2] * filter->x[1] - + filter->a[1] * filter->y[0] - + filter->a[2] * filter->y[1]; +} + + typedef struct ALfilter { // Filter type (AL_FILTER_NULL, ...) ALenum type; diff --git a/OpenAL32/alFilter.c b/OpenAL32/alFilter.c index 312cf681..6b4ce633 100644 --- a/OpenAL32/alFilter.c +++ b/OpenAL32/alFilter.c @@ -325,6 +325,84 @@ AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *va } +void ALfilterState_clear(ALfilterState *filter) +{ + filter->x[0] = 0.0f; + filter->x[1] = 0.0f; + filter->y[0] = 0.0f; + filter->y[1] = 0.0f; +} + +void ALfilterState_setParams(ALfilterState *filter, ALfilterType type, ALfloat gain, ALfloat freq_scale, ALfloat bandwidth) +{ + ALfloat alpha; + ALfloat w0; + + w0 = 2.0f*F_PI * freq_scale; + + /* Calculate filter coefficients depending on filter type */ + switch(type) + { + case ALfilterType_HighShelf: + alpha = sinf(w0) / 2.0f * sqrtf((gain + 1.0f/gain) * + (1.0f/0.75f - 1.0f) + 2.0f); + filter->b[0] = gain * ((gain + 1.0f) + + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha); + filter->b[1] = -2.0f * gain * ((gain - 1.0f) + + (gain + 1.0f) * cosf(w0)); + filter->b[2] = gain * ((gain + 1.0f) + + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha); + filter->a[0] = (gain + 1.0f) - + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha; + filter->a[1] = 2.0f * ((gain - 1.0f) - + (gain + 1.0f) * cosf(w0)); + filter->a[2] = (gain + 1.0f) - + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha; + break; + case ALfilterType_LowShelf: + alpha = sinf(w0) / 2.0f * sqrtf((gain + 1.0f / gain) * + (1.0f / 0.75f - 1.0f) + 2.0f); + filter->b[0] = gain * ((gain + 1.0f) - + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha); + filter->b[1] = 2.0f * gain * ((gain - 1.0f) - + (gain + 1.0f) * cosf(w0)); + filter->b[2] = gain * ((gain + 1.0f) - + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha); + filter->a[0] = (gain + 1.0f) + + (gain - 1.0f) * cosf(w0) + + 2.0f * sqrtf(gain) * alpha; + filter->a[1] = -2.0f * ((gain - 1.0f) + + (gain + 1.0f) * cosf(w0)); + filter->a[2] = (gain + 1.0f) + + (gain - 1.0f) * cosf(w0) - + 2.0f * sqrtf(gain) * alpha; + break; + case ALfilterType_Peaking: + alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0)); + filter->b[0] = 1.0f + alpha * gain; + filter->b[1] = -2.0f * cosf(w0); + filter->b[2] = 1.0f - alpha * gain; + filter->a[0] = 1.0f + alpha / gain; + filter->a[1] = -2.0f * cosf(w0); + filter->a[2] = 1.0f - alpha / gain; + break; + } + + filter->b[0] /= filter->a[0]; + filter->b[1] /= filter->a[0]; + filter->b[2] /= filter->a[0]; + filter->a[0] /= filter->a[0]; + filter->a[1] /= filter->a[0]; + filter->a[2] /= filter->a[0]; +} + + ALfloat lpCoeffCalc(ALfloat g, ALfloat cw) { ALfloat a = 0.0f; -- cgit v1.2.3 From 6556626055e9985251ebd782c8551839e6d67ac5 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 27 May 2013 21:57:22 -0700 Subject: Simplify and fix some filter gain calculations --- Alc/ALu.c | 18 ++++++++++++------ Alc/effects/equalizer.c | 10 +++++----- 2 files changed, 17 insertions(+), 11 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/ALu.c b/Alc/ALu.c index 70b5c80a..57dfa30f 100644 --- a/Alc/ALu.c +++ b/Alc/ALu.c @@ -452,7 +452,7 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext) } { - ALfloat gain = maxf(0.001f, DryGainHF); + ALfloat gain = maxf(0.001f, sqrtf(DryGainHF)); for(c = 0;c < num_channels;c++) ALfilterState_setParams(&ALSource->Params.Direct.Filter[c], ALfilterType_LowPass, gain, @@ -460,7 +460,7 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext) } for(i = 0;i < NumSends;i++) { - ALfloat gain = maxf(0.001f, WetGainHF[i]); + ALfloat gain = maxf(0.001f, sqrtf(WetGainHF[i])); for(c = 0;c < num_channels;c++) ALfilterState_setParams(&ALSource->Params.Send[i].Filter[c], ALfilterType_LowPass, gain, @@ -901,13 +901,19 @@ ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext) ALSource->Params.Send[i].Gain = WetGain[i]; - ALfilterState_setParams(&ALSource->Params.Direct.Filter[0], - ALfilterType_LowPass, maxf(0.001f, DryGainHF), - (ALfloat)LOWPASSFREQREF/Frequency, 0.0f); + { + ALfloat gain = maxf(0.001f, sqrtf(DryGainHF)); + ALfilterState_setParams(&ALSource->Params.Direct.Filter[0], + ALfilterType_LowPass, gain, + (ALfloat)LOWPASSFREQREF/Frequency, 0.0f); + } for(i = 0;i < NumSends;i++) + { + ALfloat gain = maxf(0.001f, sqrtf(WetGainHF[i])); ALfilterState_setParams(&ALSource->Params.Send[i].Filter[0], - ALfilterType_LowPass, maxf(0.001f, WetGainHF[i]), + ALfilterType_LowPass, gain, (ALfloat)LOWPASSFREQREF/Frequency, 0.0f); + } } diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 9a1543e4..0a26cda7 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -123,27 +123,27 @@ static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device ALfloat gain; /* convert linear gains to filter gains */ - switch (it) + switch(it) { case 0: /* Low Shelf */ - gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.LowGain)) / 40.0f); + gain = sqrtf(slot->EffectProps.Equalizer.LowGain); filter_frequency = slot->EffectProps.Equalizer.LowCutoff; type = ALfilterType_LowShelf; break; case 1: /* Peaking */ - gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.Mid1Gain)) / 40.0f); + gain = sqrtf(slot->EffectProps.Equalizer.Mid1Gain); filter_frequency = slot->EffectProps.Equalizer.Mid1Center; bandwidth = slot->EffectProps.Equalizer.Mid1Width; type = ALfilterType_Peaking; break; case 2: /* Peaking */ - gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.Mid2Gain)) / 40.0f); + gain = sqrtf(slot->EffectProps.Equalizer.Mid2Gain); filter_frequency = slot->EffectProps.Equalizer.Mid2Center; bandwidth = slot->EffectProps.Equalizer.Mid2Width; type = ALfilterType_Peaking; break; case 3: /* High Shelf */ - gain = powf(10.0f, (20.0f * log10f(slot->EffectProps.Equalizer.HighGain)) / 40.0f); + gain = sqrtf(slot->EffectProps.Equalizer.HighGain); filter_frequency = slot->EffectProps.Equalizer.HighCutoff; type = ALfilterType_HighShelf; break; -- cgit v1.2.3 From 764e3aa4963c4fbfb08b313d93f6246b5d79b1b9 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Wed, 29 May 2013 11:17:45 -0700 Subject: Fix up the naming convention of effect methods --- Alc/ALc.c | 8 ++--- Alc/ALu.c | 8 ++--- Alc/effects/chorus.c | 30 +++++++++--------- Alc/effects/dedicated.c | 30 +++++++++--------- Alc/effects/distortion.c | 30 +++++++++--------- Alc/effects/echo.c | 30 +++++++++--------- Alc/effects/equalizer.c | 30 +++++++++--------- Alc/effects/flanger.c | 30 +++++++++--------- Alc/effects/modulator.c | 32 ++++++++++---------- Alc/effects/null.c | 22 +++++++------- Alc/effects/reverb.c | 62 +++++++++++++++++++------------------- OpenAL32/Include/alAuxEffectSlot.h | 27 +++++++++-------- OpenAL32/Include/alEffect.h | 26 ++++++++-------- OpenAL32/alAuxEffectSlot.c | 4 +-- OpenAL32/alEffect.c | 16 +++++----- OpenAL32/alState.c | 2 +- 16 files changed, 195 insertions(+), 192 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/ALc.c b/Alc/ALc.c index 975fe661..4d60278f 100644 --- a/Alc/ALc.c +++ b/Alc/ALc.c @@ -1707,7 +1707,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList) { ALeffectslot *slot = context->EffectSlotMap.array[pos].value; - if(VCALL(slot->EffectState,DeviceUpdate,(device)) == AL_FALSE) + if(VCALL(slot->EffectState,deviceUpdate,(device)) == AL_FALSE) { UnlockUIntMapRead(&context->EffectSlotMap); ALCdevice_Unlock(device); @@ -1715,7 +1715,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList) return ALC_INVALID_DEVICE; } slot->NeedsUpdate = AL_FALSE; - VCALL(slot->EffectState,Update,(device, slot)); + VCALL(slot->EffectState,update,(device, slot)); } UnlockUIntMapRead(&context->EffectSlotMap); @@ -1744,14 +1744,14 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList) { ALeffectslot *slot = device->DefaultSlot; - if(VCALL(slot->EffectState,DeviceUpdate,(device)) == AL_FALSE) + if(VCALL(slot->EffectState,deviceUpdate,(device)) == AL_FALSE) { ALCdevice_Unlock(device); RestoreFPUMode(&oldMode); return ALC_INVALID_DEVICE; } slot->NeedsUpdate = AL_FALSE; - VCALL(slot->EffectState,Update,(device, slot)); + VCALL(slot->EffectState,update,(device, slot)); } ALCdevice_Unlock(device); RestoreFPUMode(&oldMode); diff --git a/Alc/ALu.c b/Alc/ALu.c index 35ed986c..dd7392fc 100644 --- a/Alc/ALu.c +++ b/Alc/ALu.c @@ -1042,9 +1042,9 @@ ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size) (*slot)->PendingClicks[0] = 0.0f; if(!DeferUpdates && ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE)) - VCALL((*slot)->EffectState,Update,(device, *slot)); + VCALL((*slot)->EffectState,update,(device, *slot)); - VCALL((*slot)->EffectState,Process,(SamplesToDo, (*slot)->WetBuffer[0], + VCALL((*slot)->EffectState,process,(SamplesToDo, (*slot)->WetBuffer[0], device->DryBuffer)); for(i = 0;i < SamplesToDo;i++) @@ -1071,9 +1071,9 @@ ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size) (*slot)->PendingClicks[0] = 0.0f; if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE)) - VCALL((*slot)->EffectState,Update,(device, *slot)); + VCALL((*slot)->EffectState,update,(device, *slot)); - VCALL((*slot)->EffectState,Process,(SamplesToDo, (*slot)->WetBuffer[0], + VCALL((*slot)->EffectState,process,(SamplesToDo, (*slot)->WetBuffer[0], device->DryBuffer)); for(i = 0;i < SamplesToDo;i++) diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index 2c3aa742..cec6f435 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -66,7 +66,7 @@ static ALvoid ALchorusState_Destruct(ALchorusState *state) state->SampleBufferRight = NULL; } -static ALboolean ALchorusState_DeviceUpdate(ALchorusState *state, ALCdevice *Device) +static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device) { ALuint maxlen; ALuint it; @@ -98,7 +98,7 @@ static ALboolean ALchorusState_DeviceUpdate(ALchorusState *state, ALCdevice *Dev return AL_TRUE; } -static ALvoid ALchorusState_Update(ALchorusState *state, ALCdevice *Device, const ALeffectslot *Slot) +static ALvoid ALchorusState_update(ALchorusState *state, ALCdevice *Device, const ALeffectslot *Slot) { ALfloat frequency = (ALfloat)Device->Frequency; ALfloat rate; @@ -235,7 +235,7 @@ DECL_TEMPLATE(Sinusoid) #undef DECL_TEMPLATE -static ALvoid ALchorusState_Process(ALchorusState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALchorusState_process(ALchorusState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { if(state->waveform == AL_CHORUS_WAVEFORM_TRIANGLE) ProcessTriangle(state, SamplesToDo, SamplesIn, SamplesOut); @@ -284,7 +284,7 @@ ALeffectStateFactory *ALchorusStateFactory_getFactory(void) } -void ALchorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALchorus_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { ALeffectProps *props = &effect->Props; switch(param) @@ -305,11 +305,11 @@ void ALchorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALchorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALchorus_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALchorus_SetParami(effect, context, param, vals[0]); + ALchorus_setParami(effect, context, param, vals[0]); } -void ALchorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALchorus_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -342,12 +342,12 @@ void ALchorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALchorus_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALchorus_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALchorus_SetParamf(effect, context, param, vals[0]); + ALchorus_setParamf(effect, context, param, vals[0]); } -void ALchorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALchorus_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -364,11 +364,11 @@ void ALchorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALchorus_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALchorus_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALchorus_GetParami(effect, context, param, vals); + ALchorus_getParami(effect, context, param, vals); } -void ALchorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALchorus_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -393,9 +393,9 @@ void ALchorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALchorus_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALchorus_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALchorus_GetParamf(effect, context, param, vals); + ALchorus_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALchorus); diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 4d3485fb..8be7fee6 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -48,14 +48,14 @@ static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state) (void)state; } -static ALboolean ALdedicatedState_DeviceUpdate(ALdedicatedState *state, ALCdevice *Device) +static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *Device) { return AL_TRUE; (void)state; (void)Device; } -static ALvoid ALdedicatedState_Update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot) +static ALvoid ALdedicatedState_update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot) { ALfloat Gain; ALsizei s; @@ -70,7 +70,7 @@ static ALvoid ALdedicatedState_Update(ALdedicatedState *state, ALCdevice *device state->gains[LFE] = Gain; } -static ALvoid ALdedicatedState_Process(ALdedicatedState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { const ALfloat *gains = state->gains; ALuint i, c; @@ -125,13 +125,13 @@ ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void) } -void ALdedicated_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALdedicated_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALdedicated_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALdedicated_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALdedicated_SetParami(effect, context, param, vals[0]); + ALdedicated_setParami(effect, context, param, vals[0]); } -void ALdedicated_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALdedicated_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -146,18 +146,18 @@ void ALdedicated_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALdedicated_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALdedicated_SetParamf(effect, context, param, vals[0]); + ALdedicated_setParamf(effect, context, param, vals[0]); } -void ALdedicated_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALdedicated_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALdedicated_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALdedicated_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALdedicated_GetParami(effect, context, param, vals); + ALdedicated_getParami(effect, context, param, vals); } -void ALdedicated_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALdedicated_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -170,9 +170,9 @@ void ALdedicated_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALdedicated_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALdedicated_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALdedicated_GetParamf(effect, context, param, vals); + ALdedicated_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALdedicated); diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index 84440cce..4fd116f6 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -72,14 +72,14 @@ static ALvoid ALdistortionState_Destruct(ALdistortionState *state) (void)state; } -static ALboolean ALdistortionState_DeviceUpdate(ALdistortionState *state, ALCdevice *device) +static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *device) { return AL_TRUE; (void)state; (void)device; } -static ALvoid ALdistortionState_Update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot) +static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot) { ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain; ALfloat frequency = (ALfloat)Device->Frequency; @@ -132,7 +132,7 @@ static ALvoid ALdistortionState_Update(ALdistortionState *state, ALCdevice *Devi state->bandpass.a[2] = 1.0f - alpha; } -static ALvoid ALdistortionState_Process(ALdistortionState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALdistortionState_process(ALdistortionState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { const ALfloat fc = state->edge_coeff; float oversample_buffer[64][4]; @@ -280,13 +280,13 @@ ALeffectStateFactory *ALdistortionStateFactory_getFactory(void) } -void ALdistortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALdistortion_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALdistortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALdistortion_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALdistortion_SetParami(effect, context, param, vals[0]); + ALdistortion_setParami(effect, context, param, vals[0]); } -void ALdistortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALdistortion_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -325,18 +325,18 @@ void ALdistortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALdistortion_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALdistortion_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALdistortion_SetParamf(effect, context, param, vals[0]); + ALdistortion_setParamf(effect, context, param, vals[0]); } -void ALdistortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALdistortion_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALdistortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALdistortion_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALdistortion_GetParami(effect, context, param, vals); + ALdistortion_getParami(effect, context, param, vals); } -void ALdistortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALdistortion_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -365,9 +365,9 @@ void ALdistortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALdistortion_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALdistortion_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALdistortion_GetParamf(effect, context, param, vals); + ALdistortion_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALdistortion); diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 9d17ead0..29087439 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -63,7 +63,7 @@ static ALvoid ALechoState_Destruct(ALechoState *state) state->SampleBuffer = NULL; } -static ALboolean ALechoState_DeviceUpdate(ALechoState *state, ALCdevice *Device) +static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device) { ALuint maxlen, i; @@ -89,7 +89,7 @@ static ALboolean ALechoState_DeviceUpdate(ALechoState *state, ALCdevice *Device) return AL_TRUE; } -static ALvoid ALechoState_Update(ALechoState *state, ALCdevice *Device, const ALeffectslot *Slot) +static ALvoid ALechoState_update(ALechoState *state, ALCdevice *Device, const ALeffectslot *Slot) { ALuint frequency = Device->Frequency; ALfloat lrpan, gain; @@ -124,7 +124,7 @@ static ALvoid ALechoState_Update(ALechoState *state, ALCdevice *Device, const AL ComputeAngleGains(Device, atan2f(+lrpan, 0.0f), (1.0f-dirGain)*F_PI, gain, state->Gain[1]); } -static ALvoid ALechoState_Process(ALechoState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALechoState_process(ALechoState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { const ALuint mask = state->BufferLength-1; const ALuint tap1 = state->Tap[0].delay; @@ -220,13 +220,13 @@ ALeffectStateFactory *ALechoStateFactory_getFactory(void) } -void ALecho_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALecho_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALecho_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALecho_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALecho_SetParami(effect, context, param, vals[0]); + ALecho_setParami(effect, context, param, vals[0]); } -void ALecho_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALecho_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -265,18 +265,18 @@ void ALecho_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALecho_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALecho_SetParamf(effect, context, param, vals[0]); + ALecho_setParamf(effect, context, param, vals[0]); } -void ALecho_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALecho_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALecho_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALecho_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALecho_GetParami(effect, context, param, vals); + ALecho_getParami(effect, context, param, vals); } -void ALecho_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALecho_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -305,9 +305,9 @@ void ALecho_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALecho_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALecho_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALecho_GetParamf(effect, context, param, vals); + ALecho_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALecho); diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 0a26cda7..467dbbbc 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -93,14 +93,14 @@ static ALvoid ALequalizerState_Destruct(ALequalizerState *state) (void)state; } -static ALboolean ALequalizerState_DeviceUpdate(ALequalizerState *state, ALCdevice *device) +static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *device) { return AL_TRUE; (void)state; (void)device; } -static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot) +static ALvoid ALequalizerState_update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot) { ALfloat frequency = (ALfloat)device->Frequency; ALfloat gain = sqrtf(1.0f / device->NumChan) * slot->Gain; @@ -153,7 +153,7 @@ static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device } } -static ALvoid ALequalizerState_Process(ALequalizerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALequalizerState_process(ALequalizerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { ALuint base; ALuint it; @@ -231,13 +231,13 @@ ALeffectStateFactory *ALequalizerStateFactory_getFactory(void) } -void ALequalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALequalizer_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALequalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALequalizer_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALequalizer_SetParami(effect, context, param, vals[0]); + ALequalizer_setParami(effect, context, param, vals[0]); } -void ALequalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALequalizer_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -306,18 +306,18 @@ void ALequalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALequalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALequalizer_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALequalizer_SetParamf(effect, context, param, vals[0]); + ALequalizer_setParamf(effect, context, param, vals[0]); } -void ALequalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALequalizer_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } -void ALequalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALequalizer_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALequalizer_GetParami(effect, context, param, vals); + ALequalizer_getParami(effect, context, param, vals); } -void ALequalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALequalizer_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -366,9 +366,9 @@ void ALequalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALequalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALequalizer_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALequalizer_GetParamf(effect, context, param, vals); + ALequalizer_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALequalizer); diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index 86b067d5..e9de888a 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -66,7 +66,7 @@ static ALvoid ALflangerState_Destruct(ALflangerState *state) state->SampleBufferRight = NULL; } -static ALboolean ALflangerState_DeviceUpdate(ALflangerState *state, ALCdevice *Device) +static ALboolean ALflangerState_deviceUpdate(ALflangerState *state, ALCdevice *Device) { ALuint maxlen; ALuint it; @@ -98,7 +98,7 @@ static ALboolean ALflangerState_DeviceUpdate(ALflangerState *state, ALCdevice *D return AL_TRUE; } -static ALvoid ALflangerState_Update(ALflangerState *state, ALCdevice *Device, const ALeffectslot *Slot) +static ALvoid ALflangerState_update(ALflangerState *state, ALCdevice *Device, const ALeffectslot *Slot) { ALfloat frequency = (ALfloat)Device->Frequency; ALfloat rate; @@ -235,7 +235,7 @@ DECL_TEMPLATE(Sinusoid) #undef DECL_TEMPLATE -static ALvoid ALflangerState_Process(ALflangerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALflangerState_process(ALflangerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { if(state->waveform == AL_FLANGER_WAVEFORM_TRIANGLE) ProcessTriangle(state, SamplesToDo, SamplesIn, SamplesOut); @@ -284,7 +284,7 @@ ALeffectStateFactory *ALflangerStateFactory_getFactory(void) } -void ALflanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALflanger_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { ALeffectProps *props = &effect->Props; switch(param) @@ -305,11 +305,11 @@ void ALflanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALflanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALflanger_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALflanger_SetParami(effect, context, param, vals[0]); + ALflanger_setParami(effect, context, param, vals[0]); } -void ALflanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALflanger_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -342,12 +342,12 @@ void ALflanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALflanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALflanger_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALflanger_SetParamf(effect, context, param, vals[0]); + ALflanger_setParamf(effect, context, param, vals[0]); } -void ALflanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALflanger_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -364,11 +364,11 @@ void ALflanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALflanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALflanger_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALflanger_GetParami(effect, context, param, vals); + ALflanger_getParami(effect, context, param, vals); } -void ALflanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALflanger_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -393,9 +393,9 @@ void ALflanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALflanger_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALflanger_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALflanger_GetParamf(effect, context, param, vals); + ALflanger_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALflanger); diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index d253614c..356f0fd6 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -126,14 +126,14 @@ static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state) (void)state; } -static ALboolean ALmodulatorState_DeviceUpdate(ALmodulatorState *state, ALCdevice *Device) +static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *Device) { return AL_TRUE; (void)state; (void)Device; } -static ALvoid ALmodulatorState_Update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot) +static ALvoid ALmodulatorState_update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot) { ALfloat gain, cw, a; ALuint index; @@ -172,7 +172,7 @@ static ALvoid ALmodulatorState_Update(ALmodulatorState *state, ALCdevice *Device } } -static ALvoid ALmodulatorState_Process(ALmodulatorState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { switch(state->Waveform) { @@ -231,7 +231,7 @@ ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void) } -void ALmodulator_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALmodulator_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -252,18 +252,18 @@ void ALmodulator_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALmodulator_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALmodulator_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALmodulator_SetParamf(effect, context, param, vals[0]); + ALmodulator_setParamf(effect, context, param, vals[0]); } -void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +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); + ALmodulator_setParamf(effect, context, param, (ALfloat)val); break; case AL_RING_MODULATOR_WAVEFORM: @@ -276,12 +276,12 @@ void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALmodulator_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALmodulator_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALmodulator_SetParami(effect, context, param, vals[0]); + ALmodulator_setParami(effect, context, param, vals[0]); } -void ALmodulator_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALmodulator_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -300,11 +300,11 @@ void ALmodulator_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALmodulator_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALmodulator_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALmodulator_GetParami(effect, context, param, vals); + ALmodulator_getParami(effect, context, param, vals); } -void ALmodulator_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALmodulator_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { ALeffectProps *props = &effect->Props; switch(param) @@ -320,9 +320,9 @@ void ALmodulator_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALmodulator_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALmodulator_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALmodulator_GetParamf(effect, context, param, vals); + ALmodulator_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALmodulator); diff --git a/Alc/effects/null.c b/Alc/effects/null.c index f7262ca5..fe9ea41d 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -31,7 +31,7 @@ static ALvoid ALnullState_Destruct(ALnullState *state) * initialization and any time the device parameters (eg. playback frequency, * format) have been changed. */ -static ALboolean ALnullState_DeviceUpdate(ALnullState *state, ALCdevice *device) +static ALboolean ALnullState_deviceUpdate(ALnullState *state, ALCdevice *device) { return AL_TRUE; (void)state; @@ -41,7 +41,7 @@ static ALboolean ALnullState_DeviceUpdate(ALnullState *state, ALCdevice *device) /* This updates the effect state. This is called any time the effect is * (re)loaded into a slot. */ -static ALvoid ALnullState_Update(ALnullState *state, ALCdevice *device, const ALeffectslot *slot) +static ALvoid ALnullState_update(ALnullState *state, ALCdevice *device, const ALeffectslot *slot) { (void)state; (void)device; @@ -52,7 +52,7 @@ static ALvoid ALnullState_Update(ALnullState *state, ALCdevice *device, const AL * input to the output buffer. The result should be added to the output buffer, * not replace it. */ -static ALvoid ALnullState_Process(ALnullState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]) +static ALvoid ALnullState_process(ALnullState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]) { (void)state; (void)samplesToDo; @@ -101,7 +101,7 @@ ALeffectStateFactory *ALnullStateFactory_getFactory(void) } -void ALnull_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALnull_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { (void)effect; (void)val; @@ -111,7 +111,7 @@ void ALnull_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALnull_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { (void)effect; (void)vals; @@ -121,7 +121,7 @@ void ALnull_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, cons SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALnull_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { (void)effect; (void)val; @@ -131,7 +131,7 @@ void ALnull_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALnull_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { (void)effect; (void)vals; @@ -142,7 +142,7 @@ void ALnull_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, cons } } -void ALnull_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALnull_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { (void)effect; (void)val; @@ -152,7 +152,7 @@ void ALnull_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALnull_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { (void)effect; (void)vals; @@ -162,7 +162,7 @@ void ALnull_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALin SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALnull_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { (void)effect; (void)val; @@ -172,7 +172,7 @@ void ALnull_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALnull_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { (void)effect; (void)vals; diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index e17a0833..1fb30610 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -561,7 +561,7 @@ static inline ALvoid EAXVerbPass(ALreverbState *State, ALfloat in, ALfloat *rest State->Offset++; } -static ALvoid ALreverbState_ProcessStandard(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALreverbState_processStandard(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { ALfloat (*restrict out)[4] = State->ReverbSamples; ALuint index, c; @@ -581,7 +581,7 @@ static ALvoid ALreverbState_ProcessStandard(ALreverbState *State, ALuint Samples } } -static ALvoid ALreverbState_ProcessEax(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALreverbState_processEax(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { ALfloat (*restrict early)[4] = State->EarlySamples; ALfloat (*restrict late)[4] = State->ReverbSamples; @@ -609,12 +609,12 @@ static ALvoid ALreverbState_ProcessEax(ALreverbState *State, ALuint SamplesToDo, } } -static ALvoid ALreverbState_Process(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) +static ALvoid ALreverbState_process(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) { if(State->IsEax) - ALreverbState_ProcessEax(State, SamplesToDo, SamplesIn, SamplesOut); + ALreverbState_processEax(State, SamplesToDo, SamplesIn, SamplesOut); else - ALreverbState_ProcessStandard(State, SamplesToDo, SamplesIn, SamplesOut); + ALreverbState_processStandard(State, SamplesToDo, SamplesIn, SamplesOut); } // Given the allocated sample buffer, this function updates each delay line @@ -731,7 +731,7 @@ static ALboolean AllocLines(ALuint frequency, ALreverbState *State) return AL_TRUE; } -static ALboolean ALreverbState_DeviceUpdate(ALreverbState *State, ALCdevice *Device) +static ALboolean ALreverbState_deviceUpdate(ALreverbState *State, ALCdevice *Device) { ALuint frequency = Device->Frequency, index; @@ -1080,7 +1080,7 @@ static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *Reflection lerp(ambientGain, 1.0f, dirGain) * Gain, State->Late.PanGain); } -static ALvoid ALreverbState_Update(ALreverbState *State, ALCdevice *Device, const ALeffectslot *Slot) +static ALvoid ALreverbState_update(ALreverbState *State, ALCdevice *Device, const ALeffectslot *Slot) { ALuint frequency = Device->Frequency; ALfloat freq_scale, cw, x, y, hfRatio; @@ -1291,7 +1291,7 @@ ALeffectStateFactory *ALreverbStateFactory_getFactory(void) } -void ALeaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALeaxreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { ALeffectProps *props = &effect->Props; switch(param) @@ -1306,11 +1306,11 @@ void ALeaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALeaxreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALeaxreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALeaxreverb_SetParami(effect, context, param, vals[0]); + ALeaxreverb_setParami(effect, context, param, vals[0]); } -void ALeaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALeaxreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -1439,7 +1439,7 @@ void ALeaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALeaxreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { ALeffectProps *props = &effect->Props; switch(param) @@ -1464,12 +1464,12 @@ void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, break; default: - ALeaxreverb_SetParamf(effect, context, param, vals[0]); + ALeaxreverb_setParamf(effect, context, param, vals[0]); break; } } -void ALeaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALeaxreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1482,11 +1482,11 @@ void ALeaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALeaxreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALeaxreverb_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALeaxreverb_GetParami(effect, context, param, vals); + ALeaxreverb_getParami(effect, context, param, vals); } -void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALeaxreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1575,7 +1575,7 @@ void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALeaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALeaxreverb_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1596,14 +1596,14 @@ void ALeaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, break; default: - ALeaxreverb_GetParamf(effect, context, param, vals); + ALeaxreverb_getParamf(effect, context, param, vals); break; } } DEFINE_ALEFFECT_VTABLE(ALeaxreverb); -void ALreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) { ALeffectProps *props = &effect->Props; switch(param) @@ -1618,11 +1618,11 @@ void ALreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { - ALreverb_SetParami(effect, context, param, vals[0]); + ALreverb_setParami(effect, context, param, vals[0]); } -void ALreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; switch(param) @@ -1703,12 +1703,12 @@ void ALreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { - ALreverb_SetParamf(effect, context, param, vals[0]); + ALreverb_setParamf(effect, context, param, vals[0]); } -void ALreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1721,11 +1721,11 @@ void ALreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALreverb_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { - ALreverb_GetParami(effect, context, param, vals); + ALreverb_getParami(effect, context, param, vals); } -void ALreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1782,9 +1782,9 @@ void ALreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALreverb_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { - ALreverb_GetParamf(effect, context, param, vals); + ALreverb_getParamf(effect, context, param, vals); } DEFINE_ALEFFECT_VTABLE(ALreverb); diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h index 60724654..463a6770 100644 --- a/OpenAL32/Include/alAuxEffectSlot.h +++ b/OpenAL32/Include/alAuxEffectSlot.h @@ -15,9 +15,10 @@ typedef struct ALeffectslot ALeffectslot; struct ALeffectStateVtable { ALvoid (*const Destruct)(ALeffectState *state); - ALboolean (*const DeviceUpdate)(ALeffectState *state, ALCdevice *device); - ALvoid (*const Update)(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot); - ALvoid (*const Process)(ALeffectState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]); + + ALboolean (*const deviceUpdate)(ALeffectState *state, ALCdevice *device); + ALvoid (*const update)(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot); + ALvoid (*const process)(ALeffectState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]); void (*const Delete)(ALeffectState *state); }; @@ -29,20 +30,22 @@ struct ALeffectState { #define DEFINE_ALEFFECTSTATE_VTABLE(T) \ static ALvoid T##_ALeffectState_Destruct(ALeffectState *state) \ { T##_Destruct(STATIC_UPCAST(T, ALeffectState, state)); } \ -static ALboolean T##_ALeffectState_DeviceUpdate(ALeffectState *state, ALCdevice *device) \ -{ return T##_DeviceUpdate(STATIC_UPCAST(T, ALeffectState, state), device); } \ -static ALvoid T##_ALeffectState_Update(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot) \ -{ T##_Update(STATIC_UPCAST(T, ALeffectState, state), device, slot); } \ -static ALvoid T##_ALeffectState_Process(ALeffectState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]) \ -{ T##_Process(STATIC_UPCAST(T, ALeffectState, state), samplesToDo, samplesIn, samplesOut); } \ +static ALboolean T##_ALeffectState_deviceUpdate(ALeffectState *state, ALCdevice *device) \ +{ return T##_deviceUpdate(STATIC_UPCAST(T, ALeffectState, state), device); } \ +static ALvoid T##_ALeffectState_update(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot) \ +{ T##_update(STATIC_UPCAST(T, ALeffectState, state), device, slot); } \ +static ALvoid T##_ALeffectState_process(ALeffectState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]) \ +{ T##_process(STATIC_UPCAST(T, ALeffectState, state), samplesToDo, samplesIn, samplesOut); } \ static ALvoid T##_ALeffectState_Delete(ALeffectState *state) \ { T##_Delete(STATIC_UPCAST(T, ALeffectState, state)); } \ \ static const struct ALeffectStateVtable T##_ALeffectState_vtable = { \ T##_ALeffectState_Destruct, \ - T##_ALeffectState_DeviceUpdate, \ - T##_ALeffectState_Update, \ - T##_ALeffectState_Process, \ + \ + T##_ALeffectState_deviceUpdate, \ + T##_ALeffectState_update, \ + T##_ALeffectState_process, \ + \ T##_ALeffectState_Delete, \ } diff --git a/OpenAL32/Include/alEffect.h b/OpenAL32/Include/alEffect.h index a1b430e9..8b7b612f 100644 --- a/OpenAL32/Include/alEffect.h +++ b/OpenAL32/Include/alEffect.h @@ -28,23 +28,23 @@ extern ALfloat ReverbBoost; extern ALboolean EmulateEAXReverb; struct ALeffectVtable { - void (*const SetParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint val); - void (*const SetParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); - void (*const SetParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); - void (*const SetParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); - - void (*const GetParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); - void (*const GetParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); - void (*const GetParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); - void (*const GetParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); + void (*const setParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint val); + void (*const setParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals); + void (*const setParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); + void (*const setParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); + + void (*const getParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); + void (*const getParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); + void (*const getParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); + void (*const getParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); }; #define DEFINE_ALEFFECT_VTABLE(T) \ const struct ALeffectVtable T##_vtable = { \ - T##_SetParami, T##_SetParamiv, \ - T##_SetParamf, T##_SetParamfv, \ - T##_GetParami, T##_GetParamiv, \ - T##_GetParamf, T##_GetParamfv, \ + T##_setParami, T##_setParamiv, \ + T##_setParamf, T##_setParamfv, \ + T##_getParami, T##_getParamiv, \ + T##_getParamf, T##_getParamfv, \ } extern const struct ALeffectVtable ALeaxreverb_vtable; diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c index 99cac58e..b3d0d826 100644 --- a/OpenAL32/alAuxEffectSlot.c +++ b/OpenAL32/alAuxEffectSlot.c @@ -496,7 +496,7 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e SetMixerFPUMode(&oldMode); ALCdevice_Lock(Device); - if(VCALL(State,DeviceUpdate,(Device)) == AL_FALSE) + if(VCALL(State,deviceUpdate,(Device)) == AL_FALSE) { ALCdevice_Unlock(Device); RestoreFPUMode(&oldMode); @@ -520,7 +520,7 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e * object was changed, it needs an update before its Process method can * be called. */ EffectSlot->NeedsUpdate = AL_FALSE; - VCALL(EffectSlot->EffectState,Update,(Device, EffectSlot)); + VCALL(EffectSlot->EffectState,update,(Device, EffectSlot)); ALCdevice_Unlock(Device); RestoreFPUMode(&oldMode); diff --git a/OpenAL32/alEffect.c b/OpenAL32/alEffect.c index 425d2b60..b67e34ae 100644 --- a/OpenAL32/alEffect.c +++ b/OpenAL32/alEffect.c @@ -167,7 +167,7 @@ AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value) else { /* Call the appropriate handler */ - VCALL(ALEffect,SetParami,(Context, param, value)); + VCALL(ALEffect,setParami,(Context, param, value)); } } @@ -196,7 +196,7 @@ AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *v else { /* Call the appropriate handler */ - VCALL(ALEffect,SetParamiv,(Context, param, values)); + VCALL(ALEffect,setParamiv,(Context, param, values)); } ALCcontext_DecRef(Context); @@ -217,7 +217,7 @@ AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat value) else { /* Call the appropriate handler */ - VCALL(ALEffect,SetParamf,(Context, param, value)); + VCALL(ALEffect,setParamf,(Context, param, value)); } ALCcontext_DecRef(Context); @@ -238,7 +238,7 @@ AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat else { /* Call the appropriate handler */ - VCALL(ALEffect,SetParamfv,(Context, param, values)); + VCALL(ALEffect,setParamfv,(Context, param, values)); } ALCcontext_DecRef(Context); @@ -263,7 +263,7 @@ AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *value else { /* Call the appropriate handler */ - VCALL(ALEffect,GetParami,(Context, param, value)); + VCALL(ALEffect,getParami,(Context, param, value)); } } @@ -292,7 +292,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *valu else { /* Call the appropriate handler */ - VCALL(ALEffect,GetParamiv,(Context, param, values)); + VCALL(ALEffect,getParamiv,(Context, param, values)); } ALCcontext_DecRef(Context); @@ -313,7 +313,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *val else { /* Call the appropriate handler */ - VCALL(ALEffect,GetParamf,(Context, param, value)); + VCALL(ALEffect,getParamf,(Context, param, value)); } ALCcontext_DecRef(Context); @@ -334,7 +334,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *va else { /* Call the appropriate handler */ - VCALL(ALEffect,GetParamfv,(Context, param, values)); + VCALL(ALEffect,getParamfv,(Context, param, values)); } ALCcontext_DecRef(Context); diff --git a/OpenAL32/alState.c b/OpenAL32/alState.c index ab39afed..f56dc98d 100644 --- a/OpenAL32/alState.c +++ b/OpenAL32/alState.c @@ -625,7 +625,7 @@ AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void) while(slot != slot_end) { if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE)) - VCALL((*slot)->EffectState,Update,(Context->Device, *slot)); + VCALL((*slot)->EffectState,update,(Context->Device, *slot)); slot++; } -- cgit v1.2.3 From a7a3d1e1947186f86cb4bdcfbeea0970d2726683 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Wed, 29 May 2013 22:34:57 -0700 Subject: Avoid an unnecessary loop --- Alc/effects/equalizer.c | 55 +++++++++++++++++-------------------------------- 1 file changed, 19 insertions(+), 36 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 467dbbbc..fd79462f 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -115,42 +115,25 @@ static ALvoid ALequalizerState_update(ALequalizerState *state, ALCdevice *device } /* Calculate coefficients for the each type of filter */ - for(it = 0; it < 4; it++) - { - ALfilterType type = ALfilterType_Peaking; - ALfloat filter_frequency; - ALfloat bandwidth = 0.0f; - ALfloat gain; - - /* convert linear gains to filter gains */ - switch(it) - { - case 0: /* Low Shelf */ - gain = sqrtf(slot->EffectProps.Equalizer.LowGain); - filter_frequency = slot->EffectProps.Equalizer.LowCutoff; - type = ALfilterType_LowShelf; - break; - case 1: /* Peaking */ - gain = sqrtf(slot->EffectProps.Equalizer.Mid1Gain); - filter_frequency = slot->EffectProps.Equalizer.Mid1Center; - bandwidth = slot->EffectProps.Equalizer.Mid1Width; - type = ALfilterType_Peaking; - break; - case 2: /* Peaking */ - gain = sqrtf(slot->EffectProps.Equalizer.Mid2Gain); - filter_frequency = slot->EffectProps.Equalizer.Mid2Center; - bandwidth = slot->EffectProps.Equalizer.Mid2Width; - type = ALfilterType_Peaking; - break; - case 3: /* High Shelf */ - gain = sqrtf(slot->EffectProps.Equalizer.HighGain); - filter_frequency = slot->EffectProps.Equalizer.HighCutoff; - type = ALfilterType_HighShelf; - break; - } - - ALfilterState_setParams(&state->filter[it], type, gain, filter_frequency/frequency, bandwidth); - } + ALfilterState_setParams(&state->filter[0], ALfilterType_LowShelf, + sqrtf(slot->EffectProps.Equalizer.LowGain), + slot->EffectProps.Equalizer.LowCutoff/frequency, + 0.0f); + + ALfilterState_setParams(&state->filter[1], ALfilterType_Peaking, + sqrtf(slot->EffectProps.Equalizer.Mid1Gain), + slot->EffectProps.Equalizer.Mid1Center/frequency, + slot->EffectProps.Equalizer.Mid1Width); + + ALfilterState_setParams(&state->filter[2], ALfilterType_Peaking, + sqrtf(slot->EffectProps.Equalizer.Mid2Gain), + slot->EffectProps.Equalizer.Mid2Center/frequency, + slot->EffectProps.Equalizer.Mid2Width); + + ALfilterState_setParams(&state->filter[3], ALfilterType_HighShelf, + sqrtf(slot->EffectProps.Equalizer.HighGain), + slot->EffectProps.Equalizer.HighCutoff/frequency, + 0.0f); } static ALvoid ALequalizerState_process(ALequalizerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) -- cgit v1.2.3 From 764ea95781486f86c7be956e84cf97ab893ac07b Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Thu, 3 Oct 2013 05:02:16 -0700 Subject: Use helpers to set channel gain arrays Also avoid unnecessary clearing. --- Alc/effects/autowah.c | 17 ++++------------- Alc/effects/chorus.c | 7 ------- Alc/effects/dedicated.c | 7 ++++--- Alc/effects/distortion.c | 14 ++++---------- Alc/effects/echo.c | 7 ------- Alc/effects/equalizer.c | 9 +-------- Alc/effects/flanger.c | 7 ------- Alc/effects/modulator.c | 12 ++---------- Alc/effects/reverb.c | 18 ++---------------- Alc/panning.c | 12 +++++------- OpenAL32/Include/alu.h | 19 ++++++++++++++++++- 11 files changed, 40 insertions(+), 89 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c index cc207858..e0556cf3 100644 --- a/Alc/effects/autowah.c +++ b/Alc/effects/autowah.c @@ -80,16 +80,12 @@ static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *d static ALvoid ALautowahState_update(ALautowahState *state, ALCdevice *Device, const ALeffectslot *Slot) { - ALuint i; - ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain; - - /* computing high-pass cutoff and bandwidth */ const ALfloat cutoff = LOWPASSFREQREF / (Device->Frequency * 4.0f); const ALfloat bandwidth = (cutoff / 2.0f) / (cutoff * 0.67f); + ALfloat gain; /* computing high-pass filter coefficients */ - ALfilterState_setParams(&state->high_pass, - ALfilterType_HighPass, 1.0f, + ALfilterState_setParams(&state->high_pass, ALfilterType_HighPass, 1.0f, cutoff, bandwidth); state->AttackTime = Slot->EffectProps.Autowah.AttackTime; @@ -102,13 +98,8 @@ static ALvoid ALautowahState_update(ALautowahState *state, ALCdevice *Device, co ALfilterState_clear(&state->low_pass); - for(i = 0;i < MaxChannels;i++) - state->Gain[i] = 0.0f; - for(i = 0;i < Device->NumChan;i++) - { - enum Channel chan = Device->Speaker2Chan[i]; - state->Gain[chan] = gain; - } + gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain; + SetGains(Device, gain, state->Gain); } static ALvoid ALautowahState_process(ALautowahState *state, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[BUFFERSIZE]) diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index cec6f435..ba664268 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -103,13 +103,6 @@ static ALvoid ALchorusState_update(ALchorusState *state, ALCdevice *Device, cons ALfloat frequency = (ALfloat)Device->Frequency; ALfloat rate; ALint phase; - ALuint it; - - for (it = 0; it < MaxChannels; it++) - { - state->Gain[0][it] = 0.0f; - state->Gain[1][it] = 0.0f; - } state->waveform = Slot->EffectProps.Chorus.Waveform; state->depth = Slot->EffectProps.Chorus.Depth; diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 8be7fee6..2aa08953 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -61,13 +61,14 @@ static ALvoid ALdedicatedState_update(ALdedicatedState *state, ALCdevice *device ALsizei s; Gain = Slot->Gain * Slot->EffectProps.Dedicated.Gain; - for(s = 0;s < MaxChannels;s++) - state->gains[s] = 0.0f; - if(Slot->EffectType == AL_EFFECT_DEDICATED_DIALOGUE) ComputeAngleGains(device, atan2f(0.0f, 1.0f), 0.0f, Gain, state->gains); else if(Slot->EffectType == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT) + { + for(s = 0;s < MaxChannels;s++) + state->gains[s] = 0.0f; state->gains[LFE] = Gain; + } } static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index dce0d64d..768d1ee2 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -64,20 +64,11 @@ static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdev static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot) { - ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain; ALfloat frequency = (ALfloat)Device->Frequency; - ALuint it; ALfloat bandwidth; ALfloat cutoff; ALfloat edge; - - for(it = 0;it < MaxChannels;it++) - state->Gain[it] = 0.0f; - for(it = 0;it < Device->NumChan;it++) - { - enum Channel chan = Device->Speaker2Chan[it]; - state->Gain[chan] = gain; - } + ALfloat gain; /* Store distorted signal attenuation settings */ state->attenuation = Slot->EffectProps.Distortion.Gain; @@ -100,6 +91,9 @@ static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Devi bandwidth = Slot->EffectProps.Distortion.EQBandwidth / (cutoff * 0.67f); ALfilterState_setParams(&state->bandpass, ALfilterType_BandPass, 1.0f, cutoff / (frequency*4.0f), bandwidth); + + gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain; + SetGains(Device, gain, state->Gain); } static ALvoid ALdistortionState_process(ALdistortionState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 6d6d70fb..8a457162 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -93,7 +93,6 @@ static ALvoid ALechoState_update(ALechoState *state, ALCdevice *Device, const AL ALuint frequency = Device->Frequency; ALfloat lrpan, gain; ALfloat dirGain; - ALuint i; state->Tap[0].delay = fastf2u(Slot->EffectProps.Echo.Delay * frequency) + 1; state->Tap[1].delay = fastf2u(Slot->EffectProps.Echo.LRDelay * frequency); @@ -108,12 +107,6 @@ static ALvoid ALechoState_update(ALechoState *state, ALCdevice *Device, const AL (ALfloat)LOWPASSFREQREF/frequency, 0.0f); gain = Slot->Gain; - for(i = 0;i < MaxChannels;i++) - { - state->Gain[0][i] = 0.0f; - state->Gain[1][i] = 0.0f; - } - dirGain = fabsf(lrpan); /* First tap panning */ diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index fd79462f..3fd0b0f7 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -104,15 +104,8 @@ static ALvoid ALequalizerState_update(ALequalizerState *state, ALCdevice *device { ALfloat frequency = (ALfloat)device->Frequency; ALfloat gain = sqrtf(1.0f / device->NumChan) * slot->Gain; - ALuint it; - for(it = 0;it < MaxChannels;it++) - state->Gain[it] = 0.0f; - for(it = 0; it < device->NumChan; it++) - { - enum Channel chan = device->Speaker2Chan[it]; - state->Gain[chan] = gain; - } + SetGains(device, gain, state->Gain); /* Calculate coefficients for the each type of filter */ ALfilterState_setParams(&state->filter[0], ALfilterType_LowShelf, diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index e9de888a..6b1a84ad 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -103,13 +103,6 @@ static ALvoid ALflangerState_update(ALflangerState *state, ALCdevice *Device, co ALfloat frequency = (ALfloat)Device->Frequency; ALfloat rate; ALint phase; - ALuint it; - - for(it = 0;it < MaxChannels;it++) - { - state->Gain[0][it] = 0.0f; - state->Gain[1][it] = 0.0f; - } state->waveform = Slot->EffectProps.Flanger.Waveform; state->depth = Slot->EffectProps.Flanger.Depth; diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index 356f0fd6..a77a42df 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -136,7 +136,6 @@ static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevic static ALvoid ALmodulatorState_update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot) { ALfloat gain, cw, a; - ALuint index; if(Slot->EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SINUSOID) state->Waveform = SINUSOID; @@ -161,15 +160,8 @@ static ALvoid ALmodulatorState_update(ALmodulatorState *state, ALCdevice *Device state->Filter.a[1] = -a; state->Filter.a[2] = 0.0f; - gain = sqrtf(1.0f/Device->NumChan); - gain *= Slot->Gain; - for(index = 0;index < MaxChannels;index++) - state->Gain[index] = 0.0f; - for(index = 0;index < Device->NumChan;index++) - { - enum Channel chan = Device->Speaker2Chan[index]; - state->Gain[chan] = gain; - } + gain = sqrtf(1.0f/Device->NumChan) * Slot->Gain; + SetGains(Device, gain, state->Gain); } static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE]) diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index 5758a09e..261a1f7f 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1044,7 +1044,6 @@ static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *Reflection ALfloat ambientGain; ALfloat dirGain; ALfloat length; - ALuint index; Gain *= ReverbBoost; @@ -1070,14 +1069,10 @@ static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *Reflection } dirGain = sqrtf(earlyPan[0]*earlyPan[0] + earlyPan[2]*earlyPan[2]); - for(index = 0;index < MaxChannels;index++) - State->Early.PanGain[index] = 0.0f; ComputeAngleGains(Device, atan2f(earlyPan[0], earlyPan[2]), (1.0f-dirGain)*F_PI, lerp(ambientGain, 1.0f, dirGain) * Gain, State->Early.PanGain); dirGain = sqrtf(latePan[0]*latePan[0] + latePan[2]*latePan[2]); - for(index = 0;index < MaxChannels;index++) - State->Late.PanGain[index] = 0.0f; ComputeAngleGains(Device, atan2f(latePan[0], latePan[2]), (1.0f-dirGain)*F_PI, lerp(ambientGain, 1.0f, dirGain) * Gain, State->Late.PanGain); } @@ -1168,18 +1163,9 @@ static ALvoid ALreverbState_update(ALreverbState *State, ALCdevice *Device, cons } else { - ALfloat gain = Slot->Gain; - ALuint index; - /* Update channel gains */ - gain *= sqrtf(2.0f/Device->NumChan) * ReverbBoost; - for(index = 0;index < MaxChannels;index++) - State->Gain[index] = 0.0f; - for(index = 0;index < Device->NumChan;index++) - { - enum Channel chan = Device->Speaker2Chan[index]; - State->Gain[chan] = gain; - } + ALfloat gain = sqrtf(2.0f/Device->NumChan) * ReverbBoost * Slot->Gain; + SetGains(Device, gain, State->Gain); } } diff --git a/Alc/panning.c b/Alc/panning.c index 02387336..188844e6 100644 --- a/Alc/panning.c +++ b/Alc/panning.c @@ -140,13 +140,7 @@ static void SetSpeakerArrangement(const char *name, ALfloat SpeakerAngle[MaxChan } -/** - * ComputeAngleGains - * - * Sets channel gains based on a given source's angle and its half-width. The - * angle and hwidth parameters are in radians. - */ -ALvoid ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, ALfloat ingain, ALfloat *gains) +void ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, ALfloat ingain, ALfloat gains[MaxChannels]) { ALfloat tmpgains[MaxChannels] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; enum Channel Speaker2Chan[MaxChannels]; @@ -164,6 +158,8 @@ ALvoid ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, if(device->NumChan <= 1 || hwidth >= F_PI) { /* Full coverage for all speakers. */ + for(i = 0;i < MaxChannels;i++) + gains[i] = 0.0f; for(i = 0;i < device->NumChan;i++) { enum Channel chan = Speaker2Chan[i]; @@ -174,6 +170,8 @@ ALvoid ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, if(hwidth <= 0.0f) { /* Infinitely small sound point. */ + for(i = 0;i < MaxChannels;i++) + gains[i] = 0.0f; for(i = 0;i < device->NumChan-1;i++) { if(angle >= SpeakerAngle[i] && angle < SpeakerAngle[i+1]) diff --git a/OpenAL32/Include/alu.h b/OpenAL32/Include/alu.h index b389ec1e..076abea6 100644 --- a/OpenAL32/Include/alu.h +++ b/OpenAL32/Include/alu.h @@ -105,7 +105,24 @@ static inline ALfloat cubic(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat va ALvoid aluInitPanning(ALCdevice *Device); -ALvoid ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, ALfloat ingain, ALfloat *gains); +/** + * ComputeAngleGains + * + * Sets channel gains based on a given source's angle and its half-width. The + * angle and hwidth parameters are in radians. + */ +void ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, ALfloat ingain, ALfloat gains[MaxChannels]); + +/** + * SetGains + * + * Helper to set the appropriate channels to the specified gain. + */ +static inline void SetGains(const ALCdevice *device, ALfloat ingain, ALfloat gains[MaxChannels]) +{ + ComputeAngleGains(device, 0.0f, F_PI, ingain, gains); +} + ALvoid CalcSourceParams(struct ALsource *ALSource, const ALCcontext *ALContext); ALvoid CalcNonAttnSourceParams(struct ALsource *ALSource, const ALCcontext *ALContext); -- cgit v1.2.3 From 79edd2cf3b46b22d3e6c57aec11b942809f24ff3 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Sun, 6 Oct 2013 17:25:47 -0700 Subject: Use a macro for the silence threshold --- Alc/effects/autowah.c | 2 +- Alc/effects/chorus.c | 4 ++-- Alc/effects/compressor.c | 2 +- Alc/effects/dedicated.c | 2 +- Alc/effects/distortion.c | 2 +- Alc/effects/echo.c | 4 ++-- Alc/effects/equalizer.c | 2 +- Alc/effects/flanger.c | 4 ++-- Alc/effects/modulator.c | 2 +- Alc/effects/reverb.c | 19 ++++++++++--------- Alc/mixer_c.c | 4 ++-- Alc/mixer_sse.c | 4 ++-- OpenAL32/Include/alu.h | 2 ++ 13 files changed, 28 insertions(+), 25 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c index 298eb7f0..ffec3c9c 100644 --- a/Alc/effects/autowah.c +++ b/Alc/effects/autowah.c @@ -155,7 +155,7 @@ static ALvoid ALautowahState_process(ALautowahState *state, ALuint SamplesToDo, for(kt = 0;kt < MaxChannels;kt++) { ALfloat gain = state->Gain[kt]; - if(!(gain > 0.00001f)) + if(!(gain > GAIN_SILENCE_THRESHOLD)) continue; for(it = 0;it < td;it++) diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index ba664268..8fc82a7f 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -203,14 +203,14 @@ static void Process##func(ALchorusState *state, ALuint SamplesToDo, \ for(kt = 0;kt < MaxChannels;kt++) \ { \ ALfloat gain = state->Gain[0][kt]; \ - if(gain > 0.00001f) \ + if(gain > GAIN_SILENCE_THRESHOLD) \ { \ for(it = 0;it < td;it++) \ SamplesOut[kt][it+base] += temps[it][0] * gain; \ } \ \ gain = state->Gain[1][kt]; \ - if(gain > 0.00001f) \ + if(gain > GAIN_SILENCE_THRESHOLD) \ { \ for(it = 0;it < td;it++) \ SamplesOut[kt][it+base] += temps[it][1] * gain; \ diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c index 6c3ab425..46673f45 100644 --- a/Alc/effects/compressor.c +++ b/Alc/effects/compressor.c @@ -117,7 +117,7 @@ static ALvoid ALcompressorState_process(ALcompressorState *state, ALuint Samples for(kt = 0;kt < MaxChannels;kt++) { ALfloat gain = state->Gain[kt] * envgain * 2.0f; - if(!(gain > 0.00001f)) + if(!(gain > GAIN_SILENCE_THRESHOLD)) continue; for(it = 0;it < td;it++) diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 2aa08953..5a9842fa 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -78,7 +78,7 @@ static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALuint SamplesTo for(c = 0;c < MaxChannels;c++) { - if(!(gains[c] > 0.00001f)) + if(!(gains[c] > GAIN_SILENCE_THRESHOLD)) continue; for(i = 0;i < SamplesToDo;i++) diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index 768d1ee2..9a18ad46 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -169,7 +169,7 @@ static ALvoid ALdistortionState_process(ALdistortionState *state, ALuint Samples for(kt = 0;kt < MaxChannels;kt++) { ALfloat gain = state->Gain[kt]; - if(!(gain > 0.00001f)) + if(!(gain > GAIN_SILENCE_THRESHOLD)) continue; for(it = 0;it < td;it++) diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 8a457162..a9110e35 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -148,14 +148,14 @@ static ALvoid ALechoState_process(ALechoState *state, ALuint SamplesToDo, const for(k = 0;k < MaxChannels;k++) { ALfloat gain = state->Gain[0][k]; - if(gain > 0.00001f) + if(gain > GAIN_SILENCE_THRESHOLD) { for(i = 0;i < td;i++) SamplesOut[k][i+base] += temps[i][0] * gain; } gain = state->Gain[1][k]; - if(gain > 0.00001f) + if(gain > GAIN_SILENCE_THRESHOLD) { for(i = 0;i < td;i++) SamplesOut[k][i+base] += temps[i][1] * gain; diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 3fd0b0f7..b7bfa0a2 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -154,7 +154,7 @@ static ALvoid ALequalizerState_process(ALequalizerState *state, ALuint SamplesTo for(kt = 0;kt < MaxChannels;kt++) { ALfloat gain = state->Gain[kt]; - if(!(gain > 0.00001f)) + if(!(gain > GAIN_SILENCE_THRESHOLD)) continue; for(it = 0;it < td;it++) diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index 6b1a84ad..0107afed 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -203,14 +203,14 @@ static void Process##func(ALflangerState *state, ALuint SamplesToDo, \ for(kt = 0;kt < MaxChannels;kt++) \ { \ ALfloat gain = state->Gain[0][kt]; \ - if(gain > 0.00001f) \ + if(gain > GAIN_SILENCE_THRESHOLD) \ { \ for(it = 0;it < td;it++) \ SamplesOut[kt][it+base] += temps[it][0] * gain; \ } \ \ gain = state->Gain[1][kt]; \ - if(gain > 0.00001f) \ + if(gain > GAIN_SILENCE_THRESHOLD) \ { \ for(it = 0;it < td;it++) \ SamplesOut[kt][it+base] += temps[it][1] * gain; \ diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index a77a42df..b71070f5 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -102,7 +102,7 @@ static void Process##func(ALmodulatorState *state, ALuint SamplesToDo, \ for(k = 0;k < MaxChannels;k++) \ { \ ALfloat gain = state->Gain[k]; \ - if(!(gain > 0.00001f)) \ + if(!(gain > GAIN_SILENCE_THRESHOLD)) \ continue; \ \ for(i = 0;i < td;i++) \ diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index 261a1f7f..4c65e0a6 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -575,11 +575,11 @@ static ALvoid ALreverbState_processStandard(ALreverbState *State, ALuint Samples for(c = 0;c < MaxChannels;c++) { ALfloat gain = State->Gain[c]; - if(gain > 0.00001f) - { - for(index = 0;index < SamplesToDo;index++) - SamplesOut[c][index] += gain * out[index][c&3]; - } + if(!(gain > GAIN_SILENCE_THRESHOLD)) + continue; + + for(index = 0;index < SamplesToDo;index++) + SamplesOut[c][index] += gain * out[index][c&3]; } } @@ -595,15 +595,16 @@ static ALvoid ALreverbState_processEax(ALreverbState *State, ALuint SamplesToDo, for(c = 0;c < MaxChannels;c++) { - ALfloat earlyGain = State->Early.PanGain[c]; - ALfloat lateGain = State->Late.PanGain[c]; + ALfloat earlyGain, lateGain; - if(earlyGain > 0.00001f) + earlyGain = State->Early.PanGain[c]; + if(earlyGain > GAIN_SILENCE_THRESHOLD) { for(index = 0;index < SamplesToDo;index++) SamplesOut[c][index] += earlyGain*early[index][c&3]; } - if(lateGain > 0.00001f) + lateGain = State->Late.PanGain[c]; + if(lateGain > GAIN_SILENCE_THRESHOLD) { for(index = 0;index < SamplesToDo;index++) SamplesOut[c][index] += lateGain*late[index][c&3]; diff --git a/Alc/mixer_c.c b/Alc/mixer_c.c index 168aa43f..da3f8318 100644 --- a/Alc/mixer_c.c +++ b/Alc/mixer_c.c @@ -96,7 +96,7 @@ void MixDirect_C(const DirectParams *params, const ALfloat *restrict data, ALuin for(c = 0;c < MaxChannels;c++) { DrySend = params->Gains[srcchan][c]; - if(!(DrySend > 0.00001f)) + if(!(DrySend > GAIN_SILENCE_THRESHOLD)) continue; if(OutPos == 0) @@ -119,7 +119,7 @@ void MixSend_C(const SendParams *params, const ALfloat *restrict data, ALuint pos; WetSend = params->Gain; - if(!(WetSend > 0.00001f)) + if(!(WetSend > GAIN_SILENCE_THRESHOLD)) return; if(OutPos == 0) diff --git a/Alc/mixer_sse.c b/Alc/mixer_sse.c index cd8ea299..56a4bdae 100644 --- a/Alc/mixer_sse.c +++ b/Alc/mixer_sse.c @@ -154,7 +154,7 @@ void MixDirect_SSE(const DirectParams *params, const ALfloat *restrict data, ALu for(c = 0;c < MaxChannels;c++) { DrySend = params->Gains[srcchan][c]; - if(!(DrySend > 0.00001f)) + if(!(DrySend > GAIN_SILENCE_THRESHOLD)) continue; if(OutPos == 0) @@ -188,7 +188,7 @@ void MixSend_SSE(const SendParams *params, const ALfloat *restrict data, ALuint pos; WetGain = params->Gain; - if(!(WetGain > 0.00001f)) + if(!(WetGain > GAIN_SILENCE_THRESHOLD)) return; if(OutPos == 0) diff --git a/OpenAL32/Include/alu.h b/OpenAL32/Include/alu.h index 076abea6..7327d85b 100644 --- a/OpenAL32/Include/alu.h +++ b/OpenAL32/Include/alu.h @@ -43,6 +43,8 @@ typedef ALvoid (*WetMixerFunc)(const struct SendParams *params, ALuint BufferSize); +#define GAIN_SILENCE_THRESHOLD (0.00001f) + #define SPEEDOFSOUNDMETRESPERSEC (343.3f) #define AIRABSORBGAINHF (0.99426f) /* -0.05dB */ -- cgit v1.2.3 From 997f6228ded27f868ffa9ca99dd544d559a92cf5 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 7 Oct 2013 08:34:54 -0700 Subject: Use the UNUSED macro in the effects --- Alc/effects/autowah.c | 18 +++++++--------- Alc/effects/chorus.c | 3 +-- Alc/effects/compressor.c | 14 ++++++------- Alc/effects/dedicated.c | 18 +++++++--------- Alc/effects/distortion.c | 18 +++++++--------- Alc/effects/echo.c | 11 +++++----- Alc/effects/equalizer.c | 18 +++++++--------- Alc/effects/flanger.c | 3 +-- Alc/effects/modulator.c | 10 +++------ Alc/effects/null.c | 54 ++++++++++++++---------------------------------- Alc/effects/reverb.c | 3 +-- 11 files changed, 60 insertions(+), 110 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c index ffec3c9c..e6e45273 100644 --- a/Alc/effects/autowah.c +++ b/Alc/effects/autowah.c @@ -66,16 +66,13 @@ typedef struct ALautowahState { ALfilterState high_pass; } ALautowahState; -static ALvoid ALautowahState_Destruct(ALautowahState *state) +static ALvoid ALautowahState_Destruct(ALautowahState *UNUSED(state)) { - (void)state; } -static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *device) +static ALboolean ALautowahState_deviceUpdate(ALautowahState *UNUSED(state), ALCdevice *UNUSED(device)) { return AL_TRUE; - (void)state; - (void)device; } static ALvoid ALautowahState_update(ALautowahState *state, ALCdevice *Device, const ALeffectslot *Slot) @@ -174,10 +171,9 @@ static void ALautowahState_Delete(ALautowahState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALautowahState); -static ALeffectState *ALautowahStateFactory_create(ALautowahStateFactory *factory) +static ALeffectState *ALautowahStateFactory_create(ALautowahStateFactory *UNUSED(factory)) { ALautowahState *state; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; @@ -198,8 +194,8 @@ ALeffectStateFactory *ALautowahStateFactory_getFactory(void) } -void ALautowah_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALautowah_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALautowah_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { ALautowah_setParami(effect, context, param, vals[0]); @@ -244,8 +240,8 @@ void ALautowah_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, c ALautowah_setParamf(effect, context, param, vals[0]); } -void ALautowah_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALautowah_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALautowah_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALautowah_getParami(effect, context, param, vals); diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index 8fc82a7f..9e889847 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -244,10 +244,9 @@ static void ALchorusState_Delete(ALchorusState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState); -static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *factory) +static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(factory)) { ALchorusState *state; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c index 46673f45..4bee76ce 100644 --- a/Alc/effects/compressor.c +++ b/Alc/effects/compressor.c @@ -47,9 +47,8 @@ typedef struct ALcompressorState { ALfloat Release; } ALcompressorState; -static ALvoid ALcompressorState_Destruct(ALcompressorState *state) +static ALvoid ALcompressorState_Destruct(ALcompressorState *UNUSED(state)) { - (void)state; } static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device) @@ -139,10 +138,9 @@ static void ALcompressorState_Delete(ALcompressorState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState); -static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *factory) +static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *UNUSED(factory)) { ALcompressorState *state; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; @@ -181,8 +179,8 @@ void ALcompressor_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param ALcompressor_setParami(effect, context, param, vals[0]); } -void ALcompressor_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) -{SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val;} +void ALcompressor_setParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALcompressor_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { @@ -205,8 +203,8 @@ void ALcompressor_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param { ALcompressor_getParami(effect, context, param, vals); } -void ALcompressor_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) -{SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val;} +void ALcompressor_getParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALcompressor_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 5a9842fa..3ce41978 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -43,16 +43,13 @@ typedef struct ALdedicatedState { } ALdedicatedState; -static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state) +static ALvoid ALdedicatedState_Destruct(ALdedicatedState *UNUSED(state)) { - (void)state; } -static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *Device) +static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *UNUSED(state), ALCdevice *UNUSED(device)) { return AL_TRUE; - (void)state; - (void)Device; } static ALvoid ALdedicatedState_update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot) @@ -94,11 +91,10 @@ static void ALdedicatedState_Delete(ALdedicatedState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState); -ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *factory) +ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(factory)) { ALdedicatedState *state; ALsizei s; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; @@ -126,8 +122,8 @@ ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void) } -void ALdedicated_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALdedicated_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALdedicated_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { ALdedicated_setParami(effect, context, param, vals[0]); @@ -152,8 +148,8 @@ void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALdedicated_setParamf(effect, context, param, vals[0]); } -void ALdedicated_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALdedicated_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALdedicated_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALdedicated_getParami(effect, context, param, vals); diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index 9a18ad46..4ceb9648 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -50,16 +50,13 @@ typedef struct ALdistortionState { ALfloat edge_coeff; } ALdistortionState; -static ALvoid ALdistortionState_Destruct(ALdistortionState *state) +static ALvoid ALdistortionState_Destruct(ALdistortionState *UNUSED(state)) { - (void)state; } -static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *device) +static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *UNUSED(state), ALCdevice *UNUSED(device)) { return AL_TRUE; - (void)state; - (void)device; } static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot) @@ -188,10 +185,9 @@ static void ALdistortionState_Delete(ALdistortionState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState); -static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *factory) +static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *UNUSED(factory)) { ALdistortionState *state; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; @@ -219,8 +215,8 @@ ALeffectStateFactory *ALdistortionStateFactory_getFactory(void) } -void ALdistortion_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALdistortion_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALdistortion_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { ALdistortion_setParami(effect, context, param, vals[0]); @@ -269,8 +265,8 @@ void ALdistortion_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param ALdistortion_setParamf(effect, context, param, vals[0]); } -void ALdistortion_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALdistortion_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALdistortion_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALdistortion_getParami(effect, context, param, vals); diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index a9110e35..1305921c 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -176,10 +176,9 @@ static void ALechoState_Delete(ALechoState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALechoState); -ALeffectState *ALechoStateFactory_create(ALechoStateFactory *factory) +ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory)) { ALechoState *state; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; @@ -213,8 +212,8 @@ ALeffectStateFactory *ALechoStateFactory_getFactory(void) } -void ALecho_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALecho_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALecho_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { ALecho_setParami(effect, context, param, vals[0]); @@ -263,8 +262,8 @@ void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, cons ALecho_setParamf(effect, context, param, vals[0]); } -void ALecho_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALecho_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALecho_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALecho_getParami(effect, context, param, vals); diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index b7bfa0a2..7b3b508d 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -88,16 +88,13 @@ typedef struct ALequalizerState { ALfilterState filter[4]; } ALequalizerState; -static ALvoid ALequalizerState_Destruct(ALequalizerState *state) +static ALvoid ALequalizerState_Destruct(ALequalizerState *UNUSED(state)) { - (void)state; } -static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *device) +static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *UNUSED(state), ALCdevice *UNUSED(device)) { return AL_TRUE; - (void)state; - (void)device; } static ALvoid ALequalizerState_update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot) @@ -173,11 +170,10 @@ static void ALequalizerState_Delete(ALequalizerState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState); -ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *factory) +ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *UNUSED(factory)) { ALequalizerState *state; int it; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; @@ -207,8 +203,8 @@ ALeffectStateFactory *ALequalizerStateFactory_getFactory(void) } -void ALequalizer_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALequalizer_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALequalizer_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) { ALequalizer_setParami(effect, context, param, vals[0]); @@ -287,8 +283,8 @@ void ALequalizer_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALequalizer_setParamf(effect, context, param, vals[0]); } -void ALequalizer_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) -{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; } +void ALequalizer_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } void ALequalizer_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALequalizer_getParami(effect, context, param, vals); diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index 0107afed..25a13934 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -244,10 +244,9 @@ static void ALflangerState_Delete(ALflangerState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALflangerState); -ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *factory) +ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *UNUSED(factory)) { ALflangerState *state; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index b71070f5..2a3049d9 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -121,16 +121,13 @@ DECL_TEMPLATE(Square) #undef DECL_TEMPLATE -static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state) +static ALvoid ALmodulatorState_Destruct(ALmodulatorState *UNUSED(state)) { - (void)state; } -static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *Device) +static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *UNUSED(state), ALCdevice *UNUSED(device)) { return AL_TRUE; - (void)state; - (void)Device; } static ALvoid ALmodulatorState_update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot) @@ -190,10 +187,9 @@ static void ALmodulatorState_Delete(ALmodulatorState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState); -static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *factory) +static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *UNUSED(factory)) { ALmodulatorState *state; - (void)factory; state = malloc(sizeof(*state)); if(!state) return NULL; diff --git a/Alc/effects/null.c b/Alc/effects/null.c index fe9ea41d..62e9f6eb 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -22,41 +22,34 @@ static ALnullStateFactory NullFactory; /* This destructs (not free!) the effect state. It's called only when the * effect slot is no longer used. */ -static ALvoid ALnullState_Destruct(ALnullState *state) +static ALvoid ALnullState_Destruct(ALnullState* UNUSED(state)) { - (void)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 *state, ALCdevice *device) +static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice* UNUSED(device)) { return AL_TRUE; - (void)state; - (void)device; } /* This updates the effect state. This is called any time the effect is * (re)loaded into a slot. */ -static ALvoid ALnullState_update(ALnullState *state, ALCdevice *device, const ALeffectslot *slot) +static ALvoid ALnullState_update(ALnullState* UNUSED(state), ALCdevice* UNUSED(device), const ALeffectslot* UNUSED(slot)) { - (void)state; - (void)device; - (void)slot; } /* 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 *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]) +static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALuint UNUSED(samplesToDo), const ALfloat *restrict UNUSED(samplesIn), ALfloat (*restrict samplesOut)[BUFFERSIZE]) { - (void)state; - (void)samplesToDo; - (void)samplesIn; + /* NOTE: Couldn't use the UNUSED macro on samplesOut due to the way GCC's + * __attribute__ declaration interacts with the parenthesis. */ (void)samplesOut; } @@ -71,10 +64,9 @@ DEFINE_ALEFFECTSTATE_VTABLE(ALnullState); /* Creates ALeffectState objects of the appropriate type. */ -ALeffectState *ALnullStateFactory_create(ALnullStateFactory *factory) +ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory)) { ALnullState *state; - (void)factory; state = calloc(1, sizeof(*state)); if(!state) return NULL; @@ -101,40 +93,32 @@ ALeffectStateFactory *ALnullStateFactory_getFactory(void) } -void ALnull_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +void ALnull_setParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val)) { - (void)effect; - (void)val; switch(param) { default: SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +void ALnull_setParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALint* UNUSED(vals)) { - (void)effect; - (void)vals; switch(param) { default: SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +void ALnull_setParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val)) { - (void)effect; - (void)val; switch(param) { default: SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +void ALnull_setParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat* UNUSED(vals)) { - (void)effect; - (void)vals; switch(param) { default: @@ -142,40 +126,32 @@ void ALnull_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, cons } } -void ALnull_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALnull_getParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val)) { - (void)effect; - (void)val; switch(param) { default: SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALnull_getParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals)) { - (void)effect; - (void)vals; switch(param) { default: SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALnull_getParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val)) { - (void)effect; - (void)val; switch(param) { default: SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALnull_getParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals)) { - (void)effect; - (void)vals; switch(param) { default: diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index 4c65e0a6..9e16984b 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1185,11 +1185,10 @@ static void ALreverbState_Delete(ALreverbState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALreverbState); -static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory *factory) +static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory* UNUSED(factory)) { ALreverbState *state; ALuint index; - (void)factory; state = malloc(sizeof(ALreverbState)); if(!state) return NULL; -- cgit v1.2.3 From fc31a414732d1b45f69f66236bb52b8226762db5 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 7 Oct 2013 12:56:41 -0700 Subject: Constify the effect parameter of effect getters --- Alc/effects/autowah.c | 11 ++++------- Alc/effects/chorus.c | 8 ++++---- Alc/effects/compressor.c | 12 ++++-------- Alc/effects/dedicated.c | 8 ++++---- Alc/effects/distortion.c | 8 ++++---- Alc/effects/echo.c | 8 ++++---- Alc/effects/equalizer.c | 8 ++++---- Alc/effects/flanger.c | 8 ++++---- Alc/effects/modulator.c | 10 +++++----- Alc/effects/null.c | 8 ++++---- Alc/effects/reverb.c | 16 ++++++++-------- OpenAL32/Include/alEffect.h | 8 ++++---- 12 files changed, 53 insertions(+), 60 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c index e6e45273..1b2e166d 100644 --- a/Alc/effects/autowah.c +++ b/Alc/effects/autowah.c @@ -200,7 +200,6 @@ void ALautowah_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, c { ALautowah_setParami(effect, context, param, vals[0]); } - void ALautowah_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) { ALeffectProps *props = &effect->Props; @@ -234,19 +233,18 @@ void ALautowah_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } - void ALautowah_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { ALautowah_setParamf(effect, context, param, vals[0]); } -void ALautowah_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +void ALautowah_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } -void ALautowah_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALautowah_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALautowah_getParami(effect, context, param, vals); } -void ALautowah_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALautowah_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -271,8 +269,7 @@ void ALautowah_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } - -void ALautowah_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALautowah_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALautowah_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index 9e889847..50b5c54a 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -339,7 +339,7 @@ void ALchorus_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, co ALchorus_setParamf(effect, context, param, vals[0]); } -void ALchorus_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALchorus_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -356,11 +356,11 @@ void ALchorus_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALchorus_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALchorus_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALchorus_getParami(effect, context, param, vals); } -void ALchorus_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALchorus_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -385,7 +385,7 @@ void ALchorus_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALchorus_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALchorus_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALchorus_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c index 4bee76ce..ea035fa7 100644 --- a/Alc/effects/compressor.c +++ b/Alc/effects/compressor.c @@ -173,21 +173,18 @@ void ALcompressor_setParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } - 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 UNUSED(param), ALfloat UNUSED(val)) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - void ALcompressor_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) { ALcompressor_setParamf(effect, context, param, vals[0]); } -void ALcompressor_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALcompressor_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -199,14 +196,13 @@ void ALcompressor_getParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALcompressor_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALcompressor_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALcompressor_getParami(effect, context, param, vals); } -void ALcompressor_getParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val)) +void ALcompressor_getParamf(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val)) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } - -void ALcompressor_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALcompressor_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALcompressor_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index 3ce41978..ecf177cb 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -148,13 +148,13 @@ void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALdedicated_setParamf(effect, context, param, vals[0]); } -void ALdedicated_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +void ALdedicated_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } -void ALdedicated_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALdedicated_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALdedicated_getParami(effect, context, param, vals); } -void ALdedicated_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALdedicated_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -167,7 +167,7 @@ void ALdedicated_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALdedicated_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALdedicated_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALdedicated_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index 4ceb9648..5c6b0497 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -265,13 +265,13 @@ void ALdistortion_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param ALdistortion_setParamf(effect, context, param, vals[0]); } -void ALdistortion_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +void ALdistortion_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } -void ALdistortion_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALdistortion_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALdistortion_getParami(effect, context, param, vals); } -void ALdistortion_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALdistortion_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -300,7 +300,7 @@ void ALdistortion_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALdistortion_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALdistortion_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALdistortion_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 1305921c..18c32f17 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -262,13 +262,13 @@ void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, cons ALecho_setParamf(effect, context, param, vals[0]); } -void ALecho_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +void ALecho_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } -void ALecho_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALecho_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALecho_getParami(effect, context, param, vals); } -void ALecho_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALecho_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -297,7 +297,7 @@ void ALecho_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALecho_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALecho_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALecho_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index 7b3b508d..dba6cc3a 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -283,13 +283,13 @@ void ALequalizer_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALequalizer_setParamf(effect, context, param, vals[0]); } -void ALequalizer_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) +void ALequalizer_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val)) { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } -void ALequalizer_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALequalizer_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALequalizer_getParami(effect, context, param, vals); } -void ALequalizer_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALequalizer_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -338,7 +338,7 @@ void ALequalizer_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALequalizer_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALequalizer_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALequalizer_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index 25a13934..644426ca 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -339,7 +339,7 @@ void ALflanger_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, c ALflanger_setParamf(effect, context, param, vals[0]); } -void ALflanger_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALflanger_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -356,11 +356,11 @@ void ALflanger_getParami(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALflanger_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALflanger_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALflanger_getParami(effect, context, param, vals); } -void ALflanger_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALflanger_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -385,7 +385,7 @@ void ALflanger_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALflanger_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALflanger_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALflanger_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index 2a3049d9..90fb50d3 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -269,7 +269,7 @@ void ALmodulator_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALmodulator_setParami(effect, context, param, vals[0]); } -void ALmodulator_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALmodulator_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -288,13 +288,13 @@ void ALmodulator_getParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALmodulator_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALmodulator_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALmodulator_getParami(effect, context, param, vals); } -void ALmodulator_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALmodulator_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { - ALeffectProps *props = &effect->Props; + const ALeffectProps *props = &effect->Props; switch(param) { case AL_RING_MODULATOR_FREQUENCY: @@ -308,7 +308,7 @@ void ALmodulator_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALmodulator_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALmodulator_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALmodulator_getParamf(effect, context, param, vals); } diff --git a/Alc/effects/null.c b/Alc/effects/null.c index 62e9f6eb..ff378960 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -126,7 +126,7 @@ void ALnull_setParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum par } } -void ALnull_getParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val)) +void ALnull_getParami(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val)) { switch(param) { @@ -134,7 +134,7 @@ void ALnull_getParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum para SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_getParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals)) +void ALnull_getParamiv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals)) { switch(param) { @@ -142,7 +142,7 @@ void ALnull_getParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum par SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_getParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val)) +void ALnull_getParamf(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val)) { switch(param) { @@ -150,7 +150,7 @@ void ALnull_getParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum para SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALnull_getParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals)) +void ALnull_getParamfv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals)) { switch(param) { diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index 9e16984b..4a99adb7 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -1470,7 +1470,7 @@ void ALeaxreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, } } -void ALeaxreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALeaxreverb_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1483,11 +1483,11 @@ void ALeaxreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALeaxreverb_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALeaxreverb_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALeaxreverb_getParami(effect, context, param, vals); } -void ALeaxreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALeaxreverb_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1576,7 +1576,7 @@ void ALeaxreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALeaxreverb_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALeaxreverb_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1709,7 +1709,7 @@ void ALreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, co ALreverb_setParamf(effect, context, param, vals[0]); } -void ALreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +void ALreverb_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1722,11 +1722,11 @@ void ALreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALreverb_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +void ALreverb_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) { ALreverb_getParami(effect, context, param, vals); } -void ALreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +void ALreverb_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) { const ALeffectProps *props = &effect->Props; switch(param) @@ -1783,7 +1783,7 @@ void ALreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); } } -void ALreverb_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +void ALreverb_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) { ALreverb_getParamf(effect, context, param, vals); } diff --git a/OpenAL32/Include/alEffect.h b/OpenAL32/Include/alEffect.h index 89fa5381..772324cc 100644 --- a/OpenAL32/Include/alEffect.h +++ b/OpenAL32/Include/alEffect.h @@ -35,10 +35,10 @@ struct ALeffectVtable { void (*const setParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val); void (*const setParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals); - void (*const getParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); - void (*const getParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); - void (*const getParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); - void (*const getParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); + void (*const getParami)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val); + void (*const getParamiv)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals); + void (*const getParamf)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val); + void (*const getParamfv)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals); }; #define DEFINE_ALEFFECT_VTABLE(T) \ -- cgit v1.2.3 From b42fcce014da2c866a3d64f8f4831baed2f46e6f Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 7 Oct 2013 14:49:36 -0700 Subject: Use inline initialization for effect state factory vtables --- Alc/effects/autowah.c | 14 ++++++-------- Alc/effects/chorus.c | 20 ++++++-------------- Alc/effects/compressor.c | 13 ++++++------- Alc/effects/dedicated.c | 20 ++++++-------------- Alc/effects/distortion.c | 20 ++++++-------------- Alc/effects/echo.c | 21 ++++++--------------- Alc/effects/equalizer.c | 21 ++++++--------------- Alc/effects/flanger.c | 21 ++++++--------------- Alc/effects/modulator.c | 21 ++++++--------------- Alc/effects/null.c | 19 ++++++------------- Alc/effects/reverb.c | 21 ++++++--------------- OpenAL32/Include/alMain.h | 7 +++++-- 12 files changed, 71 insertions(+), 147 deletions(-) (limited to 'Alc/effects/equalizer.c') diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c index 1b2e166d..9a3f8b94 100644 --- a/Alc/effects/autowah.c +++ b/Alc/effects/autowah.c @@ -35,13 +35,6 @@ #define OCTAVE 2.0f -typedef struct ALautowahStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALautowahStateFactory; - -static ALautowahStateFactory AutowahFactory; - - /* We use a lfo with a custom low-pass filter to generate autowah * effect and a high-pass filter to avoid distortion and aliasing. * By adding the two filters up, we obtain a dynamic bandpass filter. @@ -171,6 +164,10 @@ static void ALautowahState_Delete(ALautowahState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALautowahState); +typedef struct ALautowahStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALautowahStateFactory; + static ALeffectState *ALautowahStateFactory_create(ALautowahStateFactory *UNUSED(factory)) { ALautowahState *state; @@ -189,7 +186,8 @@ DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALautowahStateFactory); ALeffectStateFactory *ALautowahStateFactory_getFactory(void) { - SET_VTABLE2(ALautowahStateFactory, ALeffectStateFactory, &AutowahFactory); + static ALautowahStateFactory AutowahFactory = { { GET_VTABLE2(ALautowahStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &AutowahFactory); } diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c index 50b5c54a..9e74f8c8 100644 --- a/Alc/effects/chorus.c +++ b/Alc/effects/chorus.c @@ -30,13 +30,6 @@ #include "alu.h" -typedef struct ALchorusStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALchorusStateFactory; - -static ALchorusStateFactory ChorusFactory; - - typedef struct ALchorusState { DERIVE_FROM_TYPE(ALeffectState); @@ -244,6 +237,10 @@ static void ALchorusState_Delete(ALchorusState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState); +typedef struct ALchorusStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALchorusStateFactory; + static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(factory)) { ALchorusState *state; @@ -263,15 +260,10 @@ static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(f DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALchorusStateFactory); -static void init_chorus_factory(void) -{ - SET_VTABLE2(ALchorusStateFactory, ALeffectStateFactory, &ChorusFactory); -} - ALeffectStateFactory *ALchorusStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_chorus_factory); + static ALchorusStateFactory ChorusFactory = { { GET_VTABLE2(ALchorusStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &ChorusFactory); } diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c index ea035fa7..8c639f43 100644 --- a/Alc/effects/compressor.c +++ b/Alc/effects/compressor.c @@ -26,12 +26,6 @@ #include "alAuxEffectSlot.h" #include "alu.h" -typedef struct ALcompressorStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALcompressorStateFactory; - -static ALcompressorStateFactory CompressorFactory; - typedef struct ALcompressorState { DERIVE_FROM_TYPE(ALeffectState); @@ -138,6 +132,10 @@ static void ALcompressorState_Delete(ALcompressorState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState); +typedef struct ALcompressorStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALcompressorStateFactory; + static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *UNUSED(factory)) { ALcompressorState *state; @@ -153,7 +151,8 @@ DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALcompressorStateFactory); ALeffectStateFactory *ALcompressorStateFactory_getFactory(void) { - SET_VTABLE2(ALcompressorStateFactory, ALeffectStateFactory, &CompressorFactory); + static ALcompressorStateFactory CompressorFactory = { { GET_VTABLE2(ALcompressorStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &CompressorFactory); } diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c index ecf177cb..fe57c7d8 100644 --- a/Alc/effects/dedicated.c +++ b/Alc/effects/dedicated.c @@ -29,13 +29,6 @@ #include "alu.h" -typedef struct ALdedicatedStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALdedicatedStateFactory; - -static ALdedicatedStateFactory DedicatedFactory; - - typedef struct ALdedicatedState { DERIVE_FROM_TYPE(ALeffectState); @@ -91,6 +84,10 @@ static void ALdedicatedState_Delete(ALdedicatedState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState); +typedef struct ALdedicatedStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALdedicatedStateFactory; + ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(factory)) { ALdedicatedState *state; @@ -109,15 +106,10 @@ ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(fa DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdedicatedStateFactory); -static void init_dedicated_factory(void) -{ - SET_VTABLE2(ALdedicatedStateFactory, ALeffectStateFactory, &DedicatedFactory); -} - ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_dedicated_factory); + static ALdedicatedStateFactory DedicatedFactory = { { GET_VTABLE2(ALdedicatedStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &DedicatedFactory); } diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c index 5c6b0497..7402f0af 100644 --- a/Alc/effects/distortion.c +++ b/Alc/effects/distortion.c @@ -30,13 +30,6 @@ #include "alu.h" -typedef struct ALdistortionStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALdistortionStateFactory; - -static ALdistortionStateFactory DistortionFactory; - - typedef struct ALdistortionState { DERIVE_FROM_TYPE(ALeffectState); @@ -185,6 +178,10 @@ static void ALdistortionState_Delete(ALdistortionState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState); +typedef struct ALdistortionStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALdistortionStateFactory; + static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *UNUSED(factory)) { ALdistortionState *state; @@ -202,15 +199,10 @@ static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory * DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdistortionStateFactory); -static void init_distortion_factory(void) -{ - SET_VTABLE2(ALdistortionStateFactory, ALeffectStateFactory, &DistortionFactory); -} - ALeffectStateFactory *ALdistortionStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_distortion_factory); + static ALdistortionStateFactory DistortionFactory = { { GET_VTABLE2(ALdistortionStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &DistortionFactory); } diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c index 18c32f17..7471c3dd 100644 --- a/Alc/effects/echo.c +++ b/Alc/effects/echo.c @@ -30,13 +30,6 @@ #include "alu.h" -typedef struct ALechoStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALechoStateFactory; - -static ALechoStateFactory EchoFactory; - - typedef struct ALechoState { DERIVE_FROM_TYPE(ALeffectState); @@ -176,6 +169,10 @@ static void ALechoState_Delete(ALechoState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALechoState); +typedef struct ALechoStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALechoStateFactory; + ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory)) { ALechoState *state; @@ -198,16 +195,10 @@ ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory)) DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALechoStateFactory); - -static void init_echo_factory(void) -{ - SET_VTABLE2(ALechoStateFactory, ALeffectStateFactory, &EchoFactory); -} - ALeffectStateFactory *ALechoStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_echo_factory); + static ALechoStateFactory EchoFactory = { { GET_VTABLE2(ALechoStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &EchoFactory); } diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c index dba6cc3a..d5bd2caf 100644 --- a/Alc/effects/equalizer.c +++ b/Alc/effects/equalizer.c @@ -30,13 +30,6 @@ #include "alu.h" -typedef struct ALequalizerStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALequalizerStateFactory; - -static ALequalizerStateFactory EqualizerFactory; - - /* 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 * @@ -170,6 +163,10 @@ static void ALequalizerState_Delete(ALequalizerState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState); +typedef struct ALequalizerStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALequalizerStateFactory; + ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *UNUSED(factory)) { ALequalizerState *state; @@ -189,16 +186,10 @@ ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *UNUSED(fa DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALequalizerStateFactory); - -static void init_equalizer_factory(void) -{ - SET_VTABLE2(ALequalizerStateFactory, ALeffectStateFactory, &EqualizerFactory); -} - ALeffectStateFactory *ALequalizerStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_equalizer_factory); + static ALequalizerStateFactory EqualizerFactory = { { GET_VTABLE2(ALequalizerStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &EqualizerFactory); } diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c index 644426ca..d3cdd250 100644 --- a/Alc/effects/flanger.c +++ b/Alc/effects/flanger.c @@ -30,13 +30,6 @@ #include "alu.h" -typedef struct ALflangerStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALflangerStateFactory; - -static ALflangerStateFactory FlangerFactory; - - typedef struct ALflangerState { DERIVE_FROM_TYPE(ALeffectState); @@ -244,6 +237,10 @@ static void ALflangerState_Delete(ALflangerState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALflangerState); +typedef struct ALflangerStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALflangerStateFactory; + ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *UNUSED(factory)) { ALflangerState *state; @@ -262,16 +259,10 @@ ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *UNUSED(factor DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALflangerStateFactory); - -static void init_flanger_factory(void) -{ - SET_VTABLE2(ALflangerStateFactory, ALeffectStateFactory, &FlangerFactory); -} - ALeffectStateFactory *ALflangerStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_flanger_factory); + static ALflangerStateFactory FlangerFactory = { { GET_VTABLE2(ALflangerStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &FlangerFactory); } diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c index 90fb50d3..4fdd1261 100644 --- a/Alc/effects/modulator.c +++ b/Alc/effects/modulator.c @@ -30,13 +30,6 @@ #include "alu.h" -typedef struct ALmodulatorStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALmodulatorStateFactory; - -static ALmodulatorStateFactory ModulatorFactory; - - typedef struct ALmodulatorState { DERIVE_FROM_TYPE(ALeffectState); @@ -187,6 +180,10 @@ static void ALmodulatorState_Delete(ALmodulatorState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState); +typedef struct ALmodulatorStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALmodulatorStateFactory; + static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *UNUSED(factory)) { ALmodulatorState *state; @@ -205,16 +202,10 @@ static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *UN DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALmodulatorStateFactory); - -static void init_modulator_factory(void) -{ - SET_VTABLE2(ALmodulatorStateFactory, ALeffectStateFactory, &ModulatorFactory); -} - ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_modulator_factory); + static ALmodulatorStateFactory ModulatorFactory = { { GET_VTABLE2(ALmodulatorStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &ModulatorFactory); } diff --git a/Alc/effects/null.c b/Alc/effects/null.c index ff378960..816a2525 100644 --- a/Alc/effects/null.c +++ b/Alc/effects/null.c @@ -9,15 +9,10 @@ #include "alError.h" -typedef struct ALnullStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALnullStateFactory; - typedef struct ALnullState { DERIVE_FROM_TYPE(ALeffectState); } ALnullState; -static ALnullStateFactory NullFactory; /* This destructs (not free!) the effect state. It's called only when the * effect slot is no longer used. @@ -63,6 +58,10 @@ static void ALnullState_Delete(ALnullState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALnullState); +typedef struct ALnullStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALnullStateFactory; + /* Creates ALeffectState objects of the appropriate type. */ ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory)) { @@ -79,16 +78,10 @@ ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory)) /* Define the ALeffectStateFactory vtable for this type. */ DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALnullStateFactory); - -static void init_none_factory(void) -{ - SET_VTABLE2(ALnullStateFactory, ALeffectStateFactory, &NullFactory); -} - ALeffectStateFactory *ALnullStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_none_factory); + static ALnullStateFactory NullFactory = { { GET_VTABLE2(ALnullStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &NullFactory); } diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c index 4a99adb7..77bf4a16 100644 --- a/Alc/effects/reverb.c +++ b/Alc/effects/reverb.c @@ -32,13 +32,6 @@ #include "alError.h" -typedef struct ALreverbStateFactory { - DERIVE_FROM_TYPE(ALeffectStateFactory); -} ALreverbStateFactory; - -static ALreverbStateFactory ReverbFactory; - - typedef struct DelayLine { // The delay lines use sample lengths that are powers of 2 to allow the @@ -1185,6 +1178,10 @@ static void ALreverbState_Delete(ALreverbState *state) DEFINE_ALEFFECTSTATE_VTABLE(ALreverbState); +typedef struct ALreverbStateFactory { + DERIVE_FROM_TYPE(ALeffectStateFactory); +} ALreverbStateFactory; + static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory* UNUSED(factory)) { ALreverbState *state; @@ -1278,16 +1275,10 @@ static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory* UNUSED(f DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALreverbStateFactory); - -static void init_reverb_factory(void) -{ - SET_VTABLE2(ALreverbStateFactory, ALeffectStateFactory, &ReverbFactory); -} - ALeffectStateFactory *ALreverbStateFactory_getFactory(void) { - static pthread_once_t once = PTHREAD_ONCE_INIT; - pthread_once(&once, init_reverb_factory); + static ALreverbStateFactory ReverbFactory = { { GET_VTABLE2(ALreverbStateFactory, ALeffectStateFactory) } }; + return STATIC_CAST(ALeffectStateFactory, &ReverbFactory); } diff --git a/OpenAL32/Include/alMain.h b/OpenAL32/Include/alMain.h index 47f1934c..11a1e78c 100644 --- a/OpenAL32/Include/alMain.h +++ b/OpenAL32/Include/alMain.h @@ -93,8 +93,11 @@ static const union { #define STATIC_CAST(to, obj) (&(obj)->to##_parent) #define STATIC_UPCAST(to, from, obj) ((to*)((char*)(obj) - offsetof(to, from##_parent))) -#define SET_VTABLE1(T1, obj) ((obj)->vtbl = &(T1##_vtable)) -#define SET_VTABLE2(T1, T2, obj) SET_VTABLE1(T1##_##T2, STATIC_CAST(T2, (obj))) +#define GET_VTABLE1(T1) (&(T1##_vtable)) +#define GET_VTABLE2(T1, T2) (&(T1##_##T2##_vtable)) + +#define SET_VTABLE1(T1, obj) ((obj)->vtbl = GET_VTABLE1(T1)) +#define SET_VTABLE2(T1, T2, obj) (STATIC_CAST(T2, obj)->vtbl = GET_VTABLE2(T1, T2)) /* Helper to extract an argument list for VCALL. Not used directly. */ #define EXTRACT_VCALL_ARGS(...) __VA_ARGS__ -- cgit v1.2.3