static void reverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
{
switch(param)
{
case AL_REVERB_DENSITY:
*val = effect->Reverb.Density;
break;
case AL_REVERB_DIFFUSION:
*val = effect->Reverb.Diffusion;
break;
case AL_REVERB_GAIN:
*val = effect->Reverb.Gain;
break;
case AL_REVERB_GAINHF:
*val = effect->Reverb.GainHF;
break;
case AL_REVERB_DECAY_TIME:
*val = effect->Reverb.DecayTime;
break;
case AL_REVERB_DECAY_HFRATIO:
*val = effect->Reverb.DecayHFRatio;
break;
case AL_REVERB_REFLECTIONS_GAIN:
*val = effect->Reverb.ReflectionsGain;
break;
case AL_REVERB_REFLECTIONS_DELAY:
*val = effect->Reverb.ReflectionsDelay;
break;
case AL_REVERB_LATE_REVERB_GAIN:
*val = effect->Reverb.LateReverbGain;
break;
case AL_REVERB_LATE_REVERB_DELAY:
*val = effect->Reverb.LateReverbDelay;
break;
case AL_REVERB_AIR_ABSORPTION_GAINHF:
*val = effect->Reverb.AirAbsorptionGainHF;
break;
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
*val = effect->Reverb.RoomRolloffFactor;
break;
default:
alSetError(context, AL_INVALID_ENUM);
break;
}
}
AL_API ALvoid AL_APIENTRY alListener3f(ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
switch(eParam)
{
case AL_POSITION:
if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
{
LockContext(Context);
Context->Listener.Position[0] = flValue1;
Context->Listener.Position[1] = flValue2;
Context->Listener.Position[2] = flValue3;
Context->UpdateSources = AL_TRUE;
UnlockContext(Context);
}
else
alSetError(Context, AL_INVALID_VALUE);
break;
case AL_VELOCITY:
if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
{
LockContext(Context);
Context->Listener.Velocity[0] = flValue1;
Context->Listener.Velocity[1] = flValue2;
Context->Listener.Velocity[2] = flValue3;
Context->UpdateSources = AL_TRUE;
UnlockContext(Context);
}
else
alSetError(Context, AL_INVALID_VALUE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
ALCcontext_DecRef(Context);
}
ALAPI ALvoid ALAPIENTRY alQueuei (ALuint source, ALenum param, ALint value)
{
QueueEntry *ptrQE, *tempPtr;
if (alIsSource(source))
{
switch(param)
{
case AL_BUFFER:
#ifdef MAC_OS_X
ptrQE = (void *)malloc(sizeof(QueueEntry));
memset(ptrQE, 0, sizeof(QueueEntry));
#else
ptrQE = (void *)NewPtrClear(sizeof(QueueEntry));
#endif
ptrQE->bufferNum = value;
ptrQE->processed = AL_FALSE;
ptrQE->pitch = gSource[source].pitch;
ptrQE->gain = gSource[source].gain;
ptrQE->loopDirection = AL_FALSE; // ***** need to implement real loop directions
tempPtr = gSource[source].ptrQueue;
if (tempPtr != NULL)
{
while (tempPtr->pNext != NULL)
{
tempPtr = tempPtr->pNext;
}
tempPtr->pNext = ptrQE;
} else
{
gSource[source].ptrQueue = ptrQE;
}
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
} else
{
alSetError(AL_INVALID_NAME);
}
}
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 void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
{
ALCcontext *Context;
ALfloat flValues[6];
if(plValues)
{
switch(eParam)
{
case AL_POSITION:
case AL_VELOCITY:
alListener3f(eParam, (ALfloat)plValues[0], (ALfloat)plValues[1], (ALfloat)plValues[2]);
return;
case AL_ORIENTATION:
flValues[0] = (ALfloat)plValues[0];
flValues[1] = (ALfloat)plValues[1];
flValues[2] = (ALfloat)plValues[2];
flValues[3] = (ALfloat)plValues[3];
flValues[4] = (ALfloat)plValues[4];
flValues[5] = (ALfloat)plValues[5];
alListenerfv(eParam, flValues);
return;
}
}
Context = GetContextRef();
if(!Context) return;
if(plValues)
{
switch(eParam)
{
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_VALUE);
ALCcontext_DecRef(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 alDeleteFilters(ALsizei n, ALuint *filters)
{
ALCcontext *Context;
ALCdevice *device;
ALfilter *ALFilter;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
device = Context->Device;
if(n < 0)
alSetError(Context, AL_INVALID_VALUE);
else
{
// Check that all filters are valid
for(i = 0;i < n;i++)
{
if(!filters[i])
continue;
if(LookupFilter(device->FilterMap, filters[i]) == NULL)
{
alSetError(Context, AL_INVALID_NAME);
n = 0;
break;
}
}
for(i = 0;i < n;i++)
{
// Recheck that the filter is valid, because there could be duplicated names
if((ALFilter=RemoveFilter(device->FilterMap, filters[i])) == NULL)
continue;
FreeThunkEntry(ALFilter->filter);
memset(ALFilter, 0, sizeof(ALfilter));
free(ALFilter);
}
}
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
{
ALCcontext *pContext;
pContext = GetContextSuspended();
if(!pContext) return;
if(plValues)
{
switch(eParam)
{
case AL_POSITION:
plValues[0] = (ALint)pContext->Listener.Position[0];
plValues[1] = (ALint)pContext->Listener.Position[1];
plValues[2] = (ALint)pContext->Listener.Position[2];
break;
case AL_VELOCITY:
plValues[0] = (ALint)pContext->Listener.Velocity[0];
plValues[1] = (ALint)pContext->Listener.Velocity[1];
plValues[2] = (ALint)pContext->Listener.Velocity[2];
break;
case AL_ORIENTATION:
// AT then UP
plValues[0] = (ALint)pContext->Listener.Forward[0];
plValues[1] = (ALint)pContext->Listener.Forward[1];
plValues[2] = (ALint)pContext->Listener.Forward[2];
plValues[3] = (ALint)pContext->Listener.Up[0];
plValues[4] = (ALint)pContext->Listener.Up[1];
plValues[5] = (ALint)pContext->Listener.Up[2];
break;
default:
alSetError(pContext, AL_INVALID_ENUM);
break;
}
}
else
alSetError(pContext, AL_INVALID_VALUE);
ProcessContext(pContext);
}
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 alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
{
ALCcontext *pContext;
ALbuffer *pBuffer;
ALCdevice *device;
pContext = GetContextSuspended();
if(!pContext) return;
device = pContext->Device;
if(!plValue)
alSetError(pContext, AL_INVALID_VALUE);
else if((pBuffer=LookupBuffer(device->BufferMap, buffer)) == NULL)
alSetError(pContext, AL_INVALID_NAME);
else
{
switch(eParam)
{
case AL_FREQUENCY:
*plValue = pBuffer->frequency;
break;
case AL_BITS:
*plValue = aluBytesFromFormat(pBuffer->format) * 8;
break;
case AL_CHANNELS:
*plValue = aluChannelsFromFormat(pBuffer->format);
break;
case AL_SIZE:
*plValue = pBuffer->size;
break;
default:
alSetError(pContext, AL_INVALID_ENUM);
break;
}
}
ProcessContext(pContext);
}
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 alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
{
ALCcontext *Context;
ALCdevice *Device;
ALfilter *ALFilter;
Context = GetContextSuspended();
if(!Context) return;
Device = Context->Device;
if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
{
switch(ALFilter->type)
{
case AL_FILTER_LOWPASS:
switch(param)
{
case AL_LOWPASS_GAIN:
*pflValue = ALFilter->Gain;
break;
case AL_LOWPASS_GAINHF:
*pflValue = ALFilter->GainHF;
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API void AL_APIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
{
ALCcontext *Context;
switch(eParam)
{
case AL_POSITION:
case AL_VELOCITY:
alGetListener3i(eParam, plValues+0, plValues+1, plValues+2);
return;
}
Context = GetContextRef();
if(!Context) return;
if(plValues)
{
switch(eParam)
{
case AL_ORIENTATION:
LockContext(Context);
// AT then UP
plValues[0] = (ALint)Context->Listener.Forward[0];
plValues[1] = (ALint)Context->Listener.Forward[1];
plValues[2] = (ALint)Context->Listener.Forward[2];
plValues[3] = (ALint)Context->Listener.Up[0];
plValues[4] = (ALint)Context->Listener.Up[1];
plValues[5] = (ALint)Context->Listener.Up[2];
UnlockContext(Context);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_VALUE);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
{
ALCcontext *pContext;
pContext = GetContextSuspended();
if(!pContext) return;
if(plValue)
{
switch(eParam)
{
default:
alSetError(pContext, AL_INVALID_ENUM);
break;
}
}
else
alSetError(pContext, AL_INVALID_VALUE);
ProcessContext(pContext);
}
AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
if(plValue)
{
switch(eParam)
{
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
alSetError(Context, AL_INVALID_VALUE);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetBooleanv(ALenum pname,ALboolean *data)
{
ALCcontext *Context;
Context = GetContextSuspended();
if(!Context) return;
if(data)
{
switch(pname)
{
case AL_DOPPLER_FACTOR:
*data = (ALboolean)((Context->DopplerFactor != int2ALfp(0)) ? AL_TRUE : AL_FALSE);
break;
case AL_DOPPLER_VELOCITY:
*data = (ALboolean)((Context->DopplerVelocity != int2ALfp(0)) ? AL_TRUE : AL_FALSE);
break;
case AL_DISTANCE_MODEL:
*data = (ALboolean)((Context->DistanceModel == AL_INVERSE_DISTANCE_CLAMPED) ? AL_TRUE : AL_FALSE);
break;
case AL_SPEED_OF_SOUND:
*data = (ALboolean)((Context->flSpeedOfSound != int2ALfp(0)) ? AL_TRUE : AL_FALSE);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
{
// data is a NULL pointer
alSetError(Context, AL_INVALID_VALUE);
}
ProcessContext(Context);
}
ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
{
ALCcontext *Context;
Context = alcGetCurrentContext();
SuspendContext(Context);
if (filter && alIsFilter(filter))
{
ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
switch(ALFilter->type)
{
case AL_FILTER_LOWPASS:
switch(param)
{
case AL_LOWPASS_GAIN:
*pflValue = ALFilter->Gain;
break;
case AL_LOWPASS_GAINHF:
*pflValue = ALFilter->GainHF;
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else
alSetError(AL_INVALID_NAME);
ProcessContext(Context);
}
AL_API void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
{
ALCcontext *pContext;
ALfloat flValues[6];
pContext = GetContextSuspended();
if(!pContext) return;
if(plValues)
{
switch(eParam)
{
case AL_POSITION:
case AL_VELOCITY:
flValues[0] = (ALfloat)plValues[0];
flValues[1] = (ALfloat)plValues[1];
flValues[2] = (ALfloat)plValues[2];
alListenerfv(eParam, flValues);
break;
case AL_ORIENTATION:
flValues[0] = (ALfloat)plValues[0];
flValues[1] = (ALfloat)plValues[1];
flValues[2] = (ALfloat)plValues[2];
flValues[3] = (ALfloat)plValues[3];
flValues[4] = (ALfloat)plValues[4];
flValues[5] = (ALfloat)plValues[5];
alListenerfv(eParam, flValues);
break;
default:
alSetError(pContext, AL_INVALID_ENUM);
break;
}
}
else
alSetError(pContext, AL_INVALID_VALUE);
ProcessContext(pContext);
}
AL_API ALvoid AL_APIENTRY alGetFloatv(ALenum pname,ALfloat *data)
{
ALCcontext *Context;
Context = GetContextSuspended();
if(!Context) return;
if(data)
{
switch(pname)
{
case AL_DOPPLER_FACTOR:
*data = ALfp2float(Context->DopplerFactor);
break;
case AL_DOPPLER_VELOCITY:
*data = ALfp2float(Context->DopplerVelocity);
break;
case AL_DISTANCE_MODEL:
*data = (float)Context->DistanceModel;
break;
case AL_SPEED_OF_SOUND:
*data = ALfp2float(Context->flSpeedOfSound);
break;
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
{
// data is a NULL pointer
alSetError(Context, AL_INVALID_VALUE);
}
ProcessContext(Context);
}
ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
{
ALCcontext *Context;
Context = GetContextSuspended();
if(!Context) return;
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);
}
static void ded_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
{
switch(param)
{
case AL_DEDICATED_GAIN:
*val = effect->Dedicated.Gain;
break;
default:
alSetError(context, AL_INVALID_ENUM);
break;
}
}
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);
}
static void mod_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
{
switch(param)
{
case AL_RING_MODULATOR_FREQUENCY:
case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
mod_SetParamf(effect, context, param, (ALfloat)val);
break;
case AL_RING_MODULATOR_WAVEFORM:
if(val >= AL_RING_MODULATOR_MIN_WAVEFORM &&
val <= AL_RING_MODULATOR_MAX_WAVEFORM)
effect->Modulator.Waveform = val;
else
alSetError(context, AL_INVALID_VALUE);
break;
default:
alSetError(context, AL_INVALID_ENUM);
break;
}
}
AL_API ALvoid AL_APIENTRY alUnmapDatabufferEXT(ALuint uiBuffer)
{
ALCcontext *pContext;
ALdatabuffer *pBuffer;
ALCdevice *Device;
pContext = GetContextSuspended();
if(!pContext) return;
Device = pContext->Device;
if((pBuffer=LookupDatabuffer(Device->DatabufferMap, uiBuffer)) != NULL)
{
if(pBuffer->state == MAPPED)
pBuffer->state = UNMAPPED;
else
alSetError(pContext, AL_INVALID_OPERATION);
}
else
alSetError(pContext, AL_INVALID_NAME);
ProcessContext(pContext);
}
AL_API ALvoid* AL_APIENTRY alMapDatabufferEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALenum access)
{
ALCcontext *pContext;
ALdatabuffer *pBuffer;
ALvoid *ret = NULL;
ALCdevice *Device;
pContext = GetContextSuspended();
if(!pContext) return NULL;
Device = pContext->Device;
if((pBuffer=LookupDatabuffer(Device->DatabufferMap, uiBuffer)) != NULL)
{
if(start >= 0 && length >= 0 && start+length <= pBuffer->size)
{
if(access == AL_READ_ONLY_EXT || access == AL_WRITE_ONLY_EXT ||
access == AL_READ_WRITE_EXT)
{
if(pBuffer->state == UNMAPPED)
{
ret = pBuffer->data + start;
pBuffer->state = MAPPED;
}
else
alSetError(pContext, AL_INVALID_OPERATION);
}
else
alSetError(pContext, AL_INVALID_ENUM);
}
else
alSetError(pContext, AL_INVALID_VALUE);
}
else
alSetError(pContext, AL_INVALID_NAME);
ProcessContext(pContext);
return ret;
}
static void reverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
{
switch(param)
{
case AL_REVERB_DECAY_HFLIMIT:
*val = effect->Reverb.DecayHFLimit;
break;
default:
alSetError(context, AL_INVALID_ENUM);
break;
}
}
ALAPI ALvoid ALAPIENTRY alGetSource3f (ALuint source, ALenum pname, ALfloat *v1, ALfloat *v2, ALfloat *v3)
{
switch(pname)
{
case AL_POSITION:
*v1 = gSource[source].Position[0];
*v2 = gSource[source].Position[1];
*v3 = gSource[source].Position[2];
break;
case AL_DIRECTION:
alSetError(AL_INVALID_ENUM); // cone functions not implemented yet
break;
case AL_VELOCITY:
*v1 = gSource[source].Velocity[0];
*v2 = gSource[source].Velocity[1];
*v3 = gSource[source].Velocity[2];
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
ALAPI ALvoid ALAPIENTRY alSourcefv (ALuint source, ALenum pname, ALfloat *values)
{
switch(pname)
{
case AL_POSITION:
gSource[source].Position[0]=values[0];
gSource[source].Position[1]=values[1];
gSource[source].Position[2]=values[2];
break;
case AL_DIRECTION:
alSetError(AL_INVALID_ENUM); // cone functions not implemented yet
break;
case AL_VELOCITY:
gSource[source].Velocity[0]=values[0];
gSource[source].Velocity[1]=values[1];
gSource[source].Velocity[2]=values[2];
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
{
ALCcontext *pContext;
ALCdevice *device;
ALbuffer *ALBuf;
pContext = GetContextSuspended();
if(!pContext) return;
device = pContext->Device;
if(!plValues)
alSetError(pContext, AL_INVALID_VALUE);
else if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
alSetError(pContext, AL_INVALID_NAME);
else
{
switch(eParam)
{
case AL_FREQUENCY:
case AL_BITS:
case AL_CHANNELS:
case AL_SIZE:
alGetBufferi(buffer, eParam, plValues);
break;
case AL_LOOP_POINTS:
plValues[0] = ALBuf->LoopStart;
plValues[1] = ALBuf->LoopEnd;
break;
default:
alSetError(pContext, AL_INVALID_ENUM);
break;
}
}
ProcessContext(pContext);
}
AL_API ALvoid AL_APIENTRY alGetIntegerv(ALenum pname,ALint *data)
{
ALCcontext *Context;
if(data)
{
switch(pname)
{
case AL_DOPPLER_FACTOR:
case AL_DOPPLER_VELOCITY:
case AL_DISTANCE_MODEL:
case AL_SPEED_OF_SOUND:
case AL_DEFERRED_UPDATES_SOFT:
*data = alGetInteger(pname);
return;
}
}
Context = GetContextRef();
if(!Context) return;
if(data)
{
switch(pname)
{
default:
alSetError(Context, AL_INVALID_ENUM);
break;
}
}
else
{
// data is a NULL pointer
alSetError(Context, AL_INVALID_VALUE);
}
ALCcontext_DecRef(Context);
}
