AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat value)
{
ALCcontext *Context;
ALeffectslot *Slot;
Context = GetContextRef();
if(!Context) return;
al_try
{
if((Slot=LookupEffectSlot(Context, effectslot)) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
switch(param)
{
case AL_EFFECTSLOT_GAIN:
CHECK_VALUE(Context, value >= 0.0f && value <= 1.0f);
Slot->Gain = value;
Slot->NeedsUpdate = AL_TRUE;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *values)
{
ALCcontext *Context;
switch(param)
{
case AL_EFFECTSLOT_EFFECT:
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
alAuxiliaryEffectSloti(effectslot, param, values[0]);
return;
}
Context = GetContextRef();
if(!Context) return;
al_try
{
if(LookupEffectSlot(Context, effectslot) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
switch(param)
{
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value)
{
ALCcontext *Context;
ALeffectslot *Slot;
Context = GetContextRef();
if(!Context) return;
al_try
{
if((Slot=LookupEffectSlot(Context, effectslot)) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
switch(param)
{
case AL_EFFECTSLOT_GAIN:
*value = Slot->Gain;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *value)
{
ALCcontext *Context;
ALeffectslot *Slot;
Context = GetContextRef();
if(!Context) return;
al_try
{
if((Slot=LookupEffectSlot(Context, effectslot)) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
switch(param)
{
case AL_EFFECTSLOT_EFFECT:
*value = Slot->effect.id;
break;
case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
*value = Slot->AuxSendAuto;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *values)
{
ALCcontext *Context;
switch(param)
{
case AL_EFFECTSLOT_GAIN:
alGetAuxiliaryEffectSlotf(effectslot, param, values);
return;
}
Context = GetContextRef();
if(!Context) return;
al_try
{
if(LookupEffectSlot(Context, effectslot) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
switch(param)
{
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
{
ALCcontext *Context;
ALsizei cur = 0;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALenum err;
CHECK_VALUE(Context, n >= 0);
for(cur = 0;cur < n;cur++)
{
ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
err = AL_OUT_OF_MEMORY;
if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
{
al_free(slot);
al_throwerr(Context, err);
break;
}
err = NewThunkEntry(&slot->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&Context->EffectSlotMap, slot->id, slot);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(slot->id);
ALeffectState_Destroy(slot->EffectState);
al_free(slot);
al_throwerr(Context, err);
}
effectslots[cur] = slot->id;
}
err = AddEffectSlotArray(Context, n, effectslots);
if(err != AL_NO_ERROR)
al_throwerr(Context, err);
}
al_catchany()
{
if(cur > 0)
alDeleteAuxiliaryEffectSlots(cur, effectslots);
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
{
ALCcontext *Context;
ALsizei cur = 0;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALCdevice *device = Context->Device;
ALenum err;
CHECK_VALUE(Context, n >= 0);
for(cur = 0;cur < n;cur++)
{
ALeffect *effect = calloc(1, sizeof(ALeffect));
err = AL_OUT_OF_MEMORY;
if(!effect || (err=InitEffect(effect)) != AL_NO_ERROR)
{
free(effect);
al_throwerr(Context, err);
}
err = NewThunkEntry(&effect->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&device->EffectMap, effect->id, effect);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(effect->id);
memset(effect, 0, sizeof(ALeffect));
free(effect);
al_throwerr(Context, err);
}
effects[cur] = effect->id;
}
}
al_catchany()
{
if(cur > 0)
alDeleteEffects(cur, effects);
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetIntegerv(ALenum pname, ALint *values)
{
ALCcontext *Context;
if(values)
{
switch(pname)
{
case AL_DOPPLER_FACTOR:
case AL_DOPPLER_VELOCITY:
case AL_DISTANCE_MODEL:
case AL_SPEED_OF_SOUND:
case AL_DEFERRED_UPDATES_SOFT:
values[0] = alGetInteger(pname);
return;
}
}
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, values);
switch(pname)
{
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
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 ALboolean AL_APIENTRY alIsEnabled(ALenum capability)
{
ALCcontext *Context;
ALboolean value=AL_FALSE;
Context = GetContextRef();
if(!Context) return AL_FALSE;
al_try
{
switch(capability)
{
case AL_SOURCE_DISTANCE_MODEL:
value = Context->SourceDistanceModel;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
return value;
}
AL_API ALvoid AL_APIENTRY alListenerf(ALenum param, ALfloat value)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
al_try
{
switch(param)
{
case AL_GAIN:
CHECK_VALUE(Context, value >= 0.0f && isfinite(value));
Context->Listener->Gain = value;
Context->UpdateSources = AL_TRUE;
break;
case AL_METERS_PER_UNIT:
CHECK_VALUE(Context, value >= 0.0f && isfinite(value));
Context->Listener->MetersPerUnit = value;
Context->UpdateSources = AL_TRUE;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, value);
switch(param)
{
case AL_GAIN:
*value = Context->Listener->Gain;
break;
case AL_METERS_PER_UNIT:
*value = Context->Listener->MetersPerUnit;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
{
ALCcontext *Context;
switch(param)
{
case AL_POSITION:
case AL_VELOCITY:
alListener3f(param, (ALfloat)value1, (ALfloat)value2, (ALfloat)value3);
return;
}
Context = GetContextRef();
if(!Context) return;
al_try
{
switch(param)
{
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
{
ALCcontext *Context;
ALfilter *Filter;
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(filters[i] && LookupFilter(device, filters[i]) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
}
for(i = 0;i < n;i++)
{
if((Filter=RemoveFilter(device, filters[i])) == NULL)
continue;
FreeThunkEntry(Filter->id);
memset(Filter, 0, sizeof(*Filter));
free(Filter);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
{
ALCcontext *Context;
ALsizei cur = 0;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALCdevice *device = Context->Device;
ALenum err;
CHECK_VALUE(Context, n >= 0);
for(cur = 0;cur < n;cur++)
{
ALfilter *filter = calloc(1, sizeof(ALfilter));
if(!filter)
al_throwerr(Context, AL_OUT_OF_MEMORY);
InitFilterParams(filter, AL_FILTER_NULL);
err = NewThunkEntry(&filter->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&device->FilterMap, filter->id, filter);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(filter->id);
memset(filter, 0, sizeof(ALfilter));
free(filter);
al_throwerr(Context, err);
}
filters[cur] = filter->id;
}
}
al_catchany()
{
if(cur > 0)
alDeleteFilters(cur, filters);
}
al_endtry;
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 alListenerfv(ALenum param, const ALfloat *values)
{
ALCcontext *Context;
if(values)
{
switch(param)
{
case AL_GAIN:
case AL_METERS_PER_UNIT:
alListenerf(param, values[0]);
return;
case AL_POSITION:
case AL_VELOCITY:
alListener3f(param, values[0], values[1], values[2]);
return;
}
}
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, values);
switch(param)
{
case AL_ORIENTATION:
CHECK_VALUE(Context, isfinite(values[0]) && isfinite(values[1]) &&
isfinite(values[2]) && isfinite(values[3]) &&
isfinite(values[4]) && isfinite(values[5]));
LockContext(Context);
/* AT then UP */
Context->Listener->Forward[0] = values[0];
Context->Listener->Forward[1] = values[1];
Context->Listener->Forward[2] = values[2];
Context->Listener->Up[0] = values[3];
Context->Listener->Up[1] = values[4];
Context->Listener->Up[2] = values[5];
Context->UpdateSources = AL_TRUE;
UnlockContext(Context);
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
{
ALCcontext *Context;
ALeffectslot *slot;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, n >= 0);
for(i = 0;i < n;i++)
{
if((slot=LookupEffectSlot(Context, effectslots[i])) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
if(slot->ref != 0)
al_throwerr(Context, AL_INVALID_OPERATION);
}
// All effectslots are valid
for(i = 0;i < n;i++)
{
if((slot=RemoveEffectSlot(Context, effectslots[i])) == NULL)
continue;
FreeThunkEntry(slot->id);
RemoveEffectSlotArray(Context, slot);
ALeffectState_Destroy(slot->EffectState);
memset(slot, 0, sizeof(*slot));
al_free(slot);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum pname)
{
ALCcontext *Context;
ALboolean value=AL_FALSE;
Context = GetContextRef();
if(!Context) return AL_FALSE;
al_try
{
switch(pname)
{
case AL_DOPPLER_FACTOR:
if(Context->DopplerFactor != 0.0f)
value = AL_TRUE;
break;
case AL_DOPPLER_VELOCITY:
if(Context->DopplerVelocity != 0.0f)
value = AL_TRUE;
break;
case AL_DISTANCE_MODEL:
if(Context->DistanceModel == AL_INVERSE_DISTANCE_CLAMPED)
value = AL_TRUE;
break;
case AL_SPEED_OF_SOUND:
if(Context->SpeedOfSound != 0.0f)
value = AL_TRUE;
break;
case AL_DEFERRED_UPDATES_SOFT:
value = Context->DeferUpdates;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
return value;
}
AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values)
{
ALCcontext *Context;
switch(param)
{
case AL_GAIN:
case AL_METERS_PER_UNIT:
alGetListenerf(param, values);
return;
case AL_POSITION:
case AL_VELOCITY:
alGetListener3f(param, values+0, values+1, values+2);
return;
}
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, values);
switch(param)
{
case AL_ORIENTATION:
LockContext(Context);
// AT then UP
values[0] = Context->Listener->Forward[0];
values[1] = Context->Listener->Forward[1];
values[2] = Context->Listener->Forward[2];
values[3] = Context->Listener->Up[0];
values[4] = Context->Listener->Up[1];
values[5] = Context->Listener->Up[2];
UnlockContext(Context);
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALint AL_APIENTRY alGetInteger(ALenum pname)
{
ALCcontext *Context;
ALint value = 0;
Context = GetContextRef();
if(!Context) return 0;
al_try
{
switch(pname)
{
case AL_DOPPLER_FACTOR:
value = (ALint)Context->DopplerFactor;
break;
case AL_DOPPLER_VELOCITY:
value = (ALint)Context->DopplerVelocity;
break;
case AL_DISTANCE_MODEL:
value = (ALint)Context->DistanceModel;
break;
case AL_SPEED_OF_SOUND:
value = (ALint)Context->SpeedOfSound;
break;
case AL_DEFERRED_UPDATES_SOFT:
value = (ALint)Context->DeferUpdates;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
return value;
}
AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values)
{
ALCcontext *Context;
if(values)
{
ALfloat fvals[6];
switch(param)
{
case AL_POSITION:
case AL_VELOCITY:
alListener3f(param, (ALfloat)values[0], (ALfloat)values[1], (ALfloat)values[2]);
return;
case AL_ORIENTATION:
fvals[0] = (ALfloat)values[0];
fvals[1] = (ALfloat)values[1];
fvals[2] = (ALfloat)values[2];
fvals[3] = (ALfloat)values[3];
fvals[4] = (ALfloat)values[4];
fvals[5] = (ALfloat)values[5];
alListenerfv(param, fvals);
return;
}
}
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, values);
switch(param)
{
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
al_try
{
switch(param)
{
case AL_POSITION:
CHECK_VALUE(Context, isfinite(value1) && isfinite(value2) && isfinite(value3));
LockContext(Context);
Context->Listener->Position[0] = value1;
Context->Listener->Position[1] = value2;
Context->Listener->Position[2] = value3;
Context->UpdateSources = AL_TRUE;
UnlockContext(Context);
break;
case AL_VELOCITY:
CHECK_VALUE(Context, isfinite(value1) && isfinite(value2) && isfinite(value3));
LockContext(Context);
Context->Listener->Velocity[0] = value1;
Context->Listener->Velocity[1] = value2;
Context->Listener->Velocity[2] = value3;
Context->UpdateSources = AL_TRUE;
UnlockContext(Context);
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum param, ALint *value)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, value);
switch(param)
{
case AL_PRIORITY_SLOTS:
*value = (ALint)Context->PrioritySlots;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alListeneri(ALenum param, ALint value)
{
ALCcontext *Context;
(void)value;
Context = GetContextRef();
if(!Context) return;
al_try
{
switch(param)
{
case AL_PRIORITY_SLOTS:
Context->PrioritySlots = (ALsizei)value;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, value1 && value2 && value3);
switch (param)
{
case AL_POSITION:
LockContext(Context);
*value1 = (ALint)Context->Listener->Position[0];
*value2 = (ALint)Context->Listener->Position[1];
*value3 = (ALint)Context->Listener->Position[2];
UnlockContext(Context);
break;
case AL_VELOCITY:
LockContext(Context);
*value1 = (ALint)Context->Listener->Velocity[0];
*value2 = (ALint)Context->Listener->Velocity[1];
*value3 = (ALint)Context->Listener->Velocity[2];
UnlockContext(Context);
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alDisable(ALenum capability)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
al_try
{
switch(capability)
{
case AL_SOURCE_DISTANCE_MODEL:
Context->SourceDistanceModel = AL_FALSE;
Context->UpdateSources = AL_TRUE;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API const ALchar* AL_APIENTRY alGetString(ALenum pname)
{
const ALchar *value = NULL;
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return NULL;
al_try
{
switch(pname)
{
case AL_VENDOR:
value = alVendor;
break;
case AL_VERSION:
value = alVersion;
break;
case AL_RENDERER:
value = alRenderer;
break;
case AL_EXTENSIONS:
value = Context->ExtensionList;
break;
case AL_NO_ERROR:
value = alNoError;
break;
case AL_INVALID_NAME:
value = alErrInvalidName;
break;
case AL_INVALID_ENUM:
value = alErrInvalidEnum;
break;
case AL_INVALID_VALUE:
value = alErrInvalidValue;
break;
case AL_INVALID_OPERATION:
value = alErrInvalidOp;
break;
case AL_OUT_OF_MEMORY:
value = alErrOutOfMemory;
break;
default:
al_throwerr(Context, AL_INVALID_ENUM);
}
}
al_endtry;
ALCcontext_DecRef(Context);
return value;
}
