From 3fd0f23e48fc71718f438e035ffb09d4ba9a47a3 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Wed, 13 Mar 2013 23:31:12 -0700 Subject: Add Chorus and Flanger effects Code provided by Mike Gorchak --- Alc/ALc.c | 18 ++- Alc/alcChorus.c | 395 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ Alc/alcFlanger.c | 395 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 806 insertions(+), 2 deletions(-) create mode 100644 Alc/alcChorus.c create mode 100644 Alc/alcFlanger.c (limited to 'Alc') diff --git a/Alc/ALc.c b/Alc/ALc.c index fd5b8894..094c974c 100644 --- a/Alc/ALc.c +++ b/Alc/ALc.c @@ -512,13 +512,13 @@ static const ALCenums enumeration[] = { DECL(AL_EFFECT_NULL), DECL(AL_EFFECT_REVERB), DECL(AL_EFFECT_EAXREVERB), -#if 0 DECL(AL_EFFECT_CHORUS), +#if 0 DECL(AL_EFFECT_DISTORTION), #endif DECL(AL_EFFECT_ECHO), -#if 0 DECL(AL_EFFECT_FLANGER), +#if 0 DECL(AL_EFFECT_FREQUENCY_SHIFTER), DECL(AL_EFFECT_VOCAL_MORPHER), DECL(AL_EFFECT_PITCH_SHIFTER), @@ -576,6 +576,20 @@ static const ALCenums enumeration[] = { DECL(AL_ECHO_FEEDBACK), DECL(AL_ECHO_SPREAD), + DECL(AL_CHORUS_WAVEFORM), + DECL(AL_CHORUS_PHASE), + DECL(AL_CHORUS_RATE), + DECL(AL_CHORUS_DEPTH), + DECL(AL_CHORUS_FEEDBACK), + DECL(AL_CHORUS_DELAY), + + DECL(AL_FLANGER_WAVEFORM), + DECL(AL_FLANGER_PHASE), + DECL(AL_FLANGER_RATE), + DECL(AL_FLANGER_DEPTH), + DECL(AL_FLANGER_FEEDBACK), + DECL(AL_FLANGER_DELAY), + DECL(AL_RING_MODULATOR_FREQUENCY), DECL(AL_RING_MODULATOR_HIGHPASS_CUTOFF), DECL(AL_RING_MODULATOR_WAVEFORM), diff --git a/Alc/alcChorus.c b/Alc/alcChorus.c new file mode 100644 index 00000000..5a97ff17 --- /dev/null +++ b/Alc/alcChorus.c @@ -0,0 +1,395 @@ +/** + * 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 ALchorusState { + // Must be first in all effects! + ALeffectState state; + + ALfloat *SampleBufferLeft; + ALfloat *SampleBufferRight; + ALuint BufferLength; + ALint offset; + ALfloat lfo_coeff; + ALint lfo_disp; + + /* Gains for left and right sides */ + ALfloat Gain[2][MaxChannels]; + + /* effect parameters */ + ALint waveform; + ALint phase; + ALfloat rate; + ALfloat depth; + ALfloat feedback; + ALfloat delay; + ALfloat frequency; +} ALchorusState; + +static ALvoid ChorusDestroy(ALeffectState *effect) +{ + ALchorusState *state = (ALchorusState*)effect; + + if (state) + { + if (state->SampleBufferLeft != NULL) + { + free(state->SampleBufferLeft); + state->SampleBufferLeft = NULL; + } + if (state->SampleBufferRight != NULL) + { + free(state->SampleBufferRight); + state->SampleBufferRight = NULL; + } + free(state); + } +} + +static ALboolean ChorusDeviceUpdate(ALeffectState *effect, ALCdevice *Device) +{ + ALchorusState *state = (ALchorusState*)effect; + ALuint maxlen; + ALuint it; + + maxlen = fastf2u(AL_CHORUS_MAX_DELAY * 3.0f * Device->Frequency) + 1; + maxlen = NextPowerOf2(maxlen); + + if (maxlen != state->BufferLength) + { + void *temp; + + temp = realloc(state->SampleBufferLeft, maxlen * sizeof(ALfloat)); + if (!temp) + { + return AL_FALSE; + } + state->SampleBufferLeft = temp; + + temp = realloc(state->SampleBufferRight, maxlen * sizeof(ALfloat)); + if (!temp) + { + return AL_FALSE; + } + state->SampleBufferRight = temp; + + state->BufferLength = maxlen; + } + + for (it = 0; it < state->BufferLength; it++) + { + state->SampleBufferLeft[it] = 0.0f; + state->SampleBufferRight[it] = 0.0f; + } + + state->frequency=(ALfloat)Device->Frequency; + + return AL_TRUE; +} + +static ALvoid ChorusUpdate(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot) +{ + ALchorusState *state = (ALchorusState*)effect; + ALuint it; + + for (it = 0; it < MaxChannels; it++) + { + state->Gain[0][it] = 0.0f; + state->Gain[1][it] = 0.0f; + } + + state->waveform = Slot->effect.Chorus.Waveform; + state->phase = Slot->effect.Chorus.Phase; + state->rate = Slot->effect.Chorus.Rate; + state->depth = Slot->effect.Chorus.Depth; + state->feedback = Slot->effect.Chorus.Feedback; + state->delay = Slot->effect.Chorus.Delay; + state->frequency=(ALfloat)Device->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]); + + /* Calculate LFO coefficient */ + switch (state->waveform) + { + case AL_CHORUS_WAVEFORM_TRIANGLE: + if (state->rate == 0.0f) + { + state->lfo_coeff = 0.0f; + } + else + { + state->lfo_coeff = 1.0f / ((ALfloat)Device->Frequency / state->rate); + } + break; + case AL_CHORUS_WAVEFORM_SINUSOID: + if (state->rate == 0.0f) + { + state->lfo_coeff = 0.0f; + } + else + { + state->lfo_coeff = F_PI * 2.0f / ((ALfloat)Device->Frequency / state->rate); + } + break; + } + + /* Calculate lfo phase displacement */ + if ((state->phase == 0) || (state->rate == 0.0f)) + { + state->lfo_disp = 0; + } + else + { + state->lfo_disp = (ALint) ((ALfloat)Device->Frequency / + state->rate / (360.0f / (ALfloat)state->phase)); + } +} + +static ALvoid ChorusProcess(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE]) +{ + ALchorusState *state = (ALchorusState*)effect; + const ALuint mask = state->BufferLength-1; + ALuint it; + ALuint kt; + ALint offset; + ALfloat lfo_value_left = 0.0f; + ALfloat lfo_value_right = 0.0f; + ALint delay_left = 0; + ALint delay_right = 0; + ALfloat smp; + + offset=state->offset; + + switch (state->waveform) + { + case AL_CHORUS_WAVEFORM_TRIANGLE: + for (it = 0; it < SamplesToDo; it++, offset++) + { + lfo_value_left = 2.0f - fabsf(2.0f - fmodf(state->lfo_coeff * + offset * 4.0f, 4.0f)); + lfo_value_left *= state->depth * state->delay; + lfo_value_left += state->delay; + delay_left = (ALint)(lfo_value_left * state->frequency); + lfo_value_right = 2.0f - fabsf(2.0f - fmodf(state->lfo_coeff * + (offset + state->lfo_disp) * 4.0f, 4.0f)); + lfo_value_right *= state->depth * state->delay; + lfo_value_right += state->delay; + delay_right = (ALint)(lfo_value_right * state->frequency); + + smp = state->SampleBufferLeft[(offset-delay_left) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[0][kt]; + } + state->SampleBufferLeft[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + smp = state->SampleBufferRight[(offset-delay_right) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[1][kt]; + } + state->SampleBufferRight[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + } + break; + case AL_CHORUS_WAVEFORM_SINUSOID: + for (it = 0; it < SamplesToDo; it++, offset++) + { + lfo_value_left = 1.0f + sinf(fmodf(state->lfo_coeff * + offset, 2 * F_PI)); + lfo_value_left *= state->depth * state->delay; + lfo_value_left += state->delay; + delay_left = (ALint)(lfo_value_left * state->frequency); + lfo_value_right = 1.0f + sinf(fmodf(state->lfo_coeff * + (offset + state->lfo_disp), 2 * F_PI)); + lfo_value_right *= state->depth * state->delay; + lfo_value_right += state->delay; + delay_right = (ALint)(lfo_value_right * state->frequency); + + smp = state->SampleBufferLeft[(offset-delay_left) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[0][kt]; + } + state->SampleBufferLeft[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + smp = state->SampleBufferRight[(offset-delay_right) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[1][kt]; + } + state->SampleBufferRight[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + } + break; + } + + state->offset=offset; +} + +ALeffectState *ChorusCreate(void) +{ + ALchorusState *state; + + state = malloc(sizeof(*state)); + if(!state) + return NULL; + + state->state.Destroy = ChorusDestroy; + state->state.DeviceUpdate = ChorusDeviceUpdate; + state->state.Update = ChorusUpdate; + state->state.Process = ChorusProcess; + + state->BufferLength = 0; + state->SampleBufferLeft = NULL; + state->SampleBufferRight = NULL; + state->offset = 0; + + return &state->state; +} + +void chorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +{ + switch(param) + { + case AL_CHORUS_WAVEFORM: + if(val >= AL_CHORUS_MIN_WAVEFORM && val <= AL_CHORUS_MAX_WAVEFORM) + effect->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; + else + alSetError(context, AL_INVALID_VALUE); + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void chorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +{ + chorus_SetParami(effect, context, param, vals[0]); +} +void chorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +{ + switch(param) + { + case AL_CHORUS_RATE: + if(val >= AL_CHORUS_MIN_RATE && val <= AL_CHORUS_MAX_RATE) + effect->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; + 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; + 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; + else + alSetError(context, AL_INVALID_VALUE); + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void chorus_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +{ + chorus_SetParamf(effect, context, param, vals[0]); +} + +void chorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +{ + switch(param) + { + case AL_CHORUS_WAVEFORM: + *val = effect->Chorus.Waveform; + break; + + case AL_CHORUS_PHASE: + *val = effect->Chorus.Phase; + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void chorus_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +{ + chorus_GetParami(effect, context, param, vals); +} +void chorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +{ + switch(param) + { + case AL_CHORUS_RATE: + *val = effect->Chorus.Rate; + break; + + case AL_CHORUS_DEPTH: + *val = effect->Chorus.Depth; + break; + + case AL_CHORUS_FEEDBACK: + *val = effect->Chorus.Feedback; + break; + + case AL_CHORUS_DELAY: + *val = effect->Chorus.Delay; + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void chorus_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +{ + chorus_GetParamf(effect, context, param, vals); +} diff --git a/Alc/alcFlanger.c b/Alc/alcFlanger.c new file mode 100644 index 00000000..a1047c01 --- /dev/null +++ b/Alc/alcFlanger.c @@ -0,0 +1,395 @@ +/** + * 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 ALflangerState { + // Must be first in all effects! + ALeffectState state; + + ALfloat *SampleBufferLeft; + ALfloat *SampleBufferRight; + ALuint BufferLength; + ALint offset; + ALfloat lfo_coeff; + ALint lfo_disp; + + /* Gains for left and right sides */ + ALfloat Gain[2][MaxChannels]; + + /* effect parameters */ + ALint waveform; + ALint phase; + ALfloat rate; + ALfloat depth; + ALfloat feedback; + ALfloat delay; + ALfloat frequency; +} ALflangerState; + +static ALvoid FlangerDestroy(ALeffectState *effect) +{ + ALflangerState *state = (ALflangerState*)effect; + + if (state) + { + if (state->SampleBufferLeft != NULL) + { + free(state->SampleBufferLeft); + state->SampleBufferLeft = NULL; + } + if (state->SampleBufferRight != NULL) + { + free(state->SampleBufferRight); + state->SampleBufferRight = NULL; + } + free(state); + } +} + +static ALboolean FlangerDeviceUpdate(ALeffectState *effect, ALCdevice *Device) +{ + ALflangerState *state = (ALflangerState*)effect; + ALuint maxlen; + ALuint it; + + maxlen = fastf2u(AL_FLANGER_MAX_DELAY * 3.0f * Device->Frequency) + 1; + maxlen = NextPowerOf2(maxlen); + + if (maxlen != state->BufferLength) + { + void *temp; + + temp = realloc(state->SampleBufferLeft, maxlen * sizeof(ALfloat)); + if (!temp) + { + return AL_FALSE; + } + state->SampleBufferLeft = temp; + + temp = realloc(state->SampleBufferRight, maxlen * sizeof(ALfloat)); + if (!temp) + { + return AL_FALSE; + } + state->SampleBufferRight = temp; + + state->BufferLength = maxlen; + } + + for (it = 0; it < state->BufferLength; it++) + { + state->SampleBufferLeft[it] = 0.0f; + state->SampleBufferRight[it] = 0.0f; + } + + state->frequency=(ALfloat)Device->Frequency; + + return AL_TRUE; +} + +static ALvoid FlangerUpdate(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot) +{ + ALflangerState *state = (ALflangerState*)effect; + ALuint it; + + for (it = 0; it < MaxChannels; it++) + { + state->Gain[0][it] = 0.0f; + state->Gain[1][it] = 0.0f; + } + + state->waveform = Slot->effect.Flanger.Waveform; + state->phase = Slot->effect.Flanger.Phase; + state->rate = Slot->effect.Flanger.Rate; + state->depth = Slot->effect.Flanger.Depth; + state->feedback = Slot->effect.Flanger.Feedback; + state->delay = Slot->effect.Flanger.Delay; + state->frequency=(ALfloat)Device->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]); + + /* Calculate LFO coefficient */ + switch (state->waveform) + { + case AL_FLANGER_WAVEFORM_TRIANGLE: + if (state->rate == 0.0f) + { + state->lfo_coeff = 0.0f; + } + else + { + state->lfo_coeff = 1.0f / ((ALfloat)Device->Frequency / state->rate); + } + break; + case AL_FLANGER_WAVEFORM_SINUSOID: + if (state->rate == 0.0f) + { + state->lfo_coeff = 0.0f; + } + else + { + state->lfo_coeff = F_PI * 2.0f / ((ALfloat)Device->Frequency / state->rate); + } + break; + } + + /* Calculate lfo phase displacement */ + if ((state->phase == 0) || (state->rate == 0.0f)) + { + state->lfo_disp = 0; + } + else + { + state->lfo_disp = (ALint) ((ALfloat)Device->Frequency / + state->rate / (360.0f / (ALfloat)state->phase)); + } +} + +static ALvoid FlangerProcess(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE]) +{ + ALflangerState *state = (ALflangerState*)effect; + const ALuint mask = state->BufferLength-1; + ALuint it; + ALuint kt; + ALint offset; + ALfloat lfo_value_left = 0.0f; + ALfloat lfo_value_right = 0.0f; + ALint delay_left = 0; + ALint delay_right = 0; + ALfloat smp; + + offset=state->offset; + + switch (state->waveform) + { + case AL_FLANGER_WAVEFORM_TRIANGLE: + for (it = 0; it < SamplesToDo; it++, offset++) + { + lfo_value_left = 2.0f - fabsf(2.0f - fmodf(state->lfo_coeff * + offset * 4.0f, 4.0f)); + lfo_value_left *= state->depth * state->delay; + lfo_value_left += state->delay; + delay_left = (ALint)(lfo_value_left * state->frequency); + lfo_value_right = 2.0f - fabsf(2.0f - fmodf(state->lfo_coeff * + (offset + state->lfo_disp) * 4.0f, 4.0f)); + lfo_value_right *= state->depth * state->delay; + lfo_value_right += state->delay; + delay_right = (ALint)(lfo_value_right * state->frequency); + + smp = state->SampleBufferLeft[(offset-delay_left) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[0][kt]; + } + state->SampleBufferLeft[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + smp = state->SampleBufferRight[(offset-delay_right) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[1][kt]; + } + state->SampleBufferRight[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + } + break; + case AL_FLANGER_WAVEFORM_SINUSOID: + for (it = 0; it < SamplesToDo; it++, offset++) + { + lfo_value_left = 1.0f + sinf(fmodf(state->lfo_coeff * + offset, 2 * F_PI)); + lfo_value_left *= state->depth * state->delay; + lfo_value_left += state->delay; + delay_left = (ALint)(lfo_value_left * state->frequency); + lfo_value_right = 1.0f + sinf(fmodf(state->lfo_coeff * + (offset + state->lfo_disp), 2 * F_PI)); + lfo_value_right *= state->depth * state->delay; + lfo_value_right += state->delay; + delay_right = (ALint)(lfo_value_right * state->frequency); + + smp = state->SampleBufferLeft[(offset-delay_left) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[0][kt]; + } + state->SampleBufferLeft[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + smp = state->SampleBufferRight[(offset-delay_right) & mask]; + for (kt = 0; kt < MaxChannels; kt++) + { + SamplesOut[kt][it] += smp * state->Gain[1][kt]; + } + state->SampleBufferRight[offset & mask] = (smp + SamplesIn[it]) * state->feedback; + } + break; + } + + state->offset=offset; +} + +ALeffectState *FlangerCreate(void) +{ + ALflangerState *state; + + state = malloc(sizeof(*state)); + if(!state) + return NULL; + + state->state.Destroy = FlangerDestroy; + state->state.DeviceUpdate = FlangerDeviceUpdate; + state->state.Update = FlangerUpdate; + state->state.Process = FlangerProcess; + + state->BufferLength = 0; + state->SampleBufferLeft = NULL; + state->SampleBufferRight = NULL; + state->offset = 0; + + return &state->state; +} + +void flanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val) +{ + switch(param) + { + case AL_FLANGER_WAVEFORM: + if(val >= AL_FLANGER_MIN_WAVEFORM && val <= AL_FLANGER_MAX_WAVEFORM) + effect->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; + else + alSetError(context, AL_INVALID_VALUE); + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void flanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals) +{ + flanger_SetParami(effect, context, param, vals[0]); +} +void flanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val) +{ + switch(param) + { + case AL_FLANGER_RATE: + if(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE) + effect->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; + 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; + 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; + else + alSetError(context, AL_INVALID_VALUE); + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void flanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals) +{ + flanger_SetParamf(effect, context, param, vals[0]); +} + +void flanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val) +{ + switch(param) + { + case AL_FLANGER_WAVEFORM: + *val = effect->Flanger.Waveform; + break; + + case AL_FLANGER_PHASE: + *val = effect->Flanger.Phase; + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void flanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals) +{ + flanger_GetParami(effect, context, param, vals); +} +void flanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val) +{ + switch(param) + { + case AL_FLANGER_RATE: + *val = effect->Flanger.Rate; + break; + + case AL_FLANGER_DEPTH: + *val = effect->Flanger.Depth; + break; + + case AL_FLANGER_FEEDBACK: + *val = effect->Flanger.Feedback; + break; + + case AL_FLANGER_DELAY: + *val = effect->Flanger.Delay; + break; + + default: + alSetError(context, AL_INVALID_ENUM); + break; + } +} +void flanger_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals) +{ + flanger_GetParamf(effect, context, param, vals); +} -- cgit v1.2.3