/**
 * 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(ALsource *Source);
static ALvoid GetSourceOffsets(ALsource *Source, ALenum name, ALdouble *offsets, ALdouble updateLen);
static ALint GetSampleOffset(ALsource *Source);

static ALenum GetSourcedv(ALsource *Source, ALCcontext *Context, ALenum name, ALdouble *values);
static ALenum GetSourceiv(ALsource *Source, ALCcontext *Context, ALenum name, ALint *values);
static ALenum GetSourcei64v(ALsource *Source, ALCcontext *Context, ALenum name, ALint64 *values);

static ALenum GetSourcedv(ALsource *Source, ALCcontext *Context, ALenum name, ALdouble *values)
{
    ALdouble offsets[2];
    ALdouble updateLen;
    ALint    ivals[3];
    ALenum   err;

    switch(name)
    {
        case AL_MAX_DISTANCE:
            *values = Source->MaxDistance;
            break;

        case AL_ROLLOFF_FACTOR:
            *values = Source->RollOffFactor;
            break;

        case AL_REFERENCE_DISTANCE:
            *values = Source->RefDistance;
            break;

        case AL_CONE_INNER_ANGLE:
            *values = Source->InnerAngle;
            break;

        case AL_CONE_OUTER_ANGLE:
            *values = Source->OuterAngle;
            break;

        case AL_SEC_OFFSET:
        case AL_SAMPLE_OFFSET:
        case AL_BYTE_OFFSET:
            LockContext(Context);
            updateLen = (ALdouble)Context->Device->UpdateSize /
                        Context->Device->Frequency;
            GetSourceOffsets(Source, name, offsets, updateLen);
            UnlockContext(Context);
            *values = offsets[0];
            break;

        case AL_DOPPLER_FACTOR:
            *values = Source->DopplerFactor;
            break;

        case AL_SAMPLE_RW_OFFSETS_SOFT:
        case AL_BYTE_RW_OFFSETS_SOFT:
            LockContext(Context);
            updateLen = (ALdouble)Context->Device->UpdateSize /
                        Context->Device->Frequency;
            GetSourceOffsets(Source, name, values, updateLen);
            UnlockContext(Context);
            break;

        case AL_POSITION:
            LockContext(Context);
            values[0] = Source->Position[0];
            values[1] = Source->Position[1];
            values[2] = Source->Position[2];
            UnlockContext(Context);
            break;

        case AL_VELOCITY:
            LockContext(Context);
            values[0] = Source->Velocity[0];
            values[1] = Source->Velocity[1];
            values[2] = Source->Velocity[2];
            UnlockContext(Context);
            break;

        case AL_DIRECTION:
            LockContext(Context);
            values[0] = Source->Orientation[0];
            values[1] = Source->Orientation[1];
            values[2] = Source->Orientation[2];
            UnlockContext(Context);
            break;

        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, name, ivals)) != AL_NO_ERROR)
                return err;
            *values = (ALdouble)ivals[0];
            break;

        default:
            return AL_INVALID_ENUM;
    }

    return AL_NO_ERROR;
}

static ALenum GetSourceiv(ALsource *Source, ALCcontext *Context, ALenum name, ALint *values)
{
    ALbufferlistitem *BufferList;
    ALdouble dvals[3];
    ALenum   err;

    switch(name)
    {
        case AL_SOURCE_RELATIVE:
            *values = Source->HeadRelative;
            break;

        case AL_LOOPING:
            *values = Source->Looping;
            break;

        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);
            break;

        case AL_SOURCE_STATE:
            *values = Source->state;
            break;

        case AL_BUFFERS_QUEUED:
            *values = Source->BuffersInQueue;
            break;

        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);
            break;

        case AL_SOURCE_TYPE:
            *values = Source->SourceType;
            break;

        case AL_DIRECT_FILTER_GAINHF_AUTO:
            *values = Source->DryGainHFAuto;
            break;

        case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
            *values = Source->WetGainAuto;
            break;

        case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
            *values = Source->WetGainHFAuto;
            break;

        case AL_DIRECT_CHANNELS_SOFT:
            *values = Source->DirectChannels;
            break;

        case AL_DISTANCE_MODEL:
            *values = Source->DistanceModel;
            break;

        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, name, dvals)) != AL_NO_ERROR)
                return err;
            *values = (ALint)dvals[0];
            break;

        case AL_SAMPLE_RW_OFFSETS_SOFT:
        case AL_BYTE_RW_OFFSETS_SOFT:
            if((err=GetSourcedv(Source, Context, name, dvals)) != AL_NO_ERROR)
                return err;
            values[0] = (ALint)dvals[0];
            values[1] = (ALint)dvals[0];
            break;

        case AL_POSITION:
        case AL_VELOCITY:
        case AL_DIRECTION:
            if((err=GetSourcedv(Source, Context, name, dvals)) != AL_NO_ERROR)
                return err;
            values[0] = (ALint)dvals[0];
            values[1] = (ALint)dvals[1];
            values[2] = (ALint)dvals[2];
            break;

        default:
            return AL_INVALID_ENUM;
    }

    return AL_NO_ERROR;
}

static ALenum GetSourcei64v(ALsource *Source, ALCcontext *Context, ALenum name, ALint64 *values)
{
    ALdouble dvals[3];
    ALint    ivals[3];
    ALenum   err;

    switch(name)
    {
        case AL_SAMPLE_OFFSET_LATENCY_SOFT:
            LockContext(Context);
            values[0] = GetSourceOffset(Source);
            values[1] = ALCdevice_GetLatency(Context->Device);
            UnlockContext(Context);
            break;

        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, name, dvals)) != AL_NO_ERROR)
                return err;
            *values = (ALint64)dvals[0];
            break;

        case AL_SAMPLE_RW_OFFSETS_SOFT:
        case AL_BYTE_RW_OFFSETS_SOFT:
            if((err=GetSourcedv(Source, Context, name, dvals)) != AL_NO_ERROR)
                return err;
            values[0] = (ALint64)dvals[0];
            values[1] = (ALint64)dvals[0];
            break;

        case AL_POSITION:
        case AL_VELOCITY:
        case AL_DIRECTION:
            if((err=GetSourcedv(Source, Context, name, dvals)) != AL_NO_ERROR)
                return err;
            values[0] = (ALint64)dvals[0];
            values[1] = (ALint64)dvals[1];
            values[2] = (ALint64)dvals[2];
            break;

        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, name, ivals)) != AL_NO_ERROR)
                return err;
            *values = ivals[0];
            break;

        default:
            return AL_INVALID_ENUM;
    }

    return AL_NO_ERROR;
}


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)
                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);

                al_throwerr(Context, err);
            }

            sources[cur] = source->id;
        }
    }
    al_catchany()
    {
        if(cur > 0)
            alDeleteSources(cur, sources);
    }
    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;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        switch(param)
        {
            case AL_PITCH:
                CHECK_VALUE(Context, value >= 0.0f);

                Source->Pitch = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_CONE_INNER_ANGLE:
                CHECK_VALUE(Context, value >= 0.0f && value <= 360.0f);

                Source->InnerAngle = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_CONE_OUTER_ANGLE:
                CHECK_VALUE(Context, value >= 0.0f && value <= 360.0f);

                Source->OuterAngle = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_GAIN:
                CHECK_VALUE(Context, value >= 0.0f);

                Source->Gain = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_MAX_DISTANCE:
                CHECK_VALUE(Context, value >= 0.0f);

                Source->MaxDistance = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_ROLLOFF_FACTOR:
                CHECK_VALUE(Context, value >= 0.0f);

                Source->RollOffFactor = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_REFERENCE_DISTANCE:
                CHECK_VALUE(Context, value >= 0.0f);

                Source->RefDistance = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_MIN_GAIN:
                CHECK_VALUE(Context, value >= 0.0f && value <= 1.0f);

                Source->MinGain = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_MAX_GAIN:
                CHECK_VALUE(Context, value >= 0.0f && value <= 1.0f);

                Source->MaxGain = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_CONE_OUTER_GAIN:
                CHECK_VALUE(Context, value >= 0.0f && value <= 1.0f);

                Source->OuterGain = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_CONE_OUTER_GAINHF:
                CHECK_VALUE(Context, value >= 0.0f && value <= 1.0f);

                Source->OuterGainHF = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_AIR_ABSORPTION_FACTOR:
                CHECK_VALUE(Context, value >= 0.0f && value <= 10.0f);

                Source->AirAbsorptionFactor = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_ROOM_ROLLOFF_FACTOR:
                CHECK_VALUE(Context, value >= 0.0f && value <= 10.0f);

                Source->RoomRolloffFactor = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_DOPPLER_FACTOR:
                CHECK_VALUE(Context, value >= 0.0f && value <= 1.0f);

                Source->DopplerFactor = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
                CHECK_VALUE(Context, value >= 0.0f);

                LockContext(Context);
                Source->OffsetType = param;
                Source->Offset = value;

                if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
                   !Context->DeferUpdates)
                {
                    if(ApplyOffset(Source) == AL_FALSE)
                    {
                        UnlockContext(Context);
                        al_throwerr(Context, AL_INVALID_VALUE);
                    }
                }
                UnlockContext(Context);
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    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;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        switch(param)
        {
            case AL_POSITION:
                CHECK_VALUE(Context, isfinite(value1) && isfinite(value2) && isfinite(value3));

                LockContext(Context);
                Source->Position[0] = value1;
                Source->Position[1] = value2;
                Source->Position[2] = value3;
                UnlockContext(Context);
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_VELOCITY:
                CHECK_VALUE(Context, isfinite(value1) && isfinite(value2) && isfinite(value3));

                LockContext(Context);
                Source->Velocity[0] = value1;
                Source->Velocity[1] = value2;
                Source->Velocity[2] = value3;
                UnlockContext(Context);
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_DIRECTION:
                CHECK_VALUE(Context, isfinite(value1) && isfinite(value2) && isfinite(value3));

                LockContext(Context);
                Source->Orientation[0] = value1;
                Source->Orientation[1] = value2;
                Source->Orientation[2] = value3;
                UnlockContext(Context);
                Source->NeedsUpdate = AL_TRUE;
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API ALvoid AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values)
{
    ALCcontext *Context;

    if(values)
    {
        switch(param)
        {
            case AL_PITCH:
            case AL_CONE_INNER_ANGLE:
            case AL_CONE_OUTER_ANGLE:
            case AL_GAIN:
            case AL_MAX_DISTANCE:
            case AL_ROLLOFF_FACTOR:
            case AL_REFERENCE_DISTANCE:
            case AL_MIN_GAIN:
            case AL_MAX_GAIN:
            case AL_CONE_OUTER_GAIN:
            case AL_CONE_OUTER_GAINHF:
            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
            case AL_AIR_ABSORPTION_FACTOR:
            case AL_ROOM_ROLLOFF_FACTOR:
                alSourcef(source, param, values[0]);
                return;

            case AL_POSITION:
            case AL_VELOCITY:
            case AL_DIRECTION:
                alSource3f(source, param, values[0], values[1], values[2]);
                return;
        }
    }

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if(LookupSource(Context, source) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, values);

        switch(param)
        {
            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API ALvoid AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value)
{
    ALCcontext *Context;
    ALsource   *Source;

    switch(param)
    {
        case AL_MAX_DISTANCE:
        case AL_ROLLOFF_FACTOR:
        case AL_CONE_INNER_ANGLE:
        case AL_CONE_OUTER_ANGLE:
        case AL_REFERENCE_DISTANCE:
            alSourcef(source, param, (ALfloat)value);
            return;
    }

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        ALCdevice *device = Context->Device;
        ALbuffer  *buffer = NULL;
        ALfilter  *filter = NULL;
        ALbufferlistitem *oldlist;

        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        switch(param)
        {
            case AL_SOURCE_RELATIVE:
                CHECK_VALUE(Context, value == AL_FALSE || value == AL_TRUE);

                Source->HeadRelative = (ALboolean)value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_LOOPING:
                CHECK_VALUE(Context, value == AL_FALSE || value == AL_TRUE);

                Source->Looping = (ALboolean)value;
                break;

            case AL_BUFFER:
                CHECK_VALUE(Context, value == 0 ||
                                     (buffer=LookupBuffer(device, value)) != NULL);

                LockContext(Context);
                if(!(Source->state == AL_STOPPED || Source->state == AL_INITIAL))
                {
                    UnlockContext(Context);
                    al_throwerr(Context, 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);
                break;

            case AL_SOURCE_STATE:
                /* Query only */
                al_throwerr(Context, AL_INVALID_OPERATION);

            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
                CHECK_VALUE(Context, value >= 0);

                LockContext(Context);
                Source->OffsetType = param;
                Source->Offset = value;

                if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
                   !Context->DeferUpdates)
                {
                    if(ApplyOffset(Source) == AL_FALSE)
                    {
                        UnlockContext(Context);
                        al_throwerr(Context, AL_INVALID_VALUE);
                    }
                }
                UnlockContext(Context);
                break;

            case AL_DIRECT_FILTER:
                CHECK_VALUE(Context, value == 0 ||
                                     (filter=LookupFilter(device, value)) != 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;
                break;

            case AL_DIRECT_FILTER_GAINHF_AUTO:
                CHECK_VALUE(Context, value == AL_FALSE || value == AL_TRUE);

                Source->DryGainHFAuto = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
                CHECK_VALUE(Context, value == AL_FALSE || value == AL_TRUE);

                Source->WetGainAuto = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
                CHECK_VALUE(Context, value == AL_FALSE || value == AL_TRUE);

                Source->WetGainHFAuto = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_DIRECT_CHANNELS_SOFT:
                CHECK_VALUE(Context, value == AL_FALSE || value == AL_TRUE);

                Source->DirectChannels = value;
                Source->NeedsUpdate = AL_TRUE;
                break;

            case AL_DISTANCE_MODEL:
                CHECK_VALUE(Context, value == AL_NONE ||
                                     value == AL_INVERSE_DISTANCE ||
                                     value == AL_INVERSE_DISTANCE_CLAMPED ||
                                     value == AL_LINEAR_DISTANCE ||
                                     value == AL_LINEAR_DISTANCE_CLAMPED ||
                                     value == AL_EXPONENT_DISTANCE ||
                                     value == AL_EXPONENT_DISTANCE_CLAMPED);

                Source->DistanceModel = value;
                if(Context->SourceDistanceModel)
                    Source->NeedsUpdate = AL_TRUE;
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3)
{
    ALCcontext   *Context;
    ALsource     *Source;

    switch(param)
    {
        case AL_POSITION:
        case AL_VELOCITY:
        case AL_DIRECTION:
            alSource3f(source, param, (ALfloat)value1, (ALfloat)value2, (ALfloat)value3);
            return;
    }

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        ALCdevice *device = Context->Device;
        ALeffectslot *slot = NULL;
        ALfilter *filter = NULL;

        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        switch(param)
        {
            case AL_AUXILIARY_SEND_FILTER:
                LockContext(Context);
                if(!((ALuint)value2 < device->NumAuxSends &&
                     (value1 == 0 || (slot=LookupEffectSlot(Context, value1)) != NULL) &&
                     (value3 == 0 || (filter=LookupFilter(device, value3)) != NULL)))
                {
                    UnlockContext(Context);
                    al_throwerr(Context, AL_INVALID_VALUE);
                }

                /* Add refcount on the new slot, and release the previous slot */
                if(slot) IncrementRef(&slot->ref);
                slot = ExchangePtr((XchgPtr*)&Source->Send[value2].Slot, slot);
                if(slot) DecrementRef(&slot->ref);

                if(!filter)
                {
                    /* Disable filter */
                    Source->Send[value2].Gain = 1.0f;
                    Source->Send[value2].GainHF = 1.0f;
                }
                else
                {
                    Source->Send[value2].Gain = filter->Gain;
                    Source->Send[value2].GainHF = filter->GainHF;
                }
                Source->NeedsUpdate = AL_TRUE;
                UnlockContext(Context);
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values)
{
    ALCcontext *Context;

    if(values)
    {
        switch(param)
        {
            case AL_SOURCE_RELATIVE:
            case AL_CONE_INNER_ANGLE:
            case AL_CONE_OUTER_ANGLE:
            case AL_LOOPING:
            case AL_BUFFER:
            case AL_SOURCE_STATE:
            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
            case AL_MAX_DISTANCE:
            case AL_ROLLOFF_FACTOR:
            case AL_REFERENCE_DISTANCE:
            case AL_DIRECT_FILTER:
            case AL_DIRECT_FILTER_GAINHF_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
            case AL_DISTANCE_MODEL:
            case AL_DIRECT_CHANNELS_SOFT:
                alSourcei(source, param, values[0]);
                return;

            case AL_POSITION:
            case AL_VELOCITY:
            case AL_DIRECTION:
            case AL_AUXILIARY_SEND_FILTER:
                alSource3i(source, param, values[0], values[1], values[2]);
                return;
        }
    }

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if(LookupSource(Context, source) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, values);
        switch(param)
        {
            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALdouble   dval;
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, value);
        switch(param)
        {
            case AL_PITCH:
            case AL_GAIN:
            case AL_MIN_GAIN:
            case AL_MAX_GAIN:
            case AL_MAX_DISTANCE:
            case AL_ROLLOFF_FACTOR:
            case AL_CONE_OUTER_GAIN:
            case AL_CONE_OUTER_GAINHF:
            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
            case AL_CONE_INNER_ANGLE:
            case AL_CONE_OUTER_ANGLE:
            case AL_REFERENCE_DISTANCE:
            case AL_AIR_ABSORPTION_FACTOR:
            case AL_ROOM_ROLLOFF_FACTOR:
            case AL_DOPPLER_FACTOR:
                if((err=GetSourcedv(Source, Context, param, &dval)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                *value = (ALfloat)dval;
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALdouble   dvals[3];
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, value1 && value2 && value3);
        switch(param)
        {
            case AL_POSITION:
            case AL_VELOCITY:
            case AL_DIRECTION:
                if((err=GetSourcedv(Source, Context, param, dvals)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                *value1 = (ALfloat)dvals[0];
                *value2 = (ALfloat)dvals[1];
                *value3 = (ALfloat)dvals[2];
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALdouble   dvals[2];
    ALenum     err;

    switch(param)
    {
        case AL_PITCH:
        case AL_GAIN:
        case AL_MIN_GAIN:
        case AL_MAX_GAIN:
        case AL_MAX_DISTANCE:
        case AL_ROLLOFF_FACTOR:
        case AL_DOPPLER_FACTOR:
        case AL_CONE_OUTER_GAIN:
        case AL_SEC_OFFSET:
        case AL_SAMPLE_OFFSET:
        case AL_BYTE_OFFSET:
        case AL_CONE_INNER_ANGLE:
        case AL_CONE_OUTER_ANGLE:
        case AL_REFERENCE_DISTANCE:
        case AL_CONE_OUTER_GAINHF:
        case AL_AIR_ABSORPTION_FACTOR:
        case AL_ROOM_ROLLOFF_FACTOR:
            alGetSourcef(source, param, values);
            return;

        case AL_POSITION:
        case AL_VELOCITY:
        case AL_DIRECTION:
            alGetSource3f(source, param, values+0, values+1, values+2);
            return;
    }

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, values);
        switch(param)
        {
            case AL_SAMPLE_RW_OFFSETS_SOFT:
            case AL_BYTE_RW_OFFSETS_SOFT:
                if((err=GetSourcedv(Source, Context, param, dvals)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                values[0] = (ALfloat)dvals[0];
                values[1] = (ALfloat)dvals[1];
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API ALvoid AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, value);
        switch(param)
        {
            case AL_MAX_DISTANCE:
            case AL_ROLLOFF_FACTOR:
            case AL_REFERENCE_DISTANCE:
            case AL_SOURCE_RELATIVE:
            case AL_CONE_INNER_ANGLE:
            case AL_CONE_OUTER_ANGLE:
            case AL_LOOPING:
            case AL_BUFFER:
            case AL_SOURCE_STATE:
            case AL_BUFFERS_QUEUED:
            case AL_BUFFERS_PROCESSED:
            case AL_SOURCE_TYPE:
            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
            case AL_DIRECT_FILTER_GAINHF_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
            case AL_DOPPLER_FACTOR:
            case AL_DIRECT_CHANNELS_SOFT:
            case AL_DISTANCE_MODEL:
                if((err=GetSourceiv(Source, Context, param, value)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALint      ivals[3];
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, value1 && value2 && value3);
        switch(param)
        {
            case AL_POSITION:
            case AL_VELOCITY:
            case AL_DIRECTION:
                if((err=GetSourceiv(Source, Context, param, ivals)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                *value1 = ivals[0];
                *value2 = ivals[1];
                *value3 = ivals[2];
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param, ALint *values)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, values);
        switch(param)
        {
            case AL_SOURCE_RELATIVE:
            case AL_CONE_INNER_ANGLE:
            case AL_CONE_OUTER_ANGLE:
            case AL_LOOPING:
            case AL_BUFFER:
            case AL_SOURCE_STATE:
            case AL_BUFFERS_QUEUED:
            case AL_BUFFERS_PROCESSED:
            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
            case AL_MAX_DISTANCE:
            case AL_ROLLOFF_FACTOR:
            case AL_DOPPLER_FACTOR:
            case AL_REFERENCE_DISTANCE:
            case AL_SOURCE_TYPE:
            case AL_DIRECT_FILTER:
            case AL_DIRECT_FILTER_GAINHF_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
            case AL_DISTANCE_MODEL:
            case AL_DIRECT_CHANNELS_SOFT:

            case AL_SAMPLE_RW_OFFSETS_SOFT:
            case AL_BYTE_RW_OFFSETS_SOFT:

            case AL_POSITION:
            case AL_VELOCITY:
            case AL_DIRECTION:
                if((err=GetSourceiv(Source, Context, param, values)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}


AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *values)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, values);
        switch(param)
        {
            case AL_MAX_DISTANCE:
            case AL_ROLLOFF_FACTOR:
            case AL_REFERENCE_DISTANCE:
            case AL_SOURCE_RELATIVE:
            case AL_CONE_INNER_ANGLE:
            case AL_CONE_OUTER_ANGLE:
            case AL_LOOPING:
            case AL_BUFFER:
            case AL_SOURCE_STATE:
            case AL_BUFFERS_QUEUED:
            case AL_BUFFERS_PROCESSED:
            case AL_SOURCE_TYPE:
            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
            case AL_DIRECT_FILTER_GAINHF_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
            case AL_DOPPLER_FACTOR:
            case AL_DIRECT_CHANNELS_SOFT:
            case AL_DISTANCE_MODEL:
                if((err=GetSourcei64v(Source, Context, param, values)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}

AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALint64    i64vals[3];
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, value1 && value2 && value3);
        switch(param)
        {
            case AL_POSITION:
            case AL_VELOCITY:
            case AL_DIRECTION:
                if((err=GetSourcei64v(Source, Context, param, i64vals)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                *value1 = i64vals[0];
                *value2 = i64vals[1];
                *value3 = i64vals[2];
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    ALCcontext_DecRef(Context);
}

AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values)
{
    ALCcontext *Context;
    ALsource   *Source;
    ALenum     err;

    Context = GetContextRef();
    if(!Context) return;

    al_try
    {
        if((Source=LookupSource(Context, source)) == NULL)
            al_throwerr(Context, AL_INVALID_NAME);
        CHECK_VALUE(Context, values);
        switch(param)
        {
            case AL_MAX_DISTANCE:
            case AL_ROLLOFF_FACTOR:
            case AL_REFERENCE_DISTANCE:
            case AL_SOURCE_RELATIVE:
            case AL_CONE_INNER_ANGLE:
            case AL_CONE_OUTER_ANGLE:
            case AL_LOOPING:
            case AL_BUFFER:
            case AL_SOURCE_STATE:
            case AL_BUFFERS_QUEUED:
            case AL_BUFFERS_PROCESSED:
            case AL_SOURCE_TYPE:
            case AL_SEC_OFFSET:
            case AL_SAMPLE_OFFSET:
            case AL_BYTE_OFFSET:
            case AL_DIRECT_FILTER_GAINHF_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
            case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
            case AL_DOPPLER_FACTOR:
            case AL_DIRECT_CHANNELS_SOFT:
            case AL_DISTANCE_MODEL:

            case AL_SAMPLE_OFFSET_LATENCY_SOFT:

            case AL_POSITION:
            case AL_VELOCITY:
            case AL_DIRECTION:
                if((err=GetSourcei64v(Source, Context, param, values)) != AL_NO_ERROR)
                    al_throwerr(Context, err);
                break;

            default:
                al_throwerr(Context, AL_INVALID_ENUM);
        }
    }
    al_endtry;

    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;
        }

        Source->BuffersInQueue += nb;

        UnlockContext(Context);
    }
    al_catchany()
    {
        while(BufferListStart)
        {
            BufferList = BufferListStart;
            BufferListStart = BufferList->next;

            if(BufferList->buffer)
                DecrementRef(&BufferList->buffer->ref);
            free(BufferList);
        }
    }
    al_endtry;

    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 < MaxChannels;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(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));
}

/* 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(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);
    }
}