AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
{
ALCdevice *device;
ALCcontext *context;
ALeffect *effect;
ALsizei i;
context = GetContextRef();
if(!context) return;
device = context->Device;
LockEffectList(device);
if(n < 0)
SETERR_GOTO(context, AL_INVALID_VALUE, done, "Deleting %d effects", n);
for(i = 0;i < n;i++)
{
if(effects[i] && LookupEffect(device, effects[i]) == NULL)
SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect ID %u", effects[i]);
}
for(i = 0;i < n;i++)
{
if((effect=LookupEffect(device, effects[i])) != NULL)
FreeEffect(device, effect);
}
done:
UnlockEffectList(device);
ALCcontext_DecRef(context);
}
AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
{
ALCcontext *Context;
ALCdevice *device;
ALeffect *ALEffect;
ALboolean Failed;
ALsizei i;
Context = GetContextSuspended();
if(!Context) return;
Failed = AL_TRUE;
device = Context->Device;
if(n < 0)
alSetError(Context, AL_INVALID_VALUE);
else
{
Failed = AL_FALSE;
// Check that all effects are valid
for(i = 0;i < n;i++)
{
if(!effects[i])
continue;
if(LookupEffect(device->EffectMap, effects[i]) == NULL)
{
alSetError(Context, AL_INVALID_NAME);
Failed = AL_TRUE;
break;
}
}
}
if(!Failed)
{
// All effects are valid
for(i = 0;i < n;i++)
{
// Recheck that the effect is valid, because there could be duplicated names
if((ALEffect=LookupEffect(device->EffectMap, effects[i])) == NULL)
continue;
RemoveUIntMapKey(&device->EffectMap, ALEffect->effect);
ALTHUNK_REMOVEENTRY(ALEffect->effect);
memset(ALEffect, 0, sizeof(ALeffect));
free(ALEffect);
}
}
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *values)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
switch(param)
{
case AL_EFFECT_TYPE:
alEffecti(effect, param, values[0]);
return;
}
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
LockEffectList(Device);
if((ALEffect=LookupEffect(Device, effect)) == NULL)
alSetError(Context, AL_INVALID_NAME, "Invalid effect ID %u", effect);
else
{
/* Call the appropriate handler */
ALeffect_setParamiv(ALEffect, Context, param, values);
}
UnlockEffectList(Device);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *value)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device, effect)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else
{
if(param == AL_EFFECT_TYPE)
*value = ALEffect->type;
else
{
/* Call the appropriate handler */
V(ALEffect,getParami)(Context, param, value);
}
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *values)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
switch(param)
{
case AL_EFFECT_TYPE:
alGetEffecti(effect, param, values);
return;
}
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device, effect)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else
{
/* Call the appropriate handler */
V(ALEffect,getParamiv)(Context, param, values);
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
{
ALCcontext *Context;
ALeffect *Effect;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALCdevice *device = Context->Device;
CHECK_VALUE(Context, n >= 0);
for(i = 0;i < n;i++)
{
if(effects[i] && LookupEffect(device, effects[i]) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
}
for(i = 0;i < n;i++)
{
if((Effect=RemoveEffect(device, effects[i])) == NULL)
continue;
FreeThunkEntry(Effect->id);
memset(Effect, 0, sizeof(*Effect));
free(Effect);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
{
ALCdevice *device;
ALCcontext *context;
ALeffect *effect;
ALsizei i;
context = GetContextRef();
if(!context) return;
if(!(n >= 0))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
device = context->Device;
for(i = 0;i < n;i++)
{
if(effects[i] && LookupEffect(device, effects[i]) == NULL)
SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
}
for(i = 0;i < n;i++)
{
if((effect=RemoveEffect(device, effects[i])) == NULL)
continue;
FreeThunkEntry(effect->id);
memset(effect, 0, sizeof(*effect));
free(effect);
}
done:
ALCcontext_DecRef(context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
{
ALCdevice *device;
ALCcontext *context;
ALeffectslot *slot;
ALeffect *effect = NULL;
ALenum err;
context = GetContextRef();
if(!context) return;
almtx_lock(&context->PropLock);
LockEffectSlotList(context);
if((slot=LookupEffectSlot(context, effectslot)) == NULL)
SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
switch(param)
{
case AL_EFFECTSLOT_EFFECT:
device = context->Device;
LockEffectList(device);
effect = (value ? LookupEffect(device, value) : NULL);
if(!(value == 0 || effect != NULL))
{
UnlockEffectList(device);
SETERR_GOTO(context, AL_INVALID_VALUE, done, "Invalid effect ID %u", value);
}
err = InitializeEffect(context, slot, effect);
UnlockEffectList(device);
if(err != AL_NO_ERROR)
SETERR_GOTO(context, err, done, "Effect initialization failed");
break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
if(!(value == AL_TRUE || value == AL_FALSE))
SETERR_GOTO(context, AL_INVALID_VALUE, done,
"Effect slot auxiliary send auto out of range");
slot->AuxSendAuto = value;
break;
default:
SETERR_GOTO(context, AL_INVALID_ENUM, done, "Invalid effect slot integer property 0x%04x",
param);
}
DO_UPDATEPROPS();
done:
UnlockEffectSlotList(context);
almtx_unlock(&context->PropLock);
ALCcontext_DecRef(context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
{
ALCdevice *device;
ALCcontext *context;
ALeffectslot *slot;
ALeffect *effect = NULL;
ALenum err;
context = GetContextRef();
if(!context) return;
WriteLock(&context->PropLock);
LockEffectSlotsRead(context);
if((slot=LookupEffectSlot(context, effectslot)) == NULL)
SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
switch(param)
{
case AL_EFFECTSLOT_EFFECT:
device = context->Device;
LockEffectsRead(device);
effect = (value ? LookupEffect(device, value) : NULL);
if(!(value == 0 || effect != NULL))
{
UnlockEffectsRead(device);
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
}
err = InitializeEffect(device, slot, effect);
UnlockEffectsRead(device);
if(err != AL_NO_ERROR)
SET_ERROR_AND_GOTO(context, err, done);
break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
if(!(value == AL_TRUE || value == AL_FALSE))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
slot->AuxSendAuto = value;
UpdateEffectSlotProps(slot);
if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
UpdateAllSourceProps(context);
break;
default:
SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
}
done:
UnlockEffectSlotsRead(context);
WriteUnlock(&context->PropLock);
ALCcontext_DecRef(context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
{
ALCdevice *Device;
ALCcontext *Context;
ALeffectslot *EffectSlot;
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
if((EffectSlot=LookupEffectSlot(Context, effectslot)) != NULL)
{
switch(param)
{
case AL_EFFECTSLOT_EFFECT: {
ALeffect *effect = NULL;
if(iValue == 0 ||
(effect=LookupEffect(Device, iValue)) != NULL)
{
ALenum err;
err = InitializeEffect(Device, EffectSlot, effect);
if(err != AL_NO_ERROR)
alSetError(Context, err);
else
Context->UpdateSources = AL_TRUE;
}
else
alSetError(Context, AL_INVALID_VALUE);
} break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
if(iValue == AL_TRUE || iValue == AL_FALSE)
{
EffectSlot->AuxSendAuto = iValue;
Context->UpdateSources = AL_TRUE;
}
else
alSetError(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_NAME);
ALCcontext_DecRef(Context);
}
AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
{
ALCcontext *Context;
ALboolean result;
Context = GetContextSuspended();
if(!Context) return AL_FALSE;
result = ((!effect || LookupEffect(Context->Device->EffectMap, effect)) ?
AL_TRUE : AL_FALSE);
ProcessContext(Context);
return result;
}
AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
{
ALCcontext *Context;
ALboolean result;
Context = GetContextRef();
if(!Context) return AL_FALSE;
result = ((!effect || LookupEffect(Context->Device, effect)) ?
AL_TRUE : AL_FALSE);
ALCcontext_DecRef(Context);
return result;
}
AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
{
ALCcontext *Context;
ALCdevice *device;
ALeffect *ALEffect;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
device = Context->Device;
if(n < 0)
alSetError(Context, AL_INVALID_VALUE);
else
{
// Check that all effects are valid
for(i = 0;i < n;i++)
{
if(!effects[i])
continue;
if(LookupEffect(device, effects[i]) == NULL)
{
alSetError(Context, AL_INVALID_NAME);
n = 0;
break;
}
}
for(i = 0;i < n;i++)
{
// Recheck that the effect is valid, because there could be duplicated names
if((ALEffect=RemoveEffect(device, effects[i])) == NULL)
continue;
FreeThunkEntry(ALEffect->effect);
memset(ALEffect, 0, sizeof(ALeffect));
free(ALEffect);
}
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
{
ALCdevice *device;
ALCcontext *context;
ALeffectslot *slot;
ALeffect *effect = NULL;
ALenum err;
context = GetContextRef();
if(!context) return;
device = context->Device;
if((slot=LookupEffectSlot(context, effectslot)) == NULL)
SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
switch(param)
{
case AL_EFFECTSLOT_EFFECT:
effect = (value ? LookupEffect(device, value) : NULL);
if(!(value == 0 || effect != NULL))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
err = InitializeEffect(device, slot, effect);
if(err != AL_NO_ERROR)
SET_ERROR_AND_GOTO(context, err, done);
ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
if(!(value == AL_TRUE || value == AL_FALSE))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
slot->AuxSendAuto = value;
ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
break;
default:
SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
}
done:
ALCcontext_DecRef(context);
}
AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *values)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device, effect)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else
{
/* Call the appropriate handler */
V(ALEffect,getParamfv)(Context, param, values);
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device, effect)) != NULL)
{
/* Call the appropriate handler */
ALeffect_GetParamf(ALEffect, Context, param, pflValue);
}
else
alSetError(Context, AL_INVALID_NAME);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
{
ALCcontext *Context;
ALeffectslot *Slot;
ALeffect *effect = NULL;
ALenum err;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALCdevice *device = Context->Device;
if((Slot=LookupEffectSlot(Context, effectslot)) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
switch(param)
{
case AL_EFFECTSLOT_EFFECT:
CHECK_VALUE(Context, value == 0 || (effect=LookupEffect(device, value)) != NULL);
err = InitializeEffect(device, Slot, effect);
if(err != AL_NO_ERROR)
al_throwerr(Context, err);
Context->UpdateSources = AL_TRUE;
break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
CHECK_VALUE(Context, value == AL_TRUE || value == AL_FALSE);
Slot->AuxSendAuto = value;
Context->UpdateSources = AL_TRUE;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
LockEffectList(Device);
if((ALEffect=LookupEffect(Device, effect)) == NULL)
alSetError(Context, AL_INVALID_NAME, "Invalid effect ID %u", effect);
else
{
if(param == AL_EFFECT_TYPE)
{
ALboolean isOk = (value == AL_EFFECT_NULL);
ALint i;
for(i = 0;!isOk && i < EFFECTLIST_SIZE;i++)
{
if(value == EffectList[i].val &&
!DisabledEffects[EffectList[i].type])
isOk = AL_TRUE;
}
if(isOk)
InitEffectParams(ALEffect, value);
else
alSetError(Context, AL_INVALID_VALUE, "Effect type 0x%04x not supported", value);
}
else
{
/* Call the appropriate handler */
ALeffect_setParami(ALEffect, Context, param, value);
}
}
UnlockEffectList(Device);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device, effect)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else
{
if(param == AL_EFFECT_TYPE)
{
ALboolean isOk = (value == AL_EFFECT_NULL);
ALint i;
for(i = 0;!isOk && EffectList[i].val;i++)
{
if(value == EffectList[i].val &&
!DisabledEffects[EffectList[i].type])
isOk = AL_TRUE;
}
if(isOk)
InitEffectParams(ALEffect, value);
else
alSetError(Context, AL_INVALID_VALUE);
}
else
{
/* Call the appropriate handler */
V(ALEffect,setParami)(Context, param, value);
}
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *value)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextRef();
if(!Context) return;
Device = Context->Device;
LockEffectList(Device);
if((ALEffect=LookupEffect(Device, effect)) == NULL)
alSetError(Context, AL_INVALID_NAME, "Invalid effect ID %u", effect);
else
{
/* Call the appropriate handler */
ALeffect_getParamf(ALEffect, Context, param, value);
}
UnlockEffectList(Device);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
{
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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, AL_INVALID_VALUE);
break;
case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
if(flValue >= 0.0f && flValue <= 10.0f)
ALEffect->Reverb.RoomRolloffFactor = flValue;
else
alSetError(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, 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(Context, 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(Context, 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(Context, 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(Context, 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(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
{
switch(param)
{
case AL_RING_MODULATOR_FREQUENCY:
if(flValue >= AL_RING_MODULATOR_MIN_FREQUENCY &&
flValue <= AL_RING_MODULATOR_MAX_FREQUENCY)
ALEffect->Modulator.Frequency = flValue;
else
alSetError(Context, AL_INVALID_VALUE);
break;
case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
if(flValue >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF &&
flValue <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF)
ALEffect->Modulator.HighPassCutoff = flValue;
else
alSetError(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_ENUM);
}
else
alSetError(Context, AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
{
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(Context, 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(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, 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(Context, 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(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
{
switch(param)
{
case AL_RING_MODULATOR_FREQUENCY:
case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
alEffectf(effect, param, pflValues[0]);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_ENUM);
}
else
alSetError(Context, AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
{
if(param == AL_EFFECT_TYPE)
{
*piValue = ALEffect->type;
}
else if(ALEffect->type == AL_EFFECT_EAXREVERB)
{
switch(param)
{
case AL_EAXREVERB_DECAY_HFLIMIT:
*piValue = ALEffect->Reverb.DecayHFLimit;
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_REVERB)
{
switch(param)
{
case AL_REVERB_DECAY_HFLIMIT:
*piValue = ALEffect->Reverb.DecayHFLimit;
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
{
switch(param)
{
case AL_RING_MODULATOR_FREQUENCY:
*piValue = (ALint)ALEffect->Modulator.Frequency;
break;
case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
*piValue = (ALint)ALEffect->Modulator.HighPassCutoff;
break;
case AL_RING_MODULATOR_WAVEFORM:
*piValue = ALEffect->Modulator.Waveform;
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_ENUM);
}
else
alSetError(Context, AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
{
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(Context, 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(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
{
switch(param)
{
case AL_RING_MODULATOR_FREQUENCY:
case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
case AL_RING_MODULATOR_WAVEFORM:
alGetEffecti(effect, param, piValues);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_ENUM);
}
else
alSetError(Context, AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
{
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(Context, 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(Context, 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(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
{
switch(param)
{
case AL_RING_MODULATOR_FREQUENCY:
*pflValue = ALEffect->Modulator.Frequency;
break;
case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
*pflValue = ALEffect->Modulator.HighPassCutoff;
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_ENUM);
}
else
alSetError(Context, AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
{
ALCcontext *Context;
ALCdevice *Device;
ALeffect *ALEffect;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
{
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]) ||
(iValue == AL_EFFECT_RING_MODULATOR && !DisabledEffects[MODULATOR]));
if(isOk)
InitEffectParams(ALEffect, iValue);
else
alSetError(Context, 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(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, 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(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_ECHO)
{
switch(param)
{
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
{
switch(param)
{
case AL_RING_MODULATOR_FREQUENCY:
case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
alEffectf(effect, param, (ALfloat)iValue);
break;
case AL_RING_MODULATOR_WAVEFORM:
if(iValue >= AL_RING_MODULATOR_MIN_WAVEFORM &&
iValue <= AL_RING_MODULATOR_MAX_WAVEFORM)
ALEffect->Modulator.Waveform = iValue;
else
alSetError(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_ENUM);
}
else
alSetError(Context, AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
{
ALCdevice *Device;
ALCcontext *Context;
ALboolean updateSources = AL_FALSE;
ALeffectslot *EffectSlot;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
{
switch(param)
{
case AL_EFFECTSLOT_EFFECT: {
ALeffect *effect = NULL;
if(iValue == 0 ||
(effect=LookupEffect(Device->EffectMap, iValue)) != NULL)
{
InitializeEffect(Context, EffectSlot, effect);
updateSources = AL_TRUE;
}
else
alSetError(Context, AL_INVALID_VALUE);
} break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
if(iValue == AL_TRUE || iValue == AL_FALSE)
{
EffectSlot->AuxSendAuto = iValue;
updateSources = AL_TRUE;
}
else
alSetError(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_NAME);
// Force updating the sources that use this slot, since it affects the
// sending parameters
if(updateSources)
{
ALsizei pos;
for(pos = 0;pos < Context->SourceMap.size;pos++)
{
ALsource *source = Context->SourceMap.array[pos].value;
ALuint i;
for(i = 0;i < Device->NumAuxSends;i++)
{
if(!source->Send[i].Slot ||
source->Send[i].Slot->effectslot != effectslot)
continue;
source->NeedsUpdate = AL_TRUE;
break;
}
}
}
ProcessContext(Context);
}
