kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Chorus and Flanger effects

Browse Source 
Code provided by Mike Gorchak
This commit is contained in:
Chris Robinson 2013-03-13 23:31:12 -07:00
parent 991aba286f
commit 3fd0f23e48
10 changed files with 896 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Alc/ALc.c
View File

@ -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),

395
Alc/alcChorus.c Normal file
View File

@ -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 <math.h>
#include <stdlib.h>
#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);
}

395
Alc/alcFlanger.c Normal file
View File

@ -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 <math.h>
#include <stdlib.h>
#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);
}

2
CMakeLists.txt
View File

@ -445,9 +445,11 @@ SET(OPENAL_OBJS OpenAL32/alAuxEffectSlot.c
)
SET(ALC_OBJS Alc/ALc.c
Alc/ALu.c
Alc/alcChorus.c
Alc/alcConfig.c
Alc/alcDedicated.c
Alc/alcEcho.c
Alc/alcFlanger.c
Alc/alcModulator.c
Alc/alcReverb.c
Alc/alcRing.c

2
OpenAL32/Include/alAuxEffectSlot.h
View File

@ -46,6 +46,8 @@ ALeffectState *ReverbCreate(void);
ALeffectState *EchoCreate(void);
ALeffectState *ModulatorCreate(void);
ALeffectState *DedicatedCreate(void);
ALeffectState *ChorusCreate(void);
ALeffectState *FlangerCreate(void);
#define ALeffectState_Destroy(a) ((a)->Destroy((a)))
#define ALeffectState_DeviceUpdate(a,b) ((a)->DeviceUpdate((a),(b)))

38
OpenAL32/Include/alEffect.h
View File

@ -13,6 +13,8 @@ enum {
ECHO,
MODULATOR,
DEDICATED,
CHORUS,
FLANGER,
MAX_EFFECTS
};
@ -75,6 +77,24 @@ typedef struct ALeffect
ALfloat Gain;
} Dedicated;
struct {
ALint Waveform;
ALint Phase;
ALfloat Rate;
ALfloat Depth;
ALfloat Feedback;
ALfloat Delay;
} Chorus;
struct {
ALint Waveform;
ALint Phase;
ALfloat Rate;
ALfloat Depth;
ALfloat Feedback;
ALfloat Delay;
} Flanger;
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);
@ -120,6 +140,15 @@ void reverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALin
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 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);
@ -129,6 +158,15 @@ void echo_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint
void echo_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val);
void echo_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);

10
OpenAL32/alAuxEffectSlot.c
View File

@ -537,6 +537,16 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e
if(!State) err = AL_OUT_OF_MEMORY;
}
}
else if(newtype == AL_EFFECT_CHORUS && EffectSlot->effect.type != AL_EFFECT_CHORUS)
{
State = ChorusCreate();
if(!State) err = AL_OUT_OF_MEMORY;
}
else if(newtype == AL_EFFECT_FLANGER && EffectSlot->effect.type != AL_EFFECT_FLANGER)
{
State = FlangerCreate();
if(!State) err = AL_OUT_OF_MEMORY;
}
if(err != AL_NO_ERROR)
{

34
OpenAL32/alEffect.c
View File

@ -470,6 +470,40 @@ static void InitEffectParams(ALeffect *effect, ALenum type)
effect->GetParamf = ded_GetParamf;
effect->GetParamfv = ded_GetParamfv;
break;
case AL_EFFECT_CHORUS:
effect->Chorus.Waveform = AL_CHORUS_DEFAULT_WAVEFORM;
effect->Chorus.Phase = AL_CHORUS_DEFAULT_PHASE;
effect->Chorus.Rate = AL_CHORUS_MAX_RATE;
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;
break;
case AL_EFFECT_FLANGER:
effect->Flanger.Waveform = AL_FLANGER_DEFAULT_WAVEFORM;
effect->Flanger.Phase = AL_FLANGER_DEFAULT_PHASE;
effect->Flanger.Rate = AL_FLANGER_MAX_RATE;
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;
break;
default:
effect->SetParami = null_SetParami;
effect->SetParamiv = null_SetParamiv;

2
OpenAL32/alExtension.c
View File

@ -42,6 +42,8 @@ const struct EffectList EffectList[] = {
{ "modulator", MODULATOR, "AL_EFFECT_RING_MODULATOR", AL_EFFECT_RING_MODULATOR },
{ "dedicated", DEDICATED, "AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT", AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT },
{ "dedicated", DEDICATED, "AL_EFFECT_DEDICATED_DIALOGUE", AL_EFFECT_DEDICATED_DIALOGUE },
{ "chorus", CHORUS, "AL_EFFECT_CHORUS", AL_EFFECT_CHORUS },
{ "flanger", FLANGER, "AL_EFFECT_FLANGER", AL_EFFECT_FLANGER },
{ NULL, 0, NULL, (ALenum)0 }
};

4
alsoftrc.sample
View File

@ -126,8 +126,8 @@
## excludefx:
# Sets which effects to exclude, preventing apps from using them. This can
# help for apps that try to use effects which are too CPU intensive for the
# system to handle. Available effects are: eaxreverb,reverb,echo,modulator,
# dedicated
# system to handle. Available effects are: eaxreverb,reverb,chorus,echo,
# flanger,modulator,dedicated
#excludefx =
## slots: