AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
{
ALCcontext *Context;
ALeffect *ALEffect;
ALsizei i;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (n >= 0)
{
// Check that all effects are valid
for (i = 0; i < n; i++)
{
if (!alIsEffect(effects[i]))
{
alSetError(AL_INVALID_NAME);
break;
}
}
if (i == n)
{
// All effects are valid
for (i = 0; i < n; i++)
{
// Recheck that the effect is valid, because there could be duplicated names
if (effects[i] && alIsEffect(effects[i]))
{
ALeffect **list;
ALEffect = ((ALeffect*)ALTHUNK_LOOKUPENTRY(effects[i]));
// Remove Source from list of Sources
list = &g_EffectList;
while(*list && *list != ALEffect)
list = &(*list)->next;
if(*list)
*list = (*list)->next;
ALTHUNK_REMOVEENTRY(ALEffect->effect);
memset(ALEffect, 0, sizeof(ALeffect));
free(ALEffect);
g_EffectCount--;
}
}
}
}
else
alSetError(AL_INVALID_VALUE);
ProcessContext(Context);
}
ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(param == AL_EFFECT_TYPE)
{
alGetEffecti(effect, param, piValues);
}
else if(ALEffect->type == AL_EFFECT_EAXREVERB)
{
switch(param)
{
case AL_EAXREVERB_DECAY_HFLIMIT:
alGetEffecti(effect, param, piValues);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DECAY_HFLIMIT:
alGetEffecti(effect, param, piValues);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
if(!Context)
{
alSetError(AL_INVALID_OPERATION);
return;
}
SuspendContext(Context);
if (alIsAuxiliaryEffectSlot(effectslot))
{
ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
switch(param)
{
case AL_EFFECTSLOT_EFFECT:
if(alIsEffect(iValue))
{
ALeffect *effect = (ALeffect*)ALTHUNK_LOOKUPENTRY(iValue);
InitializeEffect(Context, ALEffectSlot, effect);
}
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
if(iValue == AL_TRUE || iValue == AL_FALSE)
ALEffectSlot->AuxSendAuto = iValue;
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DENSITY:
case AL_REVERB_DIFFUSION:
case AL_REVERB_GAIN:
case AL_REVERB_GAINHF:
case AL_REVERB_DECAY_TIME:
case AL_REVERB_DECAY_HFRATIO:
case AL_REVERB_REFLECTIONS_GAIN:
case AL_REVERB_REFLECTIONS_DELAY:
case AL_REVERB_LATE_REVERB_GAIN:
case AL_REVERB_LATE_REVERB_DELAY:
case AL_REVERB_AIR_ABSORPTION_GAINHF:
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
alGetEffectf(effect, param, pflValues);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(param == AL_EFFECT_TYPE)
{
if(iValue == AL_EFFECT_NULL ||
iValue == AL_EFFECT_REVERB)
InitEffectParams(ALEffect, iValue);
else
alSetError(AL_INVALID_VALUE);
}
else if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DECAY_HFLIMIT:
if(iValue == AL_TRUE || iValue == AL_FALSE)
ALEffect->Reverb.DecayHFLimit = iValue;
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DENSITY:
*pflValue = ALEffect->Reverb.Density;
break;
case AL_REVERB_DIFFUSION:
*pflValue = ALEffect->Reverb.Diffusion;
break;
case AL_REVERB_GAIN:
*pflValue = ALEffect->Reverb.Gain;
break;
case AL_REVERB_GAINHF:
*pflValue = ALEffect->Reverb.GainHF;
break;
case AL_REVERB_DECAY_TIME:
*pflValue = ALEffect->Reverb.DecayTime;
break;
case AL_REVERB_DECAY_HFRATIO:
*pflValue = ALEffect->Reverb.DecayHFRatio;
break;
case AL_REVERB_REFLECTIONS_GAIN:
*pflValue = ALEffect->Reverb.ReflectionsGain;
break;
case AL_REVERB_REFLECTIONS_DELAY:
*pflValue = ALEffect->Reverb.ReflectionsDelay;
break;
case AL_REVERB_LATE_REVERB_GAIN:
*pflValue = ALEffect->Reverb.LateReverbGain;
break;
case AL_REVERB_LATE_REVERB_DELAY:
*pflValue = ALEffect->Reverb.LateReverbDelay;
break;
case AL_REVERB_AIR_ABSORPTION_GAINHF:
*pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
break;
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
*pflValue = ALEffect->Reverb.RoomRolloffFactor;
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
CEFX::CEFX(ALCdevice* device)
:enabled(false)
,supported(false)
,sfxProperties(NULL)
,sfxSlot(0)
,sfxReverb(0)
,sfxFilter(0)
,updates(0)
,maxSlots(0)
,maxSlotsPerSource(0)
{
SetAirAbsorptionFactor(configHandler->GetFloat("snd_airAbsorption"));
bool hasExtension = alcIsExtensionPresent(device, "ALC_EXT_EFX");
if(hasExtension && alGenEffects && alDeleteEffects)
supported = true;
//! set default preset
eaxPresets["default"] = eaxPresets[default_preset];
//! always allocate this
sfxProperties = new EAXSfxProps();
*sfxProperties = eaxPresets[default_preset];
if (!supported) {
if(!hasExtension)
LOG(" EFX Supported: no");
else
LOG(" EFX is supported but software does not seem to work properly");
return;
}
//! clear log
alGetError() ;
//! Check Available Effects
{
static const ALuint effects[] = {
AL_EFFECT_REVERB,
AL_EFFECT_EAXREVERB,
AL_EFFECT_CHORUS,
AL_EFFECT_DISTORTION,
AL_EFFECT_ECHO,
AL_EFFECT_FLANGER,
AL_EFFECT_FREQUENCY_SHIFTER,
AL_EFFECT_VOCAL_MORPHER,
AL_EFFECT_PITCH_SHIFTER,
AL_EFFECT_RING_MODULATOR,
AL_EFFECT_AUTOWAH,
AL_EFFECT_COMPRESSOR,
AL_EFFECT_EQUALIZER
};
ALuint alFx;
alGenEffects(1, &alFx);
if (alGetError() == AL_NO_ERROR) {
for(size_t i = 0; i < sizeof(effects); i++) {
const ALuint fx = effects[i];
alEffecti(alFx, AL_EFFECT_TYPE, fx);
effectsSupported[fx] = (alGetError() == AL_NO_ERROR);
}
}
alDeleteEffects(1, &alFx);
}
//! Check Available Filters
{
static const ALuint filters[] = {
AL_FILTER_LOWPASS,
AL_FILTER_HIGHPASS,
AL_FILTER_BANDPASS
};
ALuint alFilter;
alGenFilters(1, &alFilter);
if (alGetError() == AL_NO_ERROR) {
for(size_t i = 0; i < sizeof(filters); i++) {
const ALuint filter = filters[i];
alFilteri(alFilter, AL_FILTER_TYPE, filter);
filtersSupported[filter] = (alGetError() == AL_NO_ERROR);
}
}
alDeleteFilters(1, &alFilter);
}
//! Check Max Available EffectSlots
{
int n;
ALuint alFXSlots[128];
for (n = 0; n < 128; n++) {
alGenAuxiliaryEffectSlots(1, &alFXSlots[n]);
if (alGetError() != AL_NO_ERROR)
break;
}
maxSlots = n;
alDeleteAuxiliaryEffectSlots(n, alFXSlots);
}
//! Check Max AUX FX SLOTS Per Sound Source
alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, (ALCint*)&maxSlotsPerSource);
//! Check requirements
if (!effectsSupported[AL_EFFECT_EAXREVERB]
|| !filtersSupported[AL_FILTER_LOWPASS]
|| (maxSlots<1)
|| (maxSlotsPerSource<1)
) {
LOG_L(L_WARNING, " EFX Supported: no");
supported = false;
return;
}
//! Create our global sfx enviroment
alGenAuxiliaryEffectSlots(1, &sfxSlot);
alGenEffects(1, &sfxReverb);
alEffecti(sfxReverb, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
alGenFilters(1, &sfxFilter);
alFilteri(sfxFilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
if (!alIsAuxiliaryEffectSlot(sfxSlot) || !alIsEffect(sfxReverb) || !alIsFilter(sfxFilter)) {
LOG_L(L_ERROR, " Initializing EFX failed!");
alDeleteFilters(1, &sfxFilter);
alDeleteEffects(1, &sfxReverb);
alDeleteAuxiliaryEffectSlots(1, &sfxSlot);
supported = false;
return;
}
//! Load defaults
CommitEffects();
if (!CheckError(" EFX")) {
LOG_L(L_ERROR, " Initializing EFX failed!");
alAuxiliaryEffectSloti(sfxSlot, AL_EFFECTSLOT_EFFECT, AL_EFFECT_NULL);
alDeleteFilters(1, &sfxFilter);
alDeleteEffects(1, &sfxReverb);
alDeleteAuxiliaryEffectSlots(1, &sfxSlot);
supported = false;
return;
}
//! User may disable it (performance reasons?)
enabled = configHandler->GetBool("UseEFX");
LOG(" EFX Enabled: %s", (enabled ? "yes" : "no"));
if (enabled) {
LOG_L(L_DEBUG, " EFX MaxSlots: %i", maxSlots);
LOG_L(L_DEBUG, " EFX MaxSlotsPerSource: %i", maxSlotsPerSource);
}
configHandler->NotifyOnChange(this);
}
static ALboolean CDECL wine_alIsEffect(ALuint eid)
{
return alIsEffect(eid);
}
ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(ALEffect->type == AL_EFFECT_EAXREVERB)
{
switch(param)
{
case AL_EAXREVERB_DENSITY:
*pflValue = ALEffect->Reverb.Density;
break;
case AL_EAXREVERB_DIFFUSION:
*pflValue = ALEffect->Reverb.Diffusion;
break;
case AL_EAXREVERB_GAIN:
*pflValue = ALEffect->Reverb.Gain;
break;
case AL_EAXREVERB_GAINHF:
*pflValue = ALEffect->Reverb.GainHF;
break;
case AL_EAXREVERB_GAINLF:
*pflValue = ALEffect->Reverb.GainLF;
break;
case AL_EAXREVERB_DECAY_TIME:
*pflValue = ALEffect->Reverb.DecayTime;
break;
case AL_EAXREVERB_DECAY_HFRATIO:
*pflValue = ALEffect->Reverb.DecayHFRatio;
break;
case AL_EAXREVERB_DECAY_LFRATIO:
*pflValue = ALEffect->Reverb.DecayLFRatio;
break;
case AL_EAXREVERB_REFLECTIONS_GAIN:
*pflValue = ALEffect->Reverb.ReflectionsGain;
break;
case AL_EAXREVERB_REFLECTIONS_DELAY:
*pflValue = ALEffect->Reverb.ReflectionsDelay;
break;
case AL_EAXREVERB_LATE_REVERB_GAIN:
*pflValue = ALEffect->Reverb.LateReverbGain;
break;
case AL_EAXREVERB_LATE_REVERB_DELAY:
*pflValue = ALEffect->Reverb.LateReverbDelay;
break;
case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
*pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
break;
case AL_EAXREVERB_ECHO_TIME:
*pflValue = ALEffect->Reverb.EchoTime;
break;
case AL_EAXREVERB_ECHO_DEPTH:
*pflValue = ALEffect->Reverb.EchoDepth;
break;
case AL_EAXREVERB_MODULATION_TIME:
*pflValue = ALEffect->Reverb.ModulationTime;
break;
case AL_EAXREVERB_MODULATION_DEPTH:
*pflValue = ALEffect->Reverb.ModulationDepth;
break;
case AL_EAXREVERB_HFREFERENCE:
*pflValue = ALEffect->Reverb.HFReference;
break;
case AL_EAXREVERB_LFREFERENCE:
*pflValue = ALEffect->Reverb.LFReference;
break;
case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
*pflValue = ALEffect->Reverb.RoomRolloffFactor;
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DENSITY:
*pflValue = ALEffect->Reverb.Density;
break;
case AL_REVERB_DIFFUSION:
*pflValue = ALEffect->Reverb.Diffusion;
break;
case AL_REVERB_GAIN:
*pflValue = ALEffect->Reverb.Gain;
break;
case AL_REVERB_GAINHF:
*pflValue = ALEffect->Reverb.GainHF;
break;
case AL_REVERB_DECAY_TIME:
*pflValue = ALEffect->Reverb.DecayTime;
break;
case AL_REVERB_DECAY_HFRATIO:
*pflValue = ALEffect->Reverb.DecayHFRatio;
break;
case AL_REVERB_REFLECTIONS_GAIN:
*pflValue = ALEffect->Reverb.ReflectionsGain;
break;
case AL_REVERB_REFLECTIONS_DELAY:
*pflValue = ALEffect->Reverb.ReflectionsDelay;
break;
case AL_REVERB_LATE_REVERB_GAIN:
*pflValue = ALEffect->Reverb.LateReverbGain;
break;
case AL_REVERB_LATE_REVERB_DELAY:
*pflValue = ALEffect->Reverb.LateReverbDelay;
break;
case AL_REVERB_AIR_ABSORPTION_GAINHF:
*pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
break;
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
*pflValue = ALEffect->Reverb.RoomRolloffFactor;
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
case AL_ECHO_DELAY:
*pflValue = ALEffect->Echo.Delay;
break;
case AL_ECHO_LRDELAY:
*pflValue = ALEffect->Echo.LRDelay;
break;
case AL_ECHO_DAMPING:
*pflValue = ALEffect->Echo.Damping;
break;
case AL_ECHO_FEEDBACK:
*pflValue = ALEffect->Echo.Feedback;
break;
case AL_ECHO_SPREAD:
*pflValue = ALEffect->Echo.Spread;
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(ALEffect->type == AL_EFFECT_EAXREVERB)
{
switch(param)
{
case AL_EAXREVERB_DENSITY:
case AL_EAXREVERB_DIFFUSION:
case AL_EAXREVERB_GAIN:
case AL_EAXREVERB_GAINHF:
case AL_EAXREVERB_GAINLF:
case AL_EAXREVERB_DECAY_TIME:
case AL_EAXREVERB_DECAY_HFRATIO:
case AL_EAXREVERB_DECAY_LFRATIO:
case AL_EAXREVERB_REFLECTIONS_GAIN:
case AL_EAXREVERB_REFLECTIONS_DELAY:
case AL_EAXREVERB_LATE_REVERB_GAIN:
case AL_EAXREVERB_LATE_REVERB_DELAY:
case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
case AL_EAXREVERB_ECHO_TIME:
case AL_EAXREVERB_ECHO_DEPTH:
case AL_EAXREVERB_MODULATION_TIME:
case AL_EAXREVERB_MODULATION_DEPTH:
case AL_EAXREVERB_HFREFERENCE:
case AL_EAXREVERB_LFREFERENCE:
case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
alEffectf(effect, param, pflValues[0]);
break;
case AL_EAXREVERB_REFLECTIONS_PAN:
if(!isnan(pflValues[0]) && !isnan(pflValues[1]) && !isnan(pflValues[2]))
{
ALEffect->Reverb.ReflectionsPan[0] = pflValues[0];
ALEffect->Reverb.ReflectionsPan[1] = pflValues[1];
ALEffect->Reverb.ReflectionsPan[2] = pflValues[2];
}
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_LATE_REVERB_PAN:
if(!isnan(pflValues[0]) && !isnan(pflValues[1]) && !isnan(pflValues[2]))
{
ALEffect->Reverb.LateReverbPan[0] = pflValues[0];
ALEffect->Reverb.LateReverbPan[1] = pflValues[1];
ALEffect->Reverb.LateReverbPan[2] = pflValues[2];
}
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DENSITY:
case AL_REVERB_DIFFUSION:
case AL_REVERB_GAIN:
case AL_REVERB_GAINHF:
case AL_REVERB_DECAY_TIME:
case AL_REVERB_DECAY_HFRATIO:
case AL_REVERB_REFLECTIONS_GAIN:
case AL_REVERB_REFLECTIONS_DELAY:
case AL_REVERB_LATE_REVERB_GAIN:
case AL_REVERB_LATE_REVERB_DELAY:
case AL_REVERB_AIR_ABSORPTION_GAINHF:
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
alEffectf(effect, param, pflValues[0]);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
case AL_ECHO_DELAY:
case AL_ECHO_LRDELAY:
case AL_ECHO_DAMPING:
case AL_ECHO_FEEDBACK:
case AL_ECHO_SPREAD:
alEffectf(effect, param, pflValues[0]);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(ALEffect->type == AL_EFFECT_EAXREVERB)
{
switch(param)
{
case AL_EAXREVERB_DENSITY:
if(flValue >= AL_EAXREVERB_MIN_DENSITY &&
flValue <= AL_EAXREVERB_MAX_DENSITY)
ALEffect->Reverb.Density = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_DIFFUSION:
if(flValue >= AL_EAXREVERB_MIN_DIFFUSION &&
flValue <= AL_EAXREVERB_MAX_DIFFUSION)
ALEffect->Reverb.Diffusion = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_GAIN:
if(flValue >= AL_EAXREVERB_MIN_GAIN &&
flValue <= AL_EAXREVERB_MAX_GAIN)
ALEffect->Reverb.Gain = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_GAINHF:
if(flValue >= AL_EAXREVERB_MIN_GAINHF &&
flValue <= AL_EAXREVERB_MAX_GAIN)
ALEffect->Reverb.GainHF = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_GAINLF:
if(flValue >= AL_EAXREVERB_MIN_GAINLF &&
flValue <= AL_EAXREVERB_MAX_GAINLF)
ALEffect->Reverb.GainLF = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_DECAY_TIME:
if(flValue >= AL_EAXREVERB_MIN_DECAY_TIME &&
flValue <= AL_EAXREVERB_MAX_DECAY_TIME)
ALEffect->Reverb.DecayTime = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_DECAY_HFRATIO:
if(flValue >= AL_EAXREVERB_MIN_DECAY_HFRATIO &&
flValue <= AL_EAXREVERB_MAX_DECAY_HFRATIO)
ALEffect->Reverb.DecayHFRatio = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_DECAY_LFRATIO:
if(flValue >= AL_EAXREVERB_MIN_DECAY_LFRATIO &&
flValue <= AL_EAXREVERB_MAX_DECAY_LFRATIO)
ALEffect->Reverb.DecayLFRatio = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_REFLECTIONS_GAIN:
if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN &&
flValue <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN)
ALEffect->Reverb.ReflectionsGain = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_REFLECTIONS_DELAY:
if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY &&
flValue <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY)
ALEffect->Reverb.ReflectionsDelay = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_LATE_REVERB_GAIN:
if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN &&
flValue <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN)
ALEffect->Reverb.LateReverbGain = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_LATE_REVERB_DELAY:
if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY &&
flValue <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY)
ALEffect->Reverb.LateReverbDelay = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
if(flValue >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF &&
flValue <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF)
ALEffect->Reverb.AirAbsorptionGainHF = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_ECHO_TIME:
if(flValue >= AL_EAXREVERB_MIN_ECHO_TIME &&
flValue <= AL_EAXREVERB_MAX_ECHO_TIME)
ALEffect->Reverb.EchoTime = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_ECHO_DEPTH:
if(flValue >= AL_EAXREVERB_MIN_ECHO_DEPTH &&
flValue <= AL_EAXREVERB_MAX_ECHO_DEPTH)
ALEffect->Reverb.EchoDepth = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_MODULATION_TIME:
if(flValue >= AL_EAXREVERB_MIN_MODULATION_TIME &&
flValue <= AL_EAXREVERB_MAX_MODULATION_TIME)
ALEffect->Reverb.ModulationTime = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_MODULATION_DEPTH:
if(flValue >= AL_EAXREVERB_MIN_MODULATION_DEPTH &&
flValue <= AL_EAXREVERB_MAX_MODULATION_DEPTH)
ALEffect->Reverb.ModulationDepth = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_HFREFERENCE:
if(flValue >= AL_EAXREVERB_MIN_HFREFERENCE &&
flValue <= AL_EAXREVERB_MAX_HFREFERENCE)
ALEffect->Reverb.HFReference = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_LFREFERENCE:
if(flValue >= AL_EAXREVERB_MIN_LFREFERENCE &&
flValue <= AL_EAXREVERB_MAX_LFREFERENCE)
ALEffect->Reverb.LFReference = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
if(flValue >= 0.0f && flValue <= 10.0f)
ALEffect->Reverb.RoomRolloffFactor = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DENSITY:
if(flValue >= AL_REVERB_MIN_DENSITY &&
flValue <= AL_REVERB_MAX_DENSITY)
ALEffect->Reverb.Density = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_DIFFUSION:
if(flValue >= AL_REVERB_MIN_DIFFUSION &&
flValue <= AL_REVERB_MAX_DIFFUSION)
ALEffect->Reverb.Diffusion = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_GAIN:
if(flValue >= AL_REVERB_MIN_GAIN &&
flValue <= AL_REVERB_MAX_GAIN)
ALEffect->Reverb.Gain = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_GAINHF:
if(flValue >= AL_REVERB_MIN_GAINHF &&
flValue <= AL_REVERB_MAX_GAINHF)
ALEffect->Reverb.GainHF = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_DECAY_TIME:
if(flValue >= AL_REVERB_MIN_DECAY_TIME &&
flValue <= AL_REVERB_MAX_DECAY_TIME)
ALEffect->Reverb.DecayTime = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_DECAY_HFRATIO:
if(flValue >= AL_REVERB_MIN_DECAY_HFRATIO &&
flValue <= AL_REVERB_MAX_DECAY_HFRATIO)
ALEffect->Reverb.DecayHFRatio = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_REFLECTIONS_GAIN:
if(flValue >= AL_REVERB_MIN_REFLECTIONS_GAIN &&
flValue <= AL_REVERB_MAX_REFLECTIONS_GAIN)
ALEffect->Reverb.ReflectionsGain = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_REFLECTIONS_DELAY:
if(flValue >= AL_REVERB_MIN_REFLECTIONS_DELAY &&
flValue <= AL_REVERB_MAX_REFLECTIONS_DELAY)
ALEffect->Reverb.ReflectionsDelay = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_LATE_REVERB_GAIN:
if(flValue >= AL_REVERB_MIN_LATE_REVERB_GAIN &&
flValue <= AL_REVERB_MAX_LATE_REVERB_GAIN)
ALEffect->Reverb.LateReverbGain = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_LATE_REVERB_DELAY:
if(flValue >= AL_REVERB_MIN_LATE_REVERB_DELAY &&
flValue <= AL_REVERB_MAX_LATE_REVERB_DELAY)
ALEffect->Reverb.LateReverbDelay = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_AIR_ABSORPTION_GAINHF:
if(flValue >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF &&
flValue <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF)
ALEffect->Reverb.AirAbsorptionGainHF = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
if(flValue >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR &&
flValue <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR)
ALEffect->Reverb.RoomRolloffFactor = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
case AL_ECHO_DELAY:
if(flValue >= AL_ECHO_MIN_DELAY && flValue <= AL_ECHO_MAX_DELAY)
ALEffect->Echo.Delay = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_ECHO_LRDELAY:
if(flValue >= AL_ECHO_MIN_LRDELAY && flValue <= AL_ECHO_MAX_LRDELAY)
ALEffect->Echo.LRDelay = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_ECHO_DAMPING:
if(flValue >= AL_ECHO_MIN_DAMPING && flValue <= AL_ECHO_MAX_DAMPING)
ALEffect->Echo.Damping = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_ECHO_FEEDBACK:
if(flValue >= AL_ECHO_MIN_FEEDBACK && flValue <= AL_ECHO_MAX_FEEDBACK)
ALEffect->Echo.Feedback = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
case AL_ECHO_SPREAD:
if(flValue >= AL_ECHO_MIN_SPREAD && flValue <= AL_ECHO_MAX_SPREAD)
ALEffect->Echo.Spread = flValue;
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (effect && alIsEffect(effect))
{
ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
if(param == AL_EFFECT_TYPE)
{
ALboolean isOk = (iValue == AL_EFFECT_NULL ||
(iValue == AL_EFFECT_EAXREVERB && !DisabledEffects[EAXREVERB]) ||
(iValue == AL_EFFECT_REVERB && !DisabledEffects[REVERB]) ||
(iValue == AL_EFFECT_ECHO && !DisabledEffects[ECHO]));
if(isOk)
InitEffectParams(ALEffect, iValue);
else
alSetError(AL_INVALID_VALUE);
}
else if(ALEffect->type == AL_EFFECT_EAXREVERB)
{
switch(param)
{
case AL_EAXREVERB_DECAY_HFLIMIT:
if(iValue >= AL_EAXREVERB_MIN_DECAY_HFLIMIT &&
iValue <= AL_EAXREVERB_MAX_DECAY_HFLIMIT)
ALEffect->Reverb.DecayHFLimit = iValue;
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DECAY_HFLIMIT:
if(iValue >= AL_REVERB_MIN_DECAY_HFLIMIT &&
iValue <= AL_REVERB_MAX_DECAY_HFLIMIT)
ALEffect->Reverb.DecayHFLimit = iValue;
else
alSetError(AL_INVALID_VALUE);
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_ENUM);
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}