Merge branch 'UPSTREAM'

1 files changed, 429 insertions, 456 deletions

diff --git a/OpenAL32/alSource.c b/OpenAL32/alSource.c
index 5dbea314..543910db 100644
--- a/OpenAL32/alSource.c
+++ b/OpenAL32/alSource.c
@@ -47,6 +47,9 @@ const ALsizei ResamplerPrePadding[ResamplerMax] = {
 };
 
 
+extern inline struct ALsource *LookupSource(ALCcontext *context, ALuint id);
+extern inline struct ALsource *RemoveSource(ALCcontext *context, ALuint id);
+
 static ALvoid InitSourceParams(ALsource *Source);
 static ALint64 GetSourceOffset(const ALsource *Source);
 static ALdouble GetSourceSecOffset(const ALsource *Source);
@@ -145,13 +148,13 @@ typedef enum SrcIntProp {
     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 ALboolean SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp prop, const ALfloat *values);
+static ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint *values);
+static ALboolean 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 ALboolean GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatProp prop, ALdouble *values);
+static ALboolean GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint *values);
+static ALboolean GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint64 *values);
 
 static ALint FloatValsByProp(ALenum prop)
 {
@@ -344,17 +347,12 @@ static ALint Int64ValsByProp(ALenum prop)
 }
 
 
-#define RETERR(x) do {                                                        \
-    alSetError(Context, (x));                                                 \
-    return (x);                                                               \
-} while(0)
-
 #define CHECKVAL(x) do {                                                      \
     if(!(x))                                                                  \
-        RETERR(AL_INVALID_VALUE);                                             \
+        SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_VALUE, AL_FALSE);      \
 } while(0)
 
-static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp prop, const ALfloat *values)
+static ALboolean SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp prop, const ALfloat *values)
 {
     ALint ival;
 
@@ -365,98 +363,98 @@ static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp pr
 
             Source->Pitch = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_INNER_ANGLE:
             CHECKVAL(*values >= 0.0f && *values <= 360.0f);
 
             Source->InnerAngle = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_OUTER_ANGLE:
             CHECKVAL(*values >= 0.0f && *values <= 360.0f);
 
             Source->OuterAngle = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_GAIN:
             CHECKVAL(*values >= 0.0f);
 
             Source->Gain = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MAX_DISTANCE:
             CHECKVAL(*values >= 0.0f);
 
             Source->MaxDistance = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_ROLLOFF_FACTOR:
             CHECKVAL(*values >= 0.0f);
 
             Source->RollOffFactor = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_REFERENCE_DISTANCE:
             CHECKVAL(*values >= 0.0f);
 
             Source->RefDistance = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MIN_GAIN:
             CHECKVAL(*values >= 0.0f && *values <= 1.0f);
 
             Source->MinGain = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MAX_GAIN:
             CHECKVAL(*values >= 0.0f && *values <= 1.0f);
 
             Source->MaxGain = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_OUTER_GAIN:
             CHECKVAL(*values >= 0.0f && *values <= 1.0f);
 
             Source->OuterGain = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_OUTER_GAINHF:
             CHECKVAL(*values >= 0.0f && *values <= 1.0f);
 
             Source->OuterGainHF = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_AIR_ABSORPTION_FACTOR:
             CHECKVAL(*values >= 0.0f && *values <= 10.0f);
 
             Source->AirAbsorptionFactor = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_ROOM_ROLLOFF_FACTOR:
             CHECKVAL(*values >= 0.0f && *values <= 10.0f);
 
             Source->RoomRolloffFactor = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DOPPLER_FACTOR:
             CHECKVAL(*values >= 0.0f && *values <= 1.0f);
 
             Source->DopplerFactor = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_SEC_OFFSET:
         case AL_SAMPLE_OFFSET:
@@ -473,16 +471,16 @@ static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp pr
                 if(ApplyOffset(Source) == AL_FALSE)
                 {
                     UnlockContext(Context);
-                    RETERR(AL_INVALID_VALUE);
+                    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_VALUE, AL_FALSE);
                 }
             }
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
 
         case AL_SEC_OFFSET_LATENCY_SOFT:
             /* Query only */
-            RETERR(AL_INVALID_OPERATION);
+            SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_OPERATION, AL_FALSE);
 
 
         case AL_POSITION:
@@ -494,7 +492,7 @@ static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp pr
             Source->Position[2] = values[2];
             UnlockContext(Context);
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_VELOCITY:
             CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
@@ -505,7 +503,7 @@ static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp pr
             Source->Velocity[2] = values[2];
             UnlockContext(Context);
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DIRECTION:
             CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
@@ -516,12 +514,12 @@ static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp pr
             Source->Orientation[2] = values[2];
             UnlockContext(Context);
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
 
         case sfSampleRWOffsetsSOFT:
         case sfByteRWOffsetsSOFT:
-            RETERR(AL_INVALID_OPERATION);
+            SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_OPERATION, AL_FALSE);
 
 
         case sfSourceRelative:
@@ -534,20 +532,20 @@ static ALenum SetSourcefv(ALsource *Source, ALCcontext *Context, SrcFloatProp pr
         case sfAuxSendFilterGainHFAuto:
         case sfDirectChannelsSOFT:
             ival = (ALint)values[0];
-            return SetSourceiv(Source, Context, prop, &ival);
+            return SetSourceiv(Source, Context, (SrcIntProp)prop, &ival);
 
         case sfBuffer:
         case sfBuffersQueued:
         case sfBuffersProcessed:
             ival = (ALint)((ALuint)values[0]);
-            return SetSourceiv(Source, Context, prop, &ival);
+            return SetSourceiv(Source, Context, (SrcIntProp)prop, &ival);
     }
 
     ERR("Unexpected property: 0x%04x\n", prop);
-    RETERR(AL_INVALID_ENUM);
+    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_ENUM, AL_FALSE);
 }
 
-static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint *values)
+static ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint *values)
 {
     ALCdevice *device = Context->Device;
     ALbuffer  *buffer = NULL;
@@ -563,13 +561,13 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
 
             Source->HeadRelative = (ALboolean)*values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_LOOPING:
             CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
 
             Source->Looping = (ALboolean)*values;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_BUFFER:
             CHECKVAL(*values == 0 || (buffer=LookupBuffer(device, *values)) != NULL);
@@ -578,7 +576,7 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
             if(!(Source->state == AL_STOPPED || Source->state == AL_INITIAL))
             {
                 UnlockContext(Context);
-                RETERR(AL_INVALID_OPERATION);
+                SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_OPERATION, AL_FALSE);
             }
 
             Source->BuffersInQueue = 0;
@@ -629,14 +627,14 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
                 free(temp);
             }
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case siSourceState:
         case siSourceType:
         case siBuffersQueued:
         case siBuffersProcessed:
             /* Query only */
-            RETERR(AL_INVALID_OPERATION);
+            SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_OPERATION, AL_FALSE);
 
         case AL_SEC_OFFSET:
         case AL_SAMPLE_OFFSET:
@@ -653,17 +651,17 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
                 if(ApplyOffset(Source) == AL_FALSE)
                 {
                     UnlockContext(Context);
-                    RETERR(AL_INVALID_VALUE);
+                    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_VALUE, AL_FALSE);
                 }
             }
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
 
         case siSampleRWOffsetsSOFT:
         case siByteRWOffsetsSOFT:
             /* Query only */
-            RETERR(AL_INVALID_OPERATION);
+            SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_OPERATION, AL_FALSE);
 
 
         case AL_DIRECT_FILTER:
@@ -682,35 +680,35 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
             }
             UnlockContext(Context);
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DIRECT_FILTER_GAINHF_AUTO:
             CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
 
             Source->DryGainHFAuto = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         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;
+            return AL_TRUE;
 
         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;
+            return AL_TRUE;
 
         case AL_DIRECT_CHANNELS_SOFT:
             CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
 
             Source->DirectChannels = *values;
             Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DISTANCE_MODEL:
             CHECKVAL(*values == AL_NONE ||
@@ -724,7 +722,7 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
             Source->DistanceModel = *values;
             if(Context->SourceDistanceModel)
                 Source->NeedsUpdate = AL_TRUE;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
 
         case AL_AUXILIARY_SEND_FILTER:
@@ -734,7 +732,7 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
                  (values[2] == 0 || (filter=LookupFilter(device, values[2])) != NULL)))
             {
                 UnlockContext(Context);
-                RETERR(AL_INVALID_VALUE);
+                SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_VALUE, AL_FALSE);
             }
 
             /* Add refcount on the new slot, and release the previous slot */
@@ -755,7 +753,7 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
             }
             Source->NeedsUpdate = AL_TRUE;
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
 
         case AL_MAX_DISTANCE:
@@ -781,10 +779,10 @@ static ALenum SetSourceiv(ALsource *Source, ALCcontext *Context, SrcIntProp prop
     }
 
     ERR("Unexpected property: 0x%04x\n", prop);
-    RETERR(AL_INVALID_ENUM);
+    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_ENUM, AL_FALSE);
 }
 
-static ALenum SetSourcei64v(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint64SOFT *values)
+static ALboolean SetSourcei64v(ALsource *Source, ALCcontext *Context, SrcIntProp prop, const ALint64SOFT *values)
 {
     ALfloat fvals[3];
     ALint   ivals[3];
@@ -795,7 +793,7 @@ static ALenum SetSourcei64v(ALsource *Source, ALCcontext *Context, SrcIntProp pr
         case siByteRWOffsetsSOFT:
         case siSampleOffsetLatencySOFT:
             /* Query only */
-            RETERR(AL_INVALID_OPERATION);
+            SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_OPERATION, AL_FALSE);
 
 
         /* 1x int */
@@ -858,60 +856,60 @@ static ALenum SetSourcei64v(ALsource *Source, ALCcontext *Context, SrcIntProp pr
     }
 
     ERR("Unexpected property: 0x%04x\n", prop);
-    RETERR(AL_INVALID_ENUM);
+    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_ENUM, AL_FALSE);
 }
 
 #undef CHECKVAL
 
 
-static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatProp prop, ALdouble *values)
+static ALboolean GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatProp prop, ALdouble *values)
 {
     ALdouble offsets[2];
     ALdouble updateLen;
-    ALint    ivals[3];
-    ALenum   err;
+    ALint ivals[3];
+    ALboolean err;
 
     switch(prop)
     {
         case AL_GAIN:
             *values = Source->Gain;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_PITCH:
             *values = Source->Pitch;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MAX_DISTANCE:
             *values = Source->MaxDistance;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_ROLLOFF_FACTOR:
             *values = Source->RollOffFactor;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_REFERENCE_DISTANCE:
             *values = Source->RefDistance;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_INNER_ANGLE:
             *values = Source->InnerAngle;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_OUTER_ANGLE:
             *values = Source->OuterAngle;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MIN_GAIN:
             *values = Source->MinGain;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MAX_GAIN:
             *values = Source->MaxGain;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_OUTER_GAIN:
             *values = Source->OuterGain;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_SEC_OFFSET:
         case AL_SAMPLE_OFFSET:
@@ -922,23 +920,23 @@ static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatP
             GetSourceOffsets(Source, prop, offsets, updateLen);
             UnlockContext(Context);
             *values = offsets[0];
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_CONE_OUTER_GAINHF:
             *values = Source->OuterGainHF;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_AIR_ABSORPTION_FACTOR:
             *values = Source->AirAbsorptionFactor;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_ROOM_ROLLOFF_FACTOR:
             *values = Source->RoomRolloffFactor;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DOPPLER_FACTOR:
             *values = Source->DopplerFactor;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_SAMPLE_RW_OFFSETS_SOFT:
         case AL_BYTE_RW_OFFSETS_SOFT:
@@ -947,7 +945,7 @@ static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatP
                         Context->Device->Frequency;
             GetSourceOffsets(Source, prop, values, updateLen);
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_SEC_OFFSET_LATENCY_SOFT:
             LockContext(Context);
@@ -955,7 +953,7 @@ static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatP
             values[1] = (ALdouble)ALCdevice_GetLatency(Context->Device) /
                         1000000000.0;
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_POSITION:
             LockContext(Context);
@@ -963,7 +961,7 @@ static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatP
             values[1] = Source->Position[1];
             values[2] = Source->Position[2];
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_VELOCITY:
             LockContext(Context);
@@ -971,7 +969,7 @@ static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatP
             values[1] = Source->Velocity[1];
             values[2] = Source->Velocity[2];
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DIRECTION:
             LockContext(Context);
@@ -979,7 +977,7 @@ static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatP
             values[1] = Source->Orientation[1];
             values[2] = Source->Orientation[2];
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_SOURCE_RELATIVE:
         case AL_LOOPING:
@@ -993,30 +991,30 @@ static ALenum GetSourcedv(const ALsource *Source, ALCcontext *Context, SrcFloatP
         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)
+            if((err=GetSourceiv(Source, Context, (int)prop, ivals)) != AL_FALSE)
                 *values = (ALdouble)ivals[0];
             return err;
     }
 
     ERR("Unexpected property: 0x%04x\n", prop);
-    RETERR(AL_INVALID_ENUM);
+    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_ENUM, AL_FALSE);
 }
 
-static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint *values)
+static ALboolean GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint *values)
 {
     ALbufferlistitem *BufferList;
     ALdouble dvals[3];
-    ALenum   err;
+    ALboolean err;
 
     switch(prop)
     {
         case AL_SOURCE_RELATIVE:
             *values = Source->HeadRelative;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_LOOPING:
             *values = Source->Looping;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_BUFFER:
             LockContext(Context);
@@ -1033,15 +1031,15 @@ static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntPro
             *values = ((BufferList && BufferList->buffer) ?
                        BufferList->buffer->id : 0);
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_SOURCE_STATE:
             *values = Source->state;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_BUFFERS_QUEUED:
             *values = Source->BuffersInQueue;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_BUFFERS_PROCESSED:
             LockContext(Context);
@@ -1054,31 +1052,31 @@ static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntPro
             else
                 *values = Source->BuffersPlayed;
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_SOURCE_TYPE:
             *values = Source->SourceType;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DIRECT_FILTER_GAINHF_AUTO:
             *values = Source->DryGainHFAuto;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
             *values = Source->WetGainAuto;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
             *values = Source->WetGainHFAuto;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DIRECT_CHANNELS_SOFT:
             *values = Source->DirectChannels;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_DISTANCE_MODEL:
             *values = Source->DistanceModel;
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MAX_DISTANCE:
         case AL_ROLLOFF_FACTOR:
@@ -1089,13 +1087,13 @@ static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntPro
         case AL_SAMPLE_OFFSET:
         case AL_BYTE_OFFSET:
         case AL_DOPPLER_FACTOR:
-            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
+            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) != AL_FALSE)
                 *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)
+            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) != AL_FALSE)
             {
                 values[0] = (ALint)dvals[0];
                 values[1] = (ALint)dvals[1];
@@ -1105,7 +1103,7 @@ static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntPro
         case AL_POSITION:
         case AL_VELOCITY:
         case AL_DIRECTION:
-            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
+            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) != AL_FALSE)
             {
                 values[0] = (ALint)dvals[0];
                 values[1] = (ALint)dvals[1];
@@ -1124,14 +1122,14 @@ static ALenum GetSourceiv(const ALsource *Source, ALCcontext *Context, SrcIntPro
     }
 
     ERR("Unexpected property: 0x%04x\n", prop);
-    RETERR(AL_INVALID_ENUM);
+    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_ENUM, AL_FALSE);
 }
 
-static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint64 *values)
+static ALboolean GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntProp prop, ALint64 *values)
 {
     ALdouble dvals[3];
-    ALint    ivals[3];
-    ALenum   err;
+    ALint ivals[3];
+    ALboolean err;
 
     switch(prop)
     {
@@ -1140,7 +1138,7 @@ static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntP
             values[0] = GetSourceOffset(Source);
             values[1] = ALCdevice_GetLatency(Context->Device);
             UnlockContext(Context);
-            return AL_NO_ERROR;
+            return AL_TRUE;
 
         case AL_MAX_DISTANCE:
         case AL_ROLLOFF_FACTOR:
@@ -1151,13 +1149,13 @@ static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntP
         case AL_SAMPLE_OFFSET:
         case AL_BYTE_OFFSET:
         case AL_DOPPLER_FACTOR:
-            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
+            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) != AL_FALSE)
                 *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)
+            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) != AL_FALSE)
             {
                 values[0] = (ALint64)dvals[0];
                 values[1] = (ALint64)dvals[1];
@@ -1167,7 +1165,7 @@ static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntP
         case AL_POSITION:
         case AL_VELOCITY:
         case AL_DIRECTION:
-            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) == AL_NO_ERROR)
+            if((err=GetSourcedv(Source, Context, (int)prop, dvals)) != AL_FALSE)
             {
                 values[0] = (ALint64)dvals[0];
                 values[1] = (ALint64)dvals[1];
@@ -1186,18 +1184,18 @@ static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntP
         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)
+            if((err=GetSourceiv(Source, Context, (int)prop, ivals)) != AL_FALSE)
                 *values = ivals[0];
             return err;
 
         case siBuffer:
         case siDirectFilter:
-            if((err=GetSourceiv(Source, Context, (int)prop, ivals)) == AL_NO_ERROR)
+            if((err=GetSourceiv(Source, Context, (int)prop, ivals)) != AL_FALSE)
                 *values = ((ALuint*)ivals)[0];
             return err;
 
         case siAuxSendFilter:
-            if((err=GetSourceiv(Source, Context, (int)prop, ivals)) == AL_NO_ERROR)
+            if((err=GetSourceiv(Source, Context, (int)prop, ivals)) != AL_FALSE)
             {
                 values[0] = ((ALuint*)ivals)[0];
                 values[1] = ((ALuint*)ivals)[1];
@@ -1207,143 +1205,133 @@ static ALenum GetSourcei64v(const ALsource *Source, ALCcontext *Context, SrcIntP
     }
 
     ERR("Unexpected property: 0x%04x\n", prop);
-    RETERR(AL_INVALID_ENUM);
+    SET_ERROR_AND_RETURN_VALUE(Context, AL_INVALID_ENUM, AL_FALSE);
 }
 
-#undef RETERR
-
 
 AL_API ALvoid AL_APIENTRY alGenSources(ALsizei n, ALuint *sources)
 {
-    ALCcontext *Context;
-    ALsizei    cur = 0;
+    ALCcontext *context;
+    ALsizei cur = 0;
+    ALenum err;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
 
-    al_try
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    for(cur = 0;cur < n;cur++)
     {
-        ALenum err;
-
-        CHECK_VALUE(Context, n >= 0);
-        for(cur = 0;cur < n;cur++)
+        ALsource *source = al_calloc(16, sizeof(ALsource));
+        if(!source)
         {
-            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);
+            alDeleteSources(cur, sources);
+            SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
+        }
+        InitSourceParams(source);
 
-                al_throwerr(Context, err);
-            }
+        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);
 
-            sources[cur] = source->id;
-        }
-    }
-    al_catchany()
-    {
-        if(cur > 0)
             alDeleteSources(cur, sources);
+            SET_ERROR_AND_GOTO(context, err, done);
+        }
+
+        sources[cur] = source->id;
     }
-    al_endtry;
 
-    ALCcontext_DecRef(Context);
+done:
+    ALCcontext_DecRef(context);
 }
 
 
 AL_API ALvoid AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
 {
-    ALCcontext *Context;
+    ALCcontext *context;
+    ALbufferlistitem *BufferList;
+    ALsource *Source;
+    ALsizei i, j;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
 
-    al_try
-    {
-        ALbufferlistitem *BufferList;
-        ALsource *Source;
-        ALsizei i, j;
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 
-        CHECK_VALUE(Context, n >= 0);
+    /* Check that all Sources are valid */
+    for(i = 0;i < n;i++)
+    {
+        if(LookupSource(context, sources[i]) == NULL)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    }
+    for(i = 0;i < n;i++)
+    {
+        ALsource **srclist, **srclistend;
 
-        /* Check that all Sources are valid */
-        for(i = 0;i < n;i++)
-        {
-            if(LookupSource(Context, sources[i]) == NULL)
-                al_throwerr(Context, AL_INVALID_NAME);
-        }
+        if((Source=RemoveSource(context, sources[i])) == NULL)
+            continue;
+        FreeThunkEntry(Source->id);
 
-        for(i = 0;i < n;i++)
+        LockContext(context);
+        srclist = context->ActiveSources;
+        srclistend = srclist + context->ActiveSourceCount;
+        while(srclist != srclistend)
         {
-            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)
             {
-                if(*srclist == Source)
-                {
-                    Context->ActiveSourceCount--;
-                    *srclist = *(--srclistend);
-                    break;
-                }
-                srclist++;
+                context->ActiveSourceCount--;
+                *srclist = *(--srclistend);
+                break;
             }
-            UnlockContext(Context);
-
-            while(Source->queue != NULL)
-            {
-                BufferList = Source->queue;
-                Source->queue = BufferList->next;
+            srclist++;
+        }
+        UnlockContext(context);
 
-                if(BufferList->buffer != NULL)
-                    DecrementRef(&BufferList->buffer->ref);
-                free(BufferList);
-            }
+        while(Source->queue != NULL)
+        {
+            BufferList = Source->queue;
+            Source->queue = BufferList->next;
 
-            for(j = 0;j < MAX_SENDS;++j)
-            {
-                if(Source->Send[j].Slot)
-                    DecrementRef(&Source->Send[j].Slot->ref);
-                Source->Send[j].Slot = NULL;
-            }
+            if(BufferList->buffer != NULL)
+                DecrementRef(&BufferList->buffer->ref);
+            free(BufferList);
+        }
 
-            memset(Source, 0, sizeof(*Source));
-            al_free(Source);
+        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);
+done:
+    ALCcontext_DecRef(context);
 }
 
 
 AL_API ALboolean AL_APIENTRY alIsSource(ALuint source)
 {
-    ALCcontext *Context;
-    ALboolean  result;
+    ALCcontext *context;
+    ALboolean ret;
 
-    Context = GetContextRef();
-    if(!Context) return AL_FALSE;
+    context = GetContextRef();
+    if(!context) return AL_FALSE;
 
-    result = (LookupSource(Context, source) ? AL_TRUE : AL_FALSE);
+    ret = (LookupSource(context, source) ? AL_TRUE : AL_FALSE);
 
-    ALCcontext_DecRef(Context);
+    ALCcontext_DecRef(context);
 
-    return result;
+    return ret;
 }
 
 
@@ -1615,7 +1603,7 @@ AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *val
     else
     {
         ALdouble dval;
-        if(GetSourcedv(Source, Context, param, &dval) == AL_NO_ERROR)
+        if(GetSourcedv(Source, Context, param, &dval))
             *value = (ALfloat)dval;
     }
 
@@ -1640,7 +1628,7 @@ AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *va
     else
     {
         ALdouble dvals[3];
-        if(GetSourcedv(Source, Context, param, dvals) == AL_NO_ERROR)
+        if(GetSourcedv(Source, Context, param, dvals))
         {
             *value1 = (ALfloat)dvals[0];
             *value2 = (ALfloat)dvals[1];
@@ -1670,7 +1658,7 @@ AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *va
     else
     {
         ALdouble dvals[3];
-        if(GetSourcedv(Source, Context, param, dvals) == AL_NO_ERROR)
+        if(GetSourcedv(Source, Context, param, dvals))
         {
             ALint i;
             for(i = 0;i < count;i++)
@@ -1719,7 +1707,7 @@ AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble
     else
     {
         ALdouble dvals[3];
-        if(GetSourcedv(Source, Context, param, dvals) == AL_NO_ERROR)
+        if(GetSourcedv(Source, Context, param, dvals))
         {
             *value1 = dvals[0];
             *value2 = dvals[1];
@@ -1789,7 +1777,7 @@ AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1
     else
     {
         ALint ivals[3];
-        if(GetSourceiv(Source, Context, param, ivals) == AL_NO_ERROR)
+        if(GetSourceiv(Source, Context, param, ivals))
         {
             *value1 = ivals[0];
             *value2 = ivals[1];
@@ -1859,7 +1847,7 @@ AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64
     else
     {
         ALint64 i64vals[3];
-        if(GetSourcei64v(Source, Context, param, i64vals) == AL_NO_ERROR)
+        if(GetSourcei64v(Source, Context, param, i64vals))
         {
             *value1 = i64vals[0];
             *value2 = i64vals[1];
@@ -1897,53 +1885,51 @@ AL_API ALvoid AL_APIENTRY alSourcePlay(ALuint source)
 }
 AL_API ALvoid AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources)
 {
-    ALCcontext *Context;
-    ALsource   *Source;
-    ALsizei    i;
+    ALCcontext *context;
+    ALsource *source;
+    ALsizei i;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
 
-    al_try
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    for(i = 0;i < n;i++)
     {
-        CHECK_VALUE(Context, n >= 0);
-        for(i = 0;i < n;i++)
-        {
-            if(!LookupSource(Context, sources[i]))
-                al_throwerr(Context, AL_INVALID_NAME);
-        }
+        if(!LookupSource(context, sources[i]))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    }
 
-        LockContext(Context);
-        while(Context->MaxActiveSources-Context->ActiveSourceCount < n)
+    LockContext(context);
+    while(n > context->MaxActiveSources-context->ActiveSourceCount)
+    {
+        void *temp = NULL;
+        ALsizei newcount;
+
+        newcount = context->MaxActiveSources << 1;
+        if(newcount > 0)
+            temp = realloc(context->ActiveSources,
+                           sizeof(*context->ActiveSources) * newcount);
+        if(!temp)
         {
-            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;
+            UnlockContext(context);
+            SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
         }
 
-        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);
+        context->ActiveSources = temp;
+        context->MaxActiveSources = newcount;
     }
-    al_endtry;
 
-    ALCcontext_DecRef(Context);
+    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);
+
+done:
+    ALCcontext_DecRef(context);
 }
 
 AL_API ALvoid AL_APIENTRY alSourcePause(ALuint source)
@@ -1952,34 +1938,32 @@ AL_API ALvoid AL_APIENTRY alSourcePause(ALuint source)
 }
 AL_API ALvoid AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
 {
-    ALCcontext *Context;
-    ALsource   *Source;
-    ALsizei    i;
+    ALCcontext *context;
+    ALsource *source;
+    ALsizei i;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
 
-    al_try
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    for(i = 0;i < n;i++)
     {
-        CHECK_VALUE(Context, n >= 0);
-        for(i = 0;i < n;i++)
-        {
-            if(!LookupSource(Context, sources[i]))
-                al_throwerr(Context, AL_INVALID_NAME);
-        }
+        if(!LookupSource(context, sources[i]))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    }
 
-        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);
+    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);
     }
-    al_endtry;
+    UnlockContext(context);
 
-    ALCcontext_DecRef(Context);
+done:
+    ALCcontext_DecRef(context);
 }
 
 AL_API ALvoid AL_APIENTRY alSourceStop(ALuint source)
@@ -1988,34 +1972,32 @@ AL_API ALvoid AL_APIENTRY alSourceStop(ALuint source)
 }
 AL_API ALvoid AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
 {
-    ALCcontext *Context;
-    ALsource   *Source;
-    ALsizei    i;
+    ALCcontext *context;
+    ALsource *source;
+    ALsizei i;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
 
-    al_try
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    for(i = 0;i < n;i++)
     {
-        CHECK_VALUE(Context, n >= 0);
-        for(i = 0;i < n;i++)
-        {
-            if(!LookupSource(Context, sources[i]))
-                al_throwerr(Context, AL_INVALID_NAME);
-        }
+        if(!LookupSource(context, sources[i]))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    }
 
-        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);
+    LockContext(context);
+    for(i = 0;i < n;i++)
+    {
+        source = LookupSource(context, sources[i]);
+        source->new_state = AL_NONE;
+        SetSourceState(source, context, AL_STOPPED);
     }
-    al_endtry;
+    UnlockContext(context);
 
-    ALCcontext_DecRef(Context);
+done:
+    ALCcontext_DecRef(context);
 }
 
 AL_API ALvoid AL_APIENTRY alSourceRewind(ALuint source)
@@ -2024,226 +2006,217 @@ AL_API ALvoid AL_APIENTRY alSourceRewind(ALuint source)
 }
 AL_API ALvoid AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
 {
-    ALCcontext *Context;
-    ALsource   *Source;
-    ALsizei    i;
+    ALCcontext *context;
+    ALsource *source;
+    ALsizei i;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
 
-    al_try
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    for(i = 0;i < n;i++)
     {
-        CHECK_VALUE(Context, n >= 0);
-        for(i = 0;i < n;i++)
-        {
-            if(!LookupSource(Context, sources[i]))
-                al_throwerr(Context, AL_INVALID_NAME);
-        }
+        if(!LookupSource(context, sources[i]))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    }
 
-        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);
+    LockContext(context);
+    for(i = 0;i < n;i++)
+    {
+        source = LookupSource(context, sources[i]);
+        source->new_state = AL_NONE;
+        SetSourceState(source, context, AL_INITIAL);
     }
-    al_endtry;
+    UnlockContext(context);
 
-    ALCcontext_DecRef(Context);
+done:
+    ALCcontext_DecRef(context);
 }
 
 
-AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers)
+AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALuint *buffers)
 {
-    ALCcontext *Context;
-    ALsource   *Source;
-    ALsizei    i;
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsource *source;
+    ALsizei i;
     ALbufferlistitem *BufferListStart = NULL;
     ALbufferlistitem *BufferList;
-    ALbuffer *BufferFmt;
+    ALbuffer *BufferFmt = NULL;
 
     if(nb == 0)
         return;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
 
-    al_try
-    {
-        ALCdevice *device = Context->Device;
+    device = context->Device;
 
-        CHECK_VALUE(Context, nb >= 0);
+    if(!(nb >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    if((source=LookupSource(context, src)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 
-        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 */
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    }
 
-        LockContext(Context);
-        if(Source->SourceType == AL_STATIC)
+    /* Check for a valid Buffer, for its frequency and format */
+    BufferList = source->queue;
+    while(BufferList)
+    {
+        if(BufferList->buffer)
         {
-            UnlockContext(Context);
-            /* Can't queue on a Static Source */
-            al_throwerr(Context, AL_INVALID_OPERATION);
+            BufferFmt = BufferList->buffer;
+            break;
         }
+        BufferList = BufferList->next;
+    }
 
-        BufferFmt = NULL;
+    for(i = 0;i < nb;i++)
+    {
+        ALbuffer *buffer = NULL;
+        if(buffers[i] && (buffer=LookupBuffer(device, buffers[i])) == NULL)
+        {
+            UnlockContext(context);
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        }
 
-        /* Check for a valid Buffer, for its frequency and format */
-        BufferList = Source->queue;
-        while(BufferList)
+        if(!BufferListStart)
         {
-            if(BufferList->buffer)
-            {
-                BufferFmt = BufferList->buffer;
-                break;
-            }
+            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);
 
-        for(i = 0;i < nb;i++)
+        ReadLock(&buffer->lock);
+        if(BufferFmt == NULL)
         {
-            ALbuffer *buffer = NULL;
-            if(buffers[i] && (buffer=LookupBuffer(device, buffers[i])) == NULL)
-            {
-                UnlockContext(Context);
-                al_throwerr(Context, AL_INVALID_NAME);
-            }
+            BufferFmt = buffer;
 
-            if(!BufferListStart)
-            {
-                BufferListStart = malloc(sizeof(ALbufferlistitem));
-                BufferListStart->buffer = buffer;
-                BufferListStart->next = NULL;
-                BufferListStart->prev = NULL;
-                BufferList = BufferListStart;
-            }
+            source->NumChannels = ChannelsFromFmt(buffer->FmtChannels);
+            source->SampleSize  = BytesFromFmt(buffer->FmtType);
+            if(buffer->FmtChannels == FmtMono)
+                source->Update = CalcSourceParams;
             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->Update = CalcNonAttnSourceParams;
 
-                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);
-            }
+            source->NeedsUpdate = AL_TRUE;
+        }
+        else if(BufferFmt->Frequency != buffer->Frequency ||
+                BufferFmt->OriginalChannels != buffer->OriginalChannels ||
+                BufferFmt->OriginalType != buffer->OriginalType)
+        {
             ReadUnlock(&buffer->lock);
+            UnlockContext(context);
+            SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
         }
+        ReadUnlock(&buffer->lock);
+    }
 
-        /* Source is now streaming */
-        Source->SourceType = AL_STREAMING;
+    /* 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;
+    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->prev = BufferList;
+        BufferList->next = BufferListStart;
+    }
+    BufferListStart = NULL;
 
-        Source->BuffersInQueue += nb;
+    source->BuffersInQueue += nb;
 
-        UnlockContext(Context);
-    }
-    al_catchany()
+    UnlockContext(context);
+
+done:
+    while(BufferListStart)
     {
-        while(BufferListStart)
-        {
-            BufferList = BufferListStart;
-            BufferListStart = BufferList->next;
+        BufferList = BufferListStart;
+        BufferListStart = BufferList->next;
 
-            if(BufferList->buffer)
-                DecrementRef(&BufferList->buffer->ref);
-            free(BufferList);
-        }
+        if(BufferList->buffer)
+            DecrementRef(&BufferList->buffer->ref);
+        free(BufferList);
     }
-    al_endtry;
 
-    ALCcontext_DecRef(Context);
+    ALCcontext_DecRef(context);
 }
 
-AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers)
+AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint src, ALsizei nb, ALuint *buffers)
 {
-    ALCcontext *Context;
-    ALsource   *Source;
-    ALsizei    i;
+    ALCcontext *context;
+    ALsource *source;
+    ALsizei i;
     ALbufferlistitem *BufferList;
 
     if(nb == 0)
         return;
 
-    Context = GetContextRef();
-    if(!Context) return;
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(nb >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 
-    al_try
+    if((source=LookupSource(context, src)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+
+    LockContext(context);
+    if(source->Looping || source->SourceType != AL_STREAMING ||
+       (ALuint)nb > source->BuffersPlayed)
     {
-        CHECK_VALUE(Context, nb >= 0);
+        UnlockContext(context);
+        /* Trying to unqueue pending buffers, or a buffer that wasn't queued. */
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    }
 
-        if((Source=LookupSource(Context, source)) == NULL)
-            al_throwerr(Context, AL_INVALID_NAME);
+    for(i = 0;i < nb;i++)
+    {
+        BufferList = source->queue;
+        source->queue = BufferList->next;
+        source->BuffersInQueue--;
+        source->BuffersPlayed--;
 
-        LockContext(Context);
-        if(Source->Looping || Source->SourceType != AL_STREAMING ||
-           (ALuint)nb > Source->BuffersPlayed)
+        if(BufferList->buffer)
         {
-            UnlockContext(Context);
-            /* Trying to unqueue pending buffers, or a buffer that wasn't queued. */
-            al_throwerr(Context, AL_INVALID_VALUE);
+            buffers[i] = BufferList->buffer->id;
+            DecrementRef(&BufferList->buffer->ref);
         }
+        else
+            buffers[i] = 0;
 
-        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);
+        free(BufferList);
     }
-    al_endtry;
+    if(source->queue)
+        source->queue->prev = NULL;
+    UnlockContext(context);
 
-    ALCcontext_DecRef(Context);
+done:
+    ALCcontext_DecRef(context);
 }
 
 
@@ -2328,7 +2301,7 @@ ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state)
 
         if(Source->state != AL_PLAYING)
         {
-            for(j = 0;j < MaxChannels;j++)
+            for(j = 0;j < MAX_INPUT_CHANNELS;j++)
             {
                 for(k = 0;k < SRC_HISTORY_LENGTH;k++)
                     Source->Hrtf.History[j][k] = 0.0f;
@@ -2432,7 +2405,7 @@ static ALint64 GetSourceOffset(const ALsource *Source)
         BufferList = BufferList->next;
     }
 
-    return (ALint64)minu64(readPos, MAKEU64(0x7fffffff,0xffffffff));
+    return (ALint64)minu64(readPos, U64(0x7fffffffffffffff));
 }
 
 /* GetSourceSecOffset