kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
openal-soft/OpenAL32/alSource.c
Chris Robinson 94884ed04b Use a separate value for the maximum buffer channels 
Unlike the device, input buffers are accessed based on channel numbers
instead of enums. This means the maximum number of channels they hold
depends on the number of channels any one format can have, rather than
the total number of recognized channels. Currently, this is 8 for 7.1.
2013-07-23 00:13:15 -07:00

2734 lines
77 KiB
C
Raw Blame History

/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
* Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#include "config.h"
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "alMain.h"
#include "alError.h"
#include "alSource.h"
#include "alBuffer.h"
#include "alThunk.h"
#include "alAuxEffectSlot.h"
enum Resampler DefaultResampler = LinearResampler;
const ALsizei ResamplerPadding[ResamplerMax] = {
0, /* Point */
1, /* Linear */
2, /* Cubic */
};
const ALsizei ResamplerPrePadding[ResamplerMax] = {
0, /* Point */
0, /* Linear */
1, /* Cubic */
};
static ALvoid InitSourceParams(ALsource *Source);
static ALint64 GetSourceOffset(const ALsource *Source);
static ALdouble GetSourceSecOffset(const ALsource *Source);
static ALvoid GetSourceOffsets(const ALsource *Source, ALenum name, ALdouble *offsets, ALdouble updateLen);
static ALint GetSampleOffset(ALsource *Source);
typedef enum SrcFloatProp {
sfPitch = AL_PITCH,
sfGain = AL_GAIN,
sfMinGain = AL_MIN_GAIN,
sfMaxGain = AL_MAX_GAIN,
sfMaxDistance = AL_MAX_DISTANCE,
sfRolloffFactor = AL_ROLLOFF_FACTOR,
sfDopplerFactor = AL_DOPPLER_FACTOR,
sfConeOuterGain = AL_CONE_OUTER_GAIN,
sfSecOffset = AL_SEC_OFFSET,
sfSampleOffset = AL_SAMPLE_OFFSET,
sfByteOffset = AL_BYTE_OFFSET,
sfConeInnerAngle = AL_CONE_INNER_ANGLE,
sfConeOuterAngle = AL_CONE_OUTER_ANGLE,
sfRefDistance = AL_REFERENCE_DISTANCE,
sfPosition = AL_POSITION,
sfVelocity = AL_VELOCITY,
sfDirection = AL_DIRECTION,
sfSourceRelative = AL_SOURCE_RELATIVE,
sfLooping = AL_LOOPING,
sfBuffer = AL_BUFFER,
sfSourceState = AL_SOURCE_STATE,
sfBuffersQueued = AL_BUFFERS_QUEUED,
sfBuffersProcessed = AL_BUFFERS_PROCESSED,
sfSourceType = AL_SOURCE_TYPE,
/* ALC_EXT_EFX */
sfConeOuterGainHF = AL_CONE_OUTER_GAINHF,
sfAirAbsorptionFactor = AL_AIR_ABSORPTION_FACTOR,
sfRoomRolloffFactor = AL_ROOM_ROLLOFF_FACTOR,
sfDirectFilterGainHFAuto = AL_DIRECT_FILTER_GAINHF_AUTO,
sfAuxSendFilterGainAuto = AL_AUXILIARY_SEND_FILTER_GAIN_AUTO,
sfAuxSendFilterGainHFAuto = AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO,
/* AL_SOFT_direct_channels */
sfDirectChannelsSOFT = AL_DIRECT_CHANNELS_SOFT,
/* AL_EXT_source_distance_model */
sfDistanceModel = AL_DISTANCE_MODEL,
/* AL_SOFT_buffer_sub_data / AL_SOFT_buffer_samples */
sfSampleRWOffsetsSOFT = AL_SAMPLE_RW_OFFSETS_SOFT,
sfByteRWOffsetsSOFT = AL_BYTE_RW_OFFSETS_SOFT,
/* AL_SOFT_source_latency */
sfSecOffsetLatencySOFT = AL_SEC_OFFSET_LATENCY_SOFT,
} SrcFloatProp;
typedef enum SrcIntProp {
siMaxDistance = AL_MAX_DISTANCE,
siRolloffFactor = AL_ROLLOFF_FACTOR,
siRefDistance = AL_REFERENCE_DISTANCE,
siSourceRelative = AL_SOURCE_RELATIVE,
siConeInnerAngle = AL_CONE_INNER_ANGLE,
siConeOuterAngle = AL_CONE_OUTER_ANGLE,
siLooping = AL_LOOPING,
siBuffer = AL_BUFFER,
siSourceState = AL_SOURCE_STATE,
siBuffersQueued = AL_BUFFERS_QUEUED,
siBuffersProcessed = AL_BUFFERS_PROCESSED,
siSourceType = AL_SOURCE_TYPE,
siSecOffset = AL_SEC_OFFSET,
siSampleOffset = AL_SAMPLE_OFFSET,
siByteOffset = AL_BYTE_OFFSET,
siDopplerFactor = AL_DOPPLER_FACTOR,
siPosition = AL_POSITION,
siVelocity = AL_VELOCITY,
siDirection = AL_DIRECTION,
/* ALC_EXT_EFX */
siDirectFilterGainHFAuto = AL_DIRECT_FILTER_GAINHF_AUTO,
siAuxSendFilterGainAutio = AL_AUXILIARY_SEND_FILTER_GAIN_AUTO,
siAuxSendFilterGainHFAuto = AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO,
siDirectFilter = AL_DIRECT_FILTER,
siAuxSendFilter = AL_AUXILIARY_SEND_FILTER,
/* AL_SOFT_direct_channels */
siDirectChannelsSOFT = AL_DIRECT_CHANNELS_SOFT,
/* AL_EXT_source_distance_model */
siDistanceModel = AL_DISTANCE_MODEL,
/* AL_SOFT_buffer_sub_data / AL_SOFT_buffer_samples */
siSampleRWOffsetsSOFT = AL_SAMPLE_RW_OFFSETS_SOFT,
siByteRWOffsetsSOFT = AL_BYTE_RW_OFFSETS_SOFT,
/* AL_SOFT_source_latency */
siSampleOffsetLatencySOFT = AL_SAMPLE_OFFSET_LATENCY_SOFT,
} SrcIntProp;
static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp prop, const ALfloat *values);
static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint *values);
static ALenum SetSourcei64v(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint64SOFT *values);
static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatProp prop, ALdouble *values);
static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint *values);
static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint64 *values);
static ALint FloatValsByProp(ALenum prop)
{
if(prop != (ALenum)((SrcFloatProp)prop))
return 0;
switch((SrcFloatProp)prop)
{
case sfPitch:
case sfGain:
case sfMinGain:
case sfMaxGain:
case sfMaxDistance:
case sfRolloffFactor:
case sfDopplerFactor:
case sfConeOuterGain:
case sfSecOffset:
case sfSampleOffset:
case sfByteOffset:
case sfConeInnerAngle:
case sfConeOuterAngle:
case sfRefDistance:
case sfConeOuterGainHF:
case sfAirAbsorptionFactor:
case sfRoomRolloffFactor:
case sfDirectFilterGainHFAuto:
case sfAuxSendFilterGainAuto:
case sfAuxSendFilterGainHFAuto:
case sfDirectChannelsSOFT:
case sfDistanceModel:
case sfSourceRelative:
case sfLooping:
case sfBuffer:
case sfSourceState:
case sfBuffersQueued:
case sfBuffersProcessed:
case sfSourceType:
return 1;
case sfSampleRWOffsetsSOFT:
case sfByteRWOffsetsSOFT:
return 2;
case sfPosition:
case sfVelocity:
case sfDirection:
return 3;
case sfSecOffsetLatencySOFT:
break; /* Double only */
}
return 0;
}
static ALint DoubleValsByProp(ALenum prop)
{
if(prop != (ALenum)((SrcFloatProp)prop))
return 0;
switch((SrcFloatProp)prop)
{
case sfPitch:
case sfGain:
case sfMinGain:
case sfMaxGain:
case sfMaxDistance:
case sfRolloffFactor:
case sfDopplerFactor:
case sfConeOuterGain:
case sfSecOffset:
case sfSampleOffset:
case sfByteOffset:
case sfConeInnerAngle:
case sfConeOuterAngle:
case sfRefDistance:
case sfConeOuterGainHF:
case sfAirAbsorptionFactor:
case sfRoomRolloffFactor:
case sfDirectFilterGainHFAuto:
case sfAuxSendFilterGainAuto:
case sfAuxSendFilterGainHFAuto:
case sfDirectChannelsSOFT:
case sfDistanceModel:
case sfSourceRelative:
case sfLooping:
case sfBuffer:
case sfSourceState:
case sfBuffersQueued:
case sfBuffersProcessed:
case sfSourceType:
return 1;
case sfSampleRWOffsetsSOFT:
case sfByteRWOffsetsSOFT:
case sfSecOffsetLatencySOFT:
return 2;
case sfPosition:
case sfVelocity:
case sfDirection:
return 3;
}
return 0;
}
static ALint IntValsByProp(ALenum prop)
{
if(prop != (ALenum)((SrcIntProp)prop))
return 0;
switch((SrcIntProp)prop)
{
case siMaxDistance:
case siRolloffFactor:
case siRefDistance:
case siSourceRelative:
case siConeInnerAngle:
case siConeOuterAngle:
case siLooping:
case siBuffer:
case siSourceState:
case siBuffersQueued:
case siBuffersProcessed:
case siSourceType:
case siSecOffset:
case siSampleOffset:
case siByteOffset:
case siDopplerFactor:
case siDirectFilterGainHFAuto:
case siAuxSendFilterGainAutio:
case siAuxSendFilterGainHFAuto:
case siDirectFilter:
case siDirectChannelsSOFT:
case siDistanceModel:
return 1;
case siSampleRWOffsetsSOFT:
case siByteRWOffsetsSOFT:
return 2;
case siPosition:
case siVelocity:
case siDirection:
case siAuxSendFilter:
return 3;
case siSampleOffsetLatencySOFT:
break; /* i64 only */
}
return 0;
}
static ALint Int64ValsByProp(ALenum prop)
{
if(prop != (ALenum)((SrcIntProp)prop))
return 0;
switch((SrcIntProp)prop)
{
case siMaxDistance:
case siRolloffFactor:
case siRefDistance:
case siSourceRelative:
case siConeInnerAngle:
case siConeOuterAngle:
case siLooping:
case siBuffer:
case siSourceState:
case siBuffersQueued:
case siBuffersProcessed:
case siSourceType:
case siSecOffset:
case siSampleOffset:
case siByteOffset:
case siDopplerFactor:
case siDirectFilterGainHFAuto:
case siAuxSendFilterGainAutio:
case siAuxSendFilterGainHFAuto:
case siDirectFilter:
case siDirectChannelsSOFT:
case siDistanceModel:
return 1;
case siSampleRWOffsetsSOFT:
case siByteRWOffsetsSOFT:
case siSampleOffsetLatencySOFT:
return 2;
case siPosition:
case siVelocity:
case siDirection:
case siAuxSendFilter:
return 3;
}
return 0;
}
#define RETERR(x) do { \
alSetError(Context, (x)); \
return (x); \
} while(0)
#define CHECKVAL(x) do { \
if(!(x)) \
RETERR(AL_INVALID_VALUE); \
} while(0)
static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp prop, const ALfloat *values)
{
ALint ival;
switch(prop)
{
case AL_PITCH:
CHECKVAL(*values >= 0.0f);
Source->Pitch = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_CONE_INNER_ANGLE:
CHECKVAL(*values >= 0.0f && *values <= 360.0f);
Source->InnerAngle = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_CONE_OUTER_ANGLE:
CHECKVAL(*values >= 0.0f && *values <= 360.0f);
Source->OuterAngle = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_GAIN:
CHECKVAL(*values >= 0.0f);
Source->Gain = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_MAX_DISTANCE:
CHECKVAL(*values >= 0.0f);
Source->MaxDistance = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_ROLLOFF_FACTOR:
CHECKVAL(*values >= 0.0f);
Source->RollOffFactor = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_REFERENCE_DISTANCE:
CHECKVAL(*values >= 0.0f);
Source->RefDistance = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_MIN_GAIN:
CHECKVAL(*values >= 0.0f && *values <= 1.0f);
Source->MinGain = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_MAX_GAIN:
CHECKVAL(*values >= 0.0f && *values <= 1.0f);
Source->MaxGain = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_CONE_OUTER_GAIN:
CHECKVAL(*values >= 0.0f && *values <= 1.0f);
Source->OuterGain = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_CONE_OUTER_GAINHF:
CHECKVAL(*values >= 0.0f && *values <= 1.0f);
Source->OuterGainHF = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_AIR_ABSORPTION_FACTOR:
CHECKVAL(*values >= 0.0f && *values <= 10.0f);
Source->AirAbsorptionFactor = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_ROOM_ROLLOFF_FACTOR:
CHECKVAL(*values >= 0.0f && *values <= 10.0f);
Source->RoomRolloffFactor = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_DOPPLER_FACTOR:
CHECKVAL(*values >= 0.0f && *values <= 1.0f);
Source->DopplerFactor = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_SEC_OFFSET:
case AL_SAMPLE_OFFSET:
case AL_BYTE_OFFSET:
CHECKVAL(*values >= 0.0f);
LockContext(Context);
Source->OffsetType = prop;
Source->Offset = *values;
if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
!Context->DeferUpdates)
{
if(ApplyOffset(Source) == AL_FALSE)
{
UnlockContext(Context);
RETERR(AL_INVALID_VALUE);
}
}
UnlockContext(Context);
return AL_NO_ERROR;
case AL_SEC_OFFSET_LATENCY_SOFT:
/* Query only */
RETERR(AL_INVALID_OPERATION);
case AL_POSITION:
CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
LockContext(Context);
Source->Position[0] = values[0];
Source->Position[1] = values[1];
Source->Position[2] = values[2];
UnlockContext(Context);
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_VELOCITY:
CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
LockContext(Context);
Source->Velocity[0] = values[0];
Source->Velocity[1] = values[1];
Source->Velocity[2] = values[2];
UnlockContext(Context);
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_DIRECTION:
CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
LockContext(Context);
Source->Orientation[0] = values[0];
Source->Orientation[1] = values[1];
Source->Orientation[2] = values[2];
UnlockContext(Context);
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case sfSampleRWOffsetsSOFT:
case sfByteRWOffsetsSOFT:
RETERR(AL_INVALID_OPERATION);
case sfSourceRelative:
case sfLooping:
case sfSourceState:
case sfSourceType:
case sfDistanceModel:
case sfDirectFilterGainHFAuto:
case sfAuxSendFilterGainAuto:
case sfAuxSendFilterGainHFAuto:
case sfDirectChannelsSOFT:
ival = (ALint)values[0];
return SetSourceiv(Source, Context, (SrcIntProp)prop, &ival);
case sfBuffer:
case sfBuffersQueued:
case sfBuffersProcessed:
ival = (ALint)((ALuint)values[0]);
return SetSourceiv(Source, Context, (SrcIntProp)prop, &ival);
}
ERR("Unexpected property: 0x%04x\n", prop);
RETERR(AL_INVALID_ENUM);
}
static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint *values)
{
ALCdevice *device = Context->Device;
ALbuffer *buffer = NULL;
ALfilter *filter = NULL;
ALeffectslot *slot = NULL;
ALbufferlistitem *oldlist;
ALfloat fvals[3];
switch(prop)
{
case AL_SOURCE_RELATIVE:
CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
Source->HeadRelative = (ALboolean)*values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_LOOPING:
CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
Source->Looping = (ALboolean)*values;
return AL_NO_ERROR;
case AL_BUFFER:
CHECKVAL(*values == 0 || (buffer=LookupBuffer(device, *values)) != NULL);
LockContext(Context);
if(!(Source->state == AL_STOPPED || Source->state == AL_INITIAL))
{
UnlockContext(Context);
RETERR(AL_INVALID_OPERATION);
}
Source->BuffersInQueue = 0;
Source->BuffersPlayed = 0;
if(buffer != NULL)
{
ALbufferlistitem *BufferListItem;
/* Source is now Static */
Source->SourceType = AL_STATIC;
/* Add the selected buffer to a one-item queue */
BufferListItem = malloc(sizeof(ALbufferlistitem));
BufferListItem->buffer = buffer;
BufferListItem->next = NULL;
BufferListItem->prev = NULL;
IncrementRef(&buffer->ref);
oldlist = ExchangePtr((XchgPtr*)&Source->queue, BufferListItem);
Source->BuffersInQueue = 1;
ReadLock(&buffer->lock);
Source->NumChannels = ChannelsFromFmt(buffer->FmtChannels);
Source->SampleSize = BytesFromFmt(buffer->FmtType);
ReadUnlock(&buffer->lock);
if(buffer->FmtChannels == FmtMono)
Source->Update = CalcSourceParams;
else
Source->Update = CalcNonAttnSourceParams;
Source->NeedsUpdate = AL_TRUE;
}
else
{
/* Source is now Undetermined */
Source->SourceType = AL_UNDETERMINED;
oldlist = ExchangePtr((XchgPtr*)&Source->queue, NULL);
}
/* Delete all elements in the previous queue */
while(oldlist != NULL)
{
ALbufferlistitem *temp = oldlist;
oldlist = temp->next;
if(temp->buffer)
DecrementRef(&temp->buffer->ref);
free(temp);
}
UnlockContext(Context);
return AL_NO_ERROR;
case siSourceState:
case siSourceType:
case siBuffersQueued:
case siBuffersProcessed:
/* Query only */
RETERR(AL_INVALID_OPERATION);
case AL_SEC_OFFSET:
case AL_SAMPLE_OFFSET:
case AL_BYTE_OFFSET:
CHECKVAL(*values >= 0);
LockContext(Context);
Source->OffsetType = prop;
Source->Offset = *values;
if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
!Context->DeferUpdates)
{
if(ApplyOffset(Source) == AL_FALSE)
{
UnlockContext(Context);
RETERR(AL_INVALID_VALUE);
}
}
UnlockContext(Context);
return AL_NO_ERROR;
case siSampleRWOffsetsSOFT:
case siByteRWOffsetsSOFT:
/* Query only */
RETERR(AL_INVALID_OPERATION);
case AL_DIRECT_FILTER:
CHECKVAL(*values == 0 || (filter=LookupFilter(device, *values)) != NULL);
LockContext(Context);
if(!filter)
{
Source->DirectGain = 1.0f;
Source->DirectGainHF = 1.0f;
}
else
{
Source->DirectGain = filter->Gain;
Source->DirectGainHF = filter->GainHF;
}
UnlockContext(Context);
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_DIRECT_FILTER_GAINHF_AUTO:
CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
Source->DryGainHFAuto = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
Source->WetGainAuto = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
Source->WetGainHFAuto = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_DIRECT_CHANNELS_SOFT:
CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
Source->DirectChannels = *values;
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_DISTANCE_MODEL:
CHECKVAL(*values == AL_NONE ||
*values == AL_INVERSE_DISTANCE ||
*values == AL_INVERSE_DISTANCE_CLAMPED ||
*values == AL_LINEAR_DISTANCE ||
*values == AL_LINEAR_DISTANCE_CLAMPED ||
*values == AL_EXPONENT_DISTANCE ||
*values == AL_EXPONENT_DISTANCE_CLAMPED);
Source->DistanceModel = *values;
if(Context->SourceDistanceModel)
Source->NeedsUpdate = AL_TRUE;
return AL_NO_ERROR;
case AL_AUXILIARY_SEND_FILTER:
LockContext(Context);
if(!((ALuint)values[1] < device->NumAuxSends &&
(values[0] == 0 || (slot=LookupEffectSlot(Context, values[0])) != NULL) &&
(values[2] == 0 || (filter=LookupFilter(device, values[2])) != NULL)))
{
UnlockContext(Context);
RETERR(AL_INVALID_VALUE);
}
/* Add refcount on the new slot, and release the previous slot */
if(slot) IncrementRef(&slot->ref);
slot = ExchangePtr((XchgPtr*)&Source->Send[values[1]].Slot, slot);
if(slot) DecrementRef(&slot->ref);
if(!filter)
{
/* Disable filter */
Source->Send[values[1]].Gain = 1.0f;
Source->Send[values[1]].GainHF = 1.0f;
}
else
{
Source->Send[values[1]].Gain = filter->Gain;
Source->Send[values[1]].GainHF = filter->GainHF;
}
Source->NeedsUpdate = AL_TRUE;
UnlockContext(Context);
return AL_NO_ERROR;
case AL_MAX_DISTANCE:
case AL_ROLLOFF_FACTOR:
case AL_CONE_INNER_ANGLE:
case AL_CONE_OUTER_ANGLE:
case AL_REFERENCE_DISTANCE:
case siDopplerFactor:
fvals[0] = (ALfloat)*values;
return SetSourcefv(Source, Context, (int)prop, fvals);
case AL_POSITION:
case AL_VELOCITY:
case AL_DIRECTION:
fvals[0] = (ALfloat)values[0];
fvals[1] = (ALfloat)values[1];
fvals[2] = (ALfloat)values[2];
return SetSourcefv(Source, Context, (int)prop, fvals);
case siSampleOffsetLatencySOFT:
/* i64 only */
break;
}
ERR("Unexpected property: 0x%04x\n", prop);
RETERR(AL_INVALID_ENUM);
}
static ALenum SetSourcei64v(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint64SOFT *values)
{
ALfloat fvals[3];
ALint ivals[3];
switch(prop)
{
case siSampleRWOffsetsSOFT:
case siByteRWOffsetsSOFT:
case siSampleOffsetLatencySOFT:
/* Query only */
RETERR(AL_INVALID_OPERATION);
/* 1x int */
case AL_SOURCE_RELATIVE:
case AL_LOOPING:
case AL_SOURCE_STATE:
case AL_BYTE_OFFSET:
case AL_SAMPLE_OFFSET:
case siSourceType:
case siBuffersQueued:
case siBuffersProcessed:
case AL_DIRECT_FILTER_GAINHF_AUTO:
case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
case AL_DIRECT_CHANNELS_SOFT:
case AL_DISTANCE_MODEL:
CHECKVAL(*values <= INT_MAX && *values >= INT_MIN);
ivals[0] = (ALint)*values;
return SetSourceiv(Source, Context, (int)prop, ivals);
/* 1x uint */
case AL_BUFFER:
case AL_DIRECT_FILTER:
CHECKVAL(*values <= UINT_MAX && *values >= 0);
ivals[0] = (ALuint)*values;
return SetSourceiv(Source, Context, (int)prop, ivals);
/* 3x uint */
case AL_AUXILIARY_SEND_FILTER:
CHECKVAL(values[0] <= UINT_MAX && values[0] >= 0 &&
values[1] <= UINT_MAX && values[1] >= 0 &&
values[2] <= UINT_MAX && values[2] >= 0);
ivals[0] = (ALuint)values[0];
ivals[1] = (ALuint)values[1];
ivals[2] = (ALuint)values[2];
return SetSourceiv(Source, Context, (int)prop, ivals);
/* 1x float */
case AL_MAX_DISTANCE:
case AL_ROLLOFF_FACTOR:
case AL_CONE_INNER_ANGLE:
case AL_CONE_OUTER_ANGLE:
case AL_REFERENCE_DISTANCE:
case AL_SEC_OFFSET:
case siDopplerFactor:
fvals[0] = (ALfloat)*values;
return SetSourcefv(Source, Context, (int)prop, fvals);
/* 3x float */
case AL_POSITION:
case AL_VELOCITY:
case AL_DIRECTION:
fvals[0] = (ALfloat)values[0];
fvals[1] = (ALfloat)values[1];
fvals[2] = (ALfloat)values[2];
return SetSourcefv(Source, Context, (int)prop, fvals);
}
ERR("Unexpected property: 0x%04x\n", prop);
RETERR(AL_INVALID_ENUM);
}
#undef CHECKVAL
static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatProp prop, ALdouble *values)
{
ALdouble offsets[2];
ALdouble updateLen;
ALint ivals[3];
ALenum err;
switch(prop)
{
case AL_GAIN:
*values = Source->Gain;
return AL_NO_ERROR;
case AL_PITCH:
*values = Source->Pitch;
return AL_NO_ERROR;
case AL_MAX_DISTANCE:
*values = Source->MaxDistance;
return AL_NO_ERROR;
case AL_ROLLOFF_FACTOR:
*values = Source->RollOffFactor;
return AL_NO_ERROR;
case AL_REFERENCE_DISTANCE:
*values = Source->RefDistance;
return AL_NO_ERROR;
case AL_CONE_INNER_ANGLE:
*values = Source->InnerAngle;
return AL_NO_ERROR;
case AL_CONE_OUTER_ANGLE:
*values = Source->OuterAngle;
return AL_NO_ERROR;
case AL_MIN_GAIN:
*values = Source->MinGain;
return AL_NO_ERROR;
case AL_MAX_GAIN:
*values = Source->MaxGain;
return AL_NO_ERROR;
case AL_CONE_OUTER_GAIN:
*values = Source->OuterGain;
return AL_NO_ERROR;
case AL_SEC_OFFSET:
case AL_SAMPLE_OFFSET:
case AL_BYTE_OFFSET:
LockContext(Context);
updateLen = (ALdouble)Context->Device->UpdateSize /
Context->Device->Frequency;
GetSourceOffsets(Source, prop, offsets, updateLen);
UnlockContext(Context);
*values = offsets[0];
return AL_NO_ERROR;
case AL_CONE_OUTER_GAINHF:
*values = Source->OuterGainHF;
return AL_NO_ERROR;
case AL_AIR_ABSORPTION_FACTOR:
*values = Source->AirAbsorptionFactor;
return AL_NO_ERROR;
case AL_ROOM_ROLLOFF_FACTOR:
*values = Source->RoomRolloffFactor;
return AL_NO_ERROR;
case AL_DOPPLER_FACTOR:
*values = Source->DopplerFactor;
return AL_NO_ERROR;
case AL_SAMPLE_RW_OFFSETS_SOFT:
case AL_BYTE_RW_OFFSETS_SOFT:
LockContext(Context);
updateLen = (ALdouble)Context->Device->UpdateSize /
Context->Device->Frequency;
GetSourceOffsets(Source, prop, values, updateLen);
UnlockContext(Context);
return AL_NO_ERROR;
case AL_SEC_OFFSET_LATENCY_SOFT:
LockContext(Context);
values[0] = GetSourceSecOffset(Source);
values[1] = (ALdouble)ALCdevice_GetLatency(Context->Device) /
1000000000.0;
UnlockContext(Context);
return AL_NO_ERROR;
case AL_POSITION:
LockContext(Context);
values[0] = Source->Position[0];
values[1] = Source->Position[1];
values[2] = Source->Position[2];
UnlockContext(Context);
return AL_NO_ERROR;
case AL_VELOCITY:
LockContext(Context);
values[0] = Source->Velocity[0];
values[1] = Source->Velocity[1];
values[2] = Source->Velocity[2];
UnlockContext(Context);
return AL_NO_ERROR;
case AL_DIRECTION:
LockContext(Context);
values[0] = Source->Orientation[0];
values[1] = Source->Orientation[1];
values[2] = Source->Orientation[2];
UnlockContext(Context);
return AL_NO_ERROR;
case AL_SOURCE_RELATIVE:
case AL_LOOPING:
case AL_BUFFER:
case AL_SOURCE_STATE:
case AL_BUFFERS_QUEUED:
case AL_BUFFERS_PROCESSED:
case AL_SOURCE_TYPE:
case AL_DIRECT_FILTER_GAINHF_AUTO:
case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
case AL_DIRECT_CHANNELS_SOFT:
case AL_DISTANCE_MODEL:
if((err=GetSourceiv(Source, Context, (int)prop, ivals)) == AL_NO_ERROR)
*values = (ALdouble)ivals[0];
return err;
}
ERR("Unexpected property: 0x%04x\n", prop);
RETERR(AL_INVALID_ENUM);
}
static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint *values)
{
ALbufferlistitem *BufferList;
ALdouble dvals[3];
ALenum err;
switch(prop)
{
case AL_SOURCE_RELATIVE:
*values = Source->HeadRelative;
return AL_NO_ERROR;
case AL_LOOPING:
*values = Source->Looping;
return AL_NO_ERROR;
case AL_BUFFER:
LockContext(Context);
BufferList = Source->queue;
if(Source->SourceType != AL_STATIC)
{
ALuint i = Source->BuffersPlayed;
while(i > 0)
{
BufferList = BufferList->next;
i--;
}
}
*values = ((BufferList && BufferList->buffer) ?
BufferList->buffer->id : 0);
UnlockContext(Context);
return AL_NO_ERROR;
case AL_SOURCE_STATE:
*values = Source->state;
return AL_NO_ERROR;
case AL_BUFFERS_QUEUED:
*values = Source->BuffersInQueue;
return AL_NO_ERROR;
case AL_BUFFERS_PROCESSED:
LockContext(Context);
if(Source->Looping || Source->SourceType != AL_STREAMING)
{
/* Buffers on a looping source are in a perpetual state of
* PENDING, so don't report any as PROCESSED */
*values = 0;
}
else
*values = Source->BuffersPlayed;
UnlockContext(Context);
return AL_NO_ERROR;
case AL_SOURCE_TYPE:
*values = Source->SourceType;
return AL_NO_ERROR;
case AL_DIRECT_FILTER_GAINHF_AUTO:
*values = Source->DryGainHFAuto;
return AL_NO_ERROR;
case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
*values = Source->WetGainAuto;
return AL_NO_ERROR;
case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
*values = Source->WetGainHFAuto;
return AL_NO_ERROR;
case AL_DIRECT_CHANNELS_SOFT:
*values = Source->DirectChannels;
return AL_NO_ERROR;
case AL_DISTANCE_MODEL:
*values = Source->DistanceModel;
return AL_NO_ERROR;
case AL_MAX_DISTANCE:
case AL_ROLLOFF_FACTOR:
case AL_REFERENCE_DISTANCE:
case AL_CONE_INNER_ANGLE:
case AL_CONE_OUTER_ANGLE:
case AL_SEC_OFFSET:
case AL_SAMPLE_OFFSET:
case AL_BYTE_OFFSET:
case AL_DOPPLER_FACTOR:
if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
*values = (ALint)dvals[0];
return err;
case AL_SAMPLE_RW_OFFSETS_SOFT:
case AL_BYTE_RW_OFFSETS_SOFT:
if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
{
values[0] = (ALint)dvals[0];
values[1] = (ALint)dvals[1];
}
return err;
case AL_POSITION:
case AL_VELOCITY:
case AL_DIRECTION:
if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
{
values[0] = (ALint)dvals[0];
values[1] = (ALint)dvals[1];
values[2] = (ALint)dvals[2];
}
return err;
case siSampleOffsetLatencySOFT:
/* i64 only */
break;
case siDirectFilter:
case siAuxSendFilter:
/* ??? */
break;
}
ERR("Unexpected property: 0x%04x\n", prop);
RETERR(AL_INVALID_ENUM);
}
static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint64 *values)
{
ALdouble dvals[3];
ALint ivals[3];
ALenum err;
switch(prop)
{
case AL_SAMPLE_OFFSET_LATENCY_SOFT:
LockContext(Context);
values[0] = GetSourceOffset(Source);
values[1] = ALCdevice_GetLatency(Context->Device);
UnlockContext(Context);
return AL_NO_ERROR;
case AL_MAX_DISTANCE:
case AL_ROLLOFF_FACTOR:
case AL_REFERENCE_DISTANCE:
case AL_CONE_INNER_ANGLE:
case AL_CONE_OUTER_ANGLE:
case AL_SEC_OFFSET:
case AL_SAMPLE_OFFSET:
case AL_BYTE_OFFSET:
case AL_DOPPLER_FACTOR:
if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
*values = (ALint64)dvals[0];
return err;
case AL_SAMPLE_RW_OFFSETS_SOFT:
case AL_BYTE_RW_OFFSETS_SOFT:
if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
{
values[0] = (ALint64)dvals[0];
values[1] = (ALint64)dvals[1];
}
return err;
case AL_POSITION:
case AL_VELOCITY:
case AL_DIRECTION:
if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
{
values[0] = (ALint64)dvals[0];
values[1] = (ALint64)dvals[1];
values[2] = (ALint64)dvals[2];
}
return err;
case AL_SOURCE_RELATIVE:
case AL_LOOPING:
case AL_SOURCE_STATE:
case AL_BUFFERS_QUEUED:
case AL_BUFFERS_PROCESSED:
case AL_SOURCE_TYPE:
case AL_DIRECT_FILTER_GAINHF_AUTO:
case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
case AL_DIRECT_CHANNELS_SOFT:
case AL_DISTANCE_MODEL:
if((err=GetSourceiv(Source, Context, (int)prop, ivals)) == AL_NO_ERROR)
*values = ivals[0];
return err;
case siBuffer:
case siDirectFilter:
if((err=GetSourceiv(Source, Context, (int)prop, ivals)) == AL_NO_ERROR)
*values = ((ALuint*)ivals)[0];
return err;
case siAuxSendFilter:
if((err=GetSourceiv(Source, Context, (int)prop, ivals)) == AL_NO_ERROR)
{
values[0] = ((ALuint*)ivals)[0];
values[1] = ((ALuint*)ivals)[1];
values[2] = ((ALuint*)ivals)[2];
}
return err;
}
ERR("Unexpected property: 0x%04x\n", prop);
RETERR(AL_INVALID_ENUM);
}
#undef RETERR
AL_API ALvoid AL_APIENTRY alGenSources(ALsizei n, ALuint *sources)
{
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++)
{
ALsource *source = al_calloc(16, sizeof(ALsource));
if(!source)
{
alDeleteSources(cur, sources);
al_throwerr(Context, AL_OUT_OF_MEMORY);
}
InitSourceParams(source);
err = NewThunkEntry(&source->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&Context->SourceMap, source->id, source);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(source->id);
memset(source, 0, sizeof(ALsource));
al_free(source);
alDeleteSources(cur, sources);
al_throwerr(Context, err);
}
sources[cur] = source->id;
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
{
ALCcontext *Context;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALbufferlistitem *BufferList;
ALsource *Source;
ALsizei i, j;
CHECK_VALUE(Context, n >= 0);
/* Check that all Sources are valid */
for(i = 0;i < n;i++)
{
if(LookupSource(Context, sources[i]) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
}
for(i = 0;i < n;i++)
{
ALsource **srclist, **srclistend;
if((Source=RemoveSource(Context, sources[i])) == NULL)
continue;
FreeThunkEntry(Source->id);
LockContext(Context);
srclist = Context->ActiveSources;
srclistend = srclist + Context->ActiveSourceCount;
while(srclist != srclistend)
{
if(*srclist == Source)
{
Context->ActiveSourceCount--;
*srclist = *(--srclistend);
break;
}
srclist++;
}
UnlockContext(Context);
while(Source->queue != NULL)
{
BufferList = Source->queue;
Source->queue = BufferList->next;
if(BufferList->buffer != NULL)
DecrementRef(&BufferList->buffer->ref);
free(BufferList);
}
for(j = 0;j < MAX_SENDS;++j)
{
if(Source->Send[j].Slot)
DecrementRef(&Source->Send[j].Slot->ref);
Source->Send[j].Slot = NULL;
}
memset(Source, 0, sizeof(*Source));
al_free(Source);
}
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALboolean AL_APIENTRY alIsSource(ALuint source)
{
ALCcontext *Context;
ALboolean result;
Context = GetContextRef();
if(!Context) return AL_FALSE;
result = (LookupSource(Context, source) ? AL_TRUE : AL_FALSE);
ALCcontext_DecRef(Context);
return result;
}
AL_API ALvoid AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(FloatValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
SetSourcefv(Source, Context, param, &value);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(FloatValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALfloat fvals[3] = { value1, value2, value3 };
SetSourcefv(Source, Context, param, fvals);
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!(FloatValsByProp(param) > 0))
alSetError(Context, AL_INVALID_ENUM);
else
SetSourcefv(Source, Context, param, values);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(DoubleValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALfloat fval = (ALfloat)value;
SetSourcefv(Source, Context, param, &fval);
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(DoubleValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALfloat fvals[3] = { (ALfloat)value1, (ALfloat)value2, (ALfloat)value3 };
SetSourcefv(Source, Context, param, fvals);
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values)
{
ALCcontext *Context;
ALsource *Source;
ALint count;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!((count=DoubleValsByProp(param)) > 0 && count <= 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALfloat fvals[3];
ALint i;
for(i = 0;i < count;i++)
fvals[i] = (ALfloat)values[i];
SetSourcefv(Source, Context, param, fvals);
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(IntValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
SetSourceiv(Source, Context, param, &value);
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(IntValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALint ivals[3] = { value1, value2, value3 };
SetSourceiv(Source, Context, param, ivals);
}
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!(IntValsByProp(param) > 0))
alSetError(Context, AL_INVALID_ENUM);
else
SetSourceiv(Source, Context, param, values);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(Int64ValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
SetSourcei64v(Source, Context, param, &value);
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(Int64ValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALint64SOFT i64vals[3] = { value1, value2, value3 };
SetSourcei64v(Source, Context, param, i64vals);
}
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!(Int64ValsByProp(param) > 0))
alSetError(Context, AL_INVALID_ENUM);
else
SetSourcei64v(Source, Context, param, values);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!value)
alSetError(Context, AL_INVALID_VALUE);
else if(!(FloatValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALdouble dval;
if(GetSourcedv(Source, Context, param, &dval) == AL_NO_ERROR)
*value = (ALfloat)dval;
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(value1 && value2 && value3))
alSetError(Context, AL_INVALID_VALUE);
else if(!(FloatValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALdouble dvals[3];
if(GetSourcedv(Source, Context, param, dvals) == AL_NO_ERROR)
{
*value1 = (ALfloat)dvals[0];
*value2 = (ALfloat)dvals[1];
*value3 = (ALfloat)dvals[2];
}
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values)
{
ALCcontext *Context;
ALsource *Source;
ALint count;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!((count=FloatValsByProp(param)) > 0 && count <= 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALdouble dvals[3];
if(GetSourcedv(Source, Context, param, dvals) == AL_NO_ERROR)
{
ALint i;
for(i = 0;i < count;i++)
values[i] = (ALfloat)dvals[i];
}
}
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!value)
alSetError(Context, AL_INVALID_VALUE);
else if(!(DoubleValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
GetSourcedv(Source, Context, param, value);
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(value1 && value2 && value3))
alSetError(Context, AL_INVALID_VALUE);
else if(!(DoubleValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALdouble dvals[3];
if(GetSourcedv(Source, Context, param, dvals) == AL_NO_ERROR)
{
*value1 = dvals[0];
*value2 = dvals[1];
*value3 = dvals[2];
}
}
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!(DoubleValsByProp(param) > 0))
alSetError(Context, AL_INVALID_ENUM);
else
GetSourcedv(Source, Context, param, values);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!value)
alSetError(Context, AL_INVALID_VALUE);
else if(!(IntValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
GetSourceiv(Source, Context, param, value);
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(value1 && value2 && value3))
alSetError(Context, AL_INVALID_VALUE);
else if(!(IntValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALint ivals[3];
if(GetSourceiv(Source, Context, param, ivals) == AL_NO_ERROR)
{
*value1 = ivals[0];
*value2 = ivals[1];
*value3 = ivals[2];
}
}
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param, ALint *values)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!(IntValsByProp(param) > 0))
alSetError(Context, AL_INVALID_ENUM);
else
GetSourceiv(Source, Context, param, values);
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!value)
alSetError(Context, AL_INVALID_VALUE);
else if(!(Int64ValsByProp(param) == 1))
alSetError(Context, AL_INVALID_ENUM);
else
GetSourcei64v(Source, Context, param, value);
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!(value1 && value2 && value3))
alSetError(Context, AL_INVALID_VALUE);
else if(!(Int64ValsByProp(param) == 3))
alSetError(Context, AL_INVALID_ENUM);
else
{
ALint64 i64vals[3];
if(GetSourcei64v(Source, Context, param, i64vals) == AL_NO_ERROR)
{
*value1 = i64vals[0];
*value2 = i64vals[1];
*value3 = i64vals[2];
}
}
ALCcontext_DecRef(Context);
}
AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values)
{
ALCcontext *Context;
ALsource *Source;
Context = GetContextRef();
if(!Context) return;
if((Source=LookupSource(Context, source)) == NULL)
alSetError(Context, AL_INVALID_NAME);
else if(!values)
alSetError(Context, AL_INVALID_VALUE);
else if(!(Int64ValsByProp(param) > 0))
alSetError(Context, AL_INVALID_ENUM);
else
GetSourcei64v(Source, Context, param, values);
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourcePlay(ALuint source)
{
alSourcePlayv(1, &source);
}
AL_API ALvoid AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, n >= 0);
for(i = 0;i < n;i++)
{
if(!LookupSource(Context, sources[i]))
al_throwerr(Context, AL_INVALID_NAME);
}
LockContext(Context);
while(Context->MaxActiveSources-Context->ActiveSourceCount < n)
{
void *temp = NULL;
ALsizei newcount;
newcount = Context->MaxActiveSources << 1;
if(newcount > 0)
temp = realloc(Context->ActiveSources,
sizeof(*Context->ActiveSources) * newcount);
if(!temp)
{
UnlockContext(Context);
al_throwerr(Context, AL_OUT_OF_MEMORY);
}
Context->ActiveSources = temp;
Context->MaxActiveSources = newcount;
}
for(i = 0;i < n;i++)
{
Source = LookupSource(Context, sources[i]);
if(Context->DeferUpdates) Source->new_state = AL_PLAYING;
else SetSourceState(Source, Context, AL_PLAYING);
}
UnlockContext(Context);
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourcePause(ALuint source)
{
alSourcePausev(1, &source);
}
AL_API ALvoid AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, n >= 0);
for(i = 0;i < n;i++)
{
if(!LookupSource(Context, sources[i]))
al_throwerr(Context, AL_INVALID_NAME);
}
LockContext(Context);
for(i = 0;i < n;i++)
{
Source = LookupSource(Context, sources[i]);
if(Context->DeferUpdates) Source->new_state = AL_PAUSED;
else SetSourceState(Source, Context, AL_PAUSED);
}
UnlockContext(Context);
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourceStop(ALuint source)
{
alSourceStopv(1, &source);
}
AL_API ALvoid AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, n >= 0);
for(i = 0;i < n;i++)
{
if(!LookupSource(Context, sources[i]))
al_throwerr(Context, AL_INVALID_NAME);
}
LockContext(Context);
for(i = 0;i < n;i++)
{
Source = LookupSource(Context, sources[i]);
Source->new_state = AL_NONE;
SetSourceState(Source, Context, AL_STOPPED);
}
UnlockContext(Context);
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourceRewind(ALuint source)
{
alSourceRewindv(1, &source);
}
AL_API ALvoid AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, n >= 0);
for(i = 0;i < n;i++)
{
if(!LookupSource(Context, sources[i]))
al_throwerr(Context, AL_INVALID_NAME);
}
LockContext(Context);
for(i = 0;i < n;i++)
{
Source = LookupSource(Context, sources[i]);
Source->new_state = AL_NONE;
SetSourceState(Source, Context, AL_INITIAL);
}
UnlockContext(Context);
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
ALbufferlistitem *BufferListStart = NULL;
ALbufferlistitem *BufferList;
ALbuffer *BufferFmt;
if(nb == 0)
return;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALCdevice *device = Context->Device;
CHECK_VALUE(Context, nb >= 0);
if((Source=LookupSource(Context, source)) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
LockContext(Context);
if(Source->SourceType == AL_STATIC)
{
UnlockContext(Context);
/* Can't queue on a Static Source */
al_throwerr(Context, AL_INVALID_OPERATION);
}
BufferFmt = NULL;
/* Check for a valid Buffer, for its frequency and format */
BufferList = Source->queue;
while(BufferList)
{
if(BufferList->buffer)
{
BufferFmt = BufferList->buffer;
break;
}
BufferList = BufferList->next;
}
for(i = 0;i < nb;i++)
{
ALbuffer *buffer = NULL;
if(buffers[i] && (buffer=LookupBuffer(device, buffers[i])) == NULL)
{
UnlockContext(Context);
al_throwerr(Context, AL_INVALID_NAME);
}
if(!BufferListStart)
{
BufferListStart = malloc(sizeof(ALbufferlistitem));
BufferListStart->buffer = buffer;
BufferListStart->next = NULL;
BufferListStart->prev = NULL;
BufferList = BufferListStart;
}
else
{
BufferList->next = malloc(sizeof(ALbufferlistitem));
BufferList->next->buffer = buffer;
BufferList->next->next = NULL;
BufferList->next->prev = BufferList;
BufferList = BufferList->next;
}
if(!buffer) continue;
IncrementRef(&buffer->ref);
ReadLock(&buffer->lock);
if(BufferFmt == NULL)
{
BufferFmt = buffer;
Source->NumChannels = ChannelsFromFmt(buffer->FmtChannels);
Source->SampleSize = BytesFromFmt(buffer->FmtType);
if(buffer->FmtChannels == FmtMono)
Source->Update = CalcSourceParams;
else
Source->Update = CalcNonAttnSourceParams;
Source->NeedsUpdate = AL_TRUE;
}
else if(BufferFmt->Frequency != buffer->Frequency ||
BufferFmt->OriginalChannels != buffer->OriginalChannels ||
BufferFmt->OriginalType != buffer->OriginalType)
{
ReadUnlock(&buffer->lock);
UnlockContext(Context);
al_throwerr(Context, AL_INVALID_OPERATION);
}
ReadUnlock(&buffer->lock);
}
/* Source is now streaming */
Source->SourceType = AL_STREAMING;
if(Source->queue == NULL)
Source->queue = BufferListStart;
else
{
/* Append to the end of the queue */
BufferList = Source->queue;
while(BufferList->next != NULL)
BufferList = BufferList->next;
BufferListStart->prev = BufferList;
BufferList->next = BufferListStart;
}
BufferListStart = NULL;
Source->BuffersInQueue += nb;
UnlockContext(Context);
}
al_endtry;
while(BufferListStart)
{
BufferList = BufferListStart;
BufferListStart = BufferList->next;
if(BufferList->buffer)
DecrementRef(&BufferList->buffer->ref);
free(BufferList);
}
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
ALbufferlistitem *BufferList;
if(nb == 0)
return;
Context = GetContextRef();
if(!Context) return;
al_try
{
CHECK_VALUE(Context, nb >= 0);
if((Source=LookupSource(Context, source)) == NULL)
al_throwerr(Context, AL_INVALID_NAME);
LockContext(Context);
if(Source->Looping || Source->SourceType != AL_STREAMING ||
(ALuint)nb > Source->BuffersPlayed)
{
UnlockContext(Context);
/* Trying to unqueue pending buffers, or a buffer that wasn't queued. */
al_throwerr(Context, AL_INVALID_VALUE);
}
for(i = 0;i < nb;i++)
{
BufferList = Source->queue;
Source->queue = BufferList->next;
Source->BuffersInQueue--;
Source->BuffersPlayed--;
if(BufferList->buffer)
{
buffers[i] = BufferList->buffer->id;
DecrementRef(&BufferList->buffer->ref);
}
else
buffers[i] = 0;
free(BufferList);
}
if(Source->queue)
Source->queue->prev = NULL;
UnlockContext(Context);
}
al_endtry;
ALCcontext_DecRef(Context);
}
static ALvoid InitSourceParams(ALsource *Source)
{
ALuint i;
Source->InnerAngle = 360.0f;
Source->OuterAngle = 360.0f;
Source->Pitch = 1.0f;
Source->Position[0] = 0.0f;
Source->Position[1] = 0.0f;
Source->Position[2] = 0.0f;
Source->Orientation[0] = 0.0f;
Source->Orientation[1] = 0.0f;
Source->Orientation[2] = 0.0f;
Source->Velocity[0] = 0.0f;
Source->Velocity[1] = 0.0f;
Source->Velocity[2] = 0.0f;
Source->RefDistance = 1.0f;
Source->MaxDistance = FLT_MAX;
Source->RollOffFactor = 1.0f;
Source->Looping = AL_FALSE;
Source->Gain = 1.0f;
Source->MinGain = 0.0f;
Source->MaxGain = 1.0f;
Source->OuterGain = 0.0f;
Source->OuterGainHF = 1.0f;
Source->DryGainHFAuto = AL_TRUE;
Source->WetGainAuto = AL_TRUE;
Source->WetGainHFAuto = AL_TRUE;
Source->AirAbsorptionFactor = 0.0f;
Source->RoomRolloffFactor = 0.0f;
Source->DopplerFactor = 1.0f;
Source->DirectChannels = AL_FALSE;
Source->DistanceModel = DefaultDistanceModel;
Source->Resampler = DefaultResampler;
Source->state = AL_INITIAL;
Source->new_state = AL_NONE;
Source->SourceType = AL_UNDETERMINED;
Source->Offset = -1.0;
Source->DirectGain = 1.0f;
Source->DirectGainHF = 1.0f;
for(i = 0;i < MAX_SENDS;i++)
{
Source->Send[i].Gain = 1.0f;
Source->Send[i].GainHF = 1.0f;
}
Source->NeedsUpdate = AL_TRUE;
Source->Hrtf.Moving = AL_FALSE;
Source->Hrtf.Counter = 0;
}
/* SetSourceState
*
* Sets the source's new play state given its current state.
*/
ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state)
{
if(state == AL_PLAYING)
{
ALbufferlistitem *BufferList;
ALsizei j, k;
/* Check that there is a queue containing at least one valid, non zero
* length Buffer. */
BufferList = Source->queue;
while(BufferList)
{
if(BufferList->buffer != NULL && BufferList->buffer->SampleLen)
break;
BufferList = BufferList->next;
}
if(Source->state != AL_PLAYING)
{
for(j = 0;j < MAX_INPUT_CHANNELS;j++)
{
for(k = 0;k < SRC_HISTORY_LENGTH;k++)
Source->Hrtf.History[j][k] = 0.0f;
for(k = 0;k < HRIR_LENGTH;k++)
{
Source->Hrtf.Values[j][k][0] = 0.0f;
Source->Hrtf.Values[j][k][1] = 0.0f;
}
}
}
if(Source->state != AL_PAUSED)
{
Source->state = AL_PLAYING;
Source->position = 0;
Source->position_fraction = 0;
Source->BuffersPlayed = 0;
}
else
Source->state = AL_PLAYING;
// Check if an Offset has been set
if(Source->Offset >= 0.0)
ApplyOffset(Source);
/* If there's nothing to play, or device is disconnected, go right to
* stopped */
if(!BufferList || !Context->Device->Connected)
{
SetSourceState(Source, Context, AL_STOPPED);
return;
}
for(j = 0;j < Context->ActiveSourceCount;j++)
{
if(Context->ActiveSources[j] == Source)
break;
}
if(j == Context->ActiveSourceCount)
Context->ActiveSources[Context->ActiveSourceCount++] = Source;
}
else if(state == AL_PAUSED)
{
if(Source->state == AL_PLAYING)
{
Source->state = AL_PAUSED;
Source->Hrtf.Moving = AL_FALSE;
Source->Hrtf.Counter = 0;
}
}
else if(state == AL_STOPPED)
{
if(Source->state != AL_INITIAL)
{
Source->state = AL_STOPPED;
Source->BuffersPlayed = Source->BuffersInQueue;
Source->Hrtf.Moving = AL_FALSE;
Source->Hrtf.Counter = 0;
}
Source->Offset = -1.0;
}
else if(state == AL_INITIAL)
{
if(Source->state != AL_INITIAL)
{
Source->state = AL_INITIAL;
Source->position = 0;
Source->position_fraction = 0;
Source->BuffersPlayed = 0;
Source->Hrtf.Moving = AL_FALSE;
Source->Hrtf.Counter = 0;
}
Source->Offset = -1.0;
}
}
/* GetSourceOffset
*
* Gets the current read offset for the given Source, in 32.32 fixed-point
* samples. The offset is relative to the start of the queue (not the start of
* the current buffer).
*/
static ALint64 GetSourceOffset(const ALsource *Source)
{
const ALbufferlistitem *BufferList;
ALuint64 readPos;
ALuint i;
if(Source->state != AL_PLAYING && Source->state != AL_PAUSED)
return 0;
/* NOTE: This is the offset into the *current* buffer, so add the length of
* any played buffers */
readPos = (ALuint64)Source->position << 32;
readPos |= (ALuint64)Source->position_fraction << (32-FRACTIONBITS);
BufferList = Source->queue;
for(i = 0;i < Source->BuffersPlayed && BufferList;i++)
{
if(BufferList->buffer)
readPos += (ALuint64)BufferList->buffer->SampleLen << 32;
BufferList = BufferList->next;
}
return (ALint64)minu64(readPos, MAKEU64(0x7fffffff,0xffffffff));
}
/* GetSourceSecOffset
*
* Gets the current read offset for the given Source, in seconds. The offset is
* relative to the start of the queue (not the start of the current buffer).
*/
static ALdouble GetSourceSecOffset(const ALsource *Source)
{
const ALbufferlistitem *BufferList;
const ALbuffer *Buffer = NULL;
ALuint64 readPos;
ALuint i;
BufferList = Source->queue;
while(BufferList)
{
if(BufferList->buffer)
{
Buffer = BufferList->buffer;
break;
}
BufferList = BufferList->next;
}
if((Source->state != AL_PLAYING && Source->state != AL_PAUSED) || !Buffer)
return 0.0;
/* NOTE: This is the offset into the *current* buffer, so add the length of
* any played buffers */
readPos = (ALuint64)Source->position << FRACTIONBITS;
readPos |= (ALuint64)Source->position_fraction;
BufferList = Source->queue;
for(i = 0;i < Source->BuffersPlayed && BufferList;i++)
{
if(BufferList->buffer)
readPos += (ALuint64)BufferList->buffer->SampleLen << FRACTIONBITS;
BufferList = BufferList->next;
}
return (ALdouble)readPos / (ALdouble)FRACTIONONE / (ALdouble)Buffer->Frequency;
}
/* GetSourceOffsets
*
* Gets the current read and write offsets for the given Source, in the
* appropriate format (Bytes, Samples or Seconds). The offsets are relative to
* the start of the queue (not the start of the current buffer).
*/
static ALvoid GetSourceOffsets(const ALsource *Source, ALenum name, ALdouble *offset, ALdouble updateLen)
{
const ALbufferlistitem *BufferList;
const ALbuffer *Buffer = NULL;
ALuint readPos, writePos;
ALuint totalBufferLen;
ALuint i;
// Find the first valid Buffer in the Queue
BufferList = Source->queue;
while(BufferList)
{
if(BufferList->buffer)
{
Buffer = BufferList->buffer;
break;
}
BufferList = BufferList->next;
}
if((Source->state != AL_PLAYING && Source->state != AL_PAUSED) || !Buffer)
{
offset[0] = 0.0;
offset[1] = 0.0;
return;
}
if(updateLen > 0.0 && updateLen < 0.015)
updateLen = 0.015;
/* NOTE: This is the offset into the *current* buffer, so add the length of
* any played buffers */
readPos = Source->position;
totalBufferLen = 0;
BufferList = Source->queue;
for(i = 0;BufferList;i++)
{
if(BufferList->buffer)
{
if(i < Source->BuffersPlayed)
readPos += BufferList->buffer->SampleLen;
totalBufferLen += BufferList->buffer->SampleLen;
}
BufferList = BufferList->next;
}
if(Source->state == AL_PLAYING)
writePos = readPos + (ALuint)(updateLen*Buffer->Frequency);
else
writePos = readPos;
if(Source->Looping)
{
readPos %= totalBufferLen;
writePos %= totalBufferLen;
}
else
{
/* Wrap positions back to 0 */
if(readPos >= totalBufferLen)
readPos = 0;
if(writePos >= totalBufferLen)
writePos = 0;
}
switch(name)
{
case AL_SEC_OFFSET:
offset[0] = (ALdouble)readPos / Buffer->Frequency;
offset[1] = (ALdouble)writePos / Buffer->Frequency;
break;
case AL_SAMPLE_OFFSET:
case AL_SAMPLE_RW_OFFSETS_SOFT:
offset[0] = (ALdouble)readPos;
offset[1] = (ALdouble)writePos;
break;
case AL_BYTE_OFFSET:
case AL_BYTE_RW_OFFSETS_SOFT:
if(Buffer->OriginalType == UserFmtIMA4)
{
ALuint BlockSize = 36 * ChannelsFromFmt(Buffer->FmtChannels);
ALuint FrameBlockSize = 65;
/* Round down to nearest ADPCM block */
offset[0] = (ALdouble)(readPos / FrameBlockSize * BlockSize);
if(Source->state != AL_PLAYING)
offset[1] = offset[0];
else
{
/* Round up to nearest ADPCM block */
offset[1] = (ALdouble)((writePos+FrameBlockSize-1) /
FrameBlockSize * BlockSize);
}
}
else
{
ALuint FrameSize = FrameSizeFromUserFmt(Buffer->OriginalChannels, Buffer->OriginalType);
offset[0] = (ALdouble)(readPos * FrameSize);
offset[1] = (ALdouble)(writePos * FrameSize);
}
break;
}
}
/* ApplyOffset
*
* Apply the stored playback offset to the Source. This function will update
* the number of buffers "played" given the stored offset.
*/
ALboolean ApplyOffset(ALsource *Source)
{
const ALbufferlistitem *BufferList;
const ALbuffer *Buffer;
ALint bufferLen, totalBufferLen;
ALint buffersPlayed;
ALint offset;
/* Get sample frame offset */
offset = GetSampleOffset(Source);
if(offset == -1)
return AL_FALSE;
buffersPlayed = 0;
totalBufferLen = 0;
BufferList = Source->queue;
while(BufferList)
{
Buffer = BufferList->buffer;
bufferLen = Buffer ? Buffer->SampleLen : 0;
if(bufferLen <= offset-totalBufferLen)
{
/* Offset is past this buffer so increment to the next buffer */
buffersPlayed++;
}
else if(totalBufferLen <= offset)
{
/* Offset is in this buffer */
Source->BuffersPlayed = buffersPlayed;
Source->position = offset - totalBufferLen;
Source->position_fraction = 0;
return AL_TRUE;
}
totalBufferLen += bufferLen;
BufferList = BufferList->next;
}
/* Offset is out of range of the queue */
return AL_FALSE;
}
/* GetSampleOffset
*
* Returns the sample offset into the Source's queue (from the Sample, Byte or
* Second offset supplied by the application). This takes into account the fact
* that the buffer format may have been modifed since.
*/
static ALint GetSampleOffset(ALsource *Source)
{
const ALbuffer *Buffer = NULL;
const ALbufferlistitem *BufferList;
ALint Offset = -1;
/* Find the first valid Buffer in the Queue */
BufferList = Source->queue;
while(BufferList)
{
if(BufferList->buffer)
{
Buffer = BufferList->buffer;
break;
}
BufferList = BufferList->next;
}
if(!Buffer)
{
Source->Offset = -1.0;
return -1;
}
switch(Source->OffsetType)
{
case AL_BYTE_OFFSET:
/* Determine the ByteOffset (and ensure it is block aligned) */
Offset = (ALint)Source->Offset;
if(Buffer->OriginalType == UserFmtIMA4)
{
Offset /= 36 * ChannelsFromUserFmt(Buffer->OriginalChannels);
Offset *= 65;
}
else
Offset /= FrameSizeFromUserFmt(Buffer->OriginalChannels, Buffer->OriginalType);
break;
case AL_SAMPLE_OFFSET:
Offset = (ALint)Source->Offset;
break;
case AL_SEC_OFFSET:
Offset = (ALint)(Source->Offset * Buffer->Frequency);
break;
}
Source->Offset = -1.0;
return Offset;
}
/* ReleaseALSources
*
* Destroys all sources in the source map.
*/
ALvoid ReleaseALSources(ALCcontext *Context)
{
ALsizei pos;
ALuint j;
for(pos = 0;pos < Context->SourceMap.size;pos++)
{
ALsource *temp = Context->SourceMap.array[pos].value;
Context->SourceMap.array[pos].value = NULL;
while(temp->queue != NULL)
{
ALbufferlistitem *BufferList = temp->queue;
temp->queue = BufferList->next;
if(BufferList->buffer != NULL)
DecrementRef(&BufferList->buffer->ref);
free(BufferList);
}
for(j = 0;j < MAX_SENDS;++j)
{
if(temp->Send[j].Slot)
DecrementRef(&temp->Send[j].Slot->ref);
temp->Send[j].Slot = NULL;
}
FreeThunkEntry(temp->id);
memset(temp, 0, sizeof(*temp));
al_free(temp);
}
}
Reference in New Issue View Git Blame Copy Permalink