Merge branch 'v1.19' of git://repo.or.cz/openal-soft into v1.19v1.19

1 files changed, 436 insertions, 184 deletions

diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c
index c1314301..8141e0f6 100644
--- a/OpenAL32/alAuxEffectSlot.c
+++ b/OpenAL32/alAuxEffectSlot.c
@@ -27,83 +27,145 @@
 #include "AL/alc.h"
 #include "alMain.h"
 #include "alAuxEffectSlot.h"
-#include "alThunk.h"
 #include "alError.h"
+#include "alListener.h"
 #include "alSource.h"
 
+#include "fpu_modes.h"
+#include "almalloc.h"
+
+
+extern inline void LockEffectSlotList(ALCcontext *context);
+extern inline void UnlockEffectSlotList(ALCcontext *context);
+
+static void AddActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcontext *context);
+static void RemoveActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcontext *context);
+
+static const struct {
+    ALenum Type;
+    EffectStateFactory* (*GetFactory)(void);
+} FactoryList[] = {
+    { AL_EFFECT_NULL, NullStateFactory_getFactory },
+    { AL_EFFECT_EAXREVERB, ReverbStateFactory_getFactory },
+    { AL_EFFECT_REVERB, ReverbStateFactory_getFactory },
+    { AL_EFFECT_AUTOWAH, AutowahStateFactory_getFactory },
+    { AL_EFFECT_CHORUS, ChorusStateFactory_getFactory },
+    { AL_EFFECT_COMPRESSOR, CompressorStateFactory_getFactory },
+    { AL_EFFECT_DISTORTION, DistortionStateFactory_getFactory },
+    { AL_EFFECT_ECHO, EchoStateFactory_getFactory },
+    { AL_EFFECT_EQUALIZER, EqualizerStateFactory_getFactory },
+    { AL_EFFECT_FLANGER, FlangerStateFactory_getFactory },
+    { AL_EFFECT_FREQUENCY_SHIFTER, FshifterStateFactory_getFactory },
+    { AL_EFFECT_RING_MODULATOR, ModulatorStateFactory_getFactory },
+    { AL_EFFECT_PITCH_SHIFTER, PshifterStateFactory_getFactory},
+    { AL_EFFECT_DEDICATED_DIALOGUE, DedicatedStateFactory_getFactory },
+    { AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, DedicatedStateFactory_getFactory }
+};
+
+static inline EffectStateFactory *getFactoryByType(ALenum type)
+{
+    size_t i;
+    for(i = 0;i < COUNTOF(FactoryList);i++)
+    {
+        if(FactoryList[i].Type == type)
+            return FactoryList[i].GetFactory();
+    }
+    return NULL;
+}
 
-extern inline struct ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id);
-extern inline struct ALeffectslot *RemoveEffectSlot(ALCcontext *context, ALuint id);
+static void ALeffectState_IncRef(ALeffectState *state);
 
-static ALenum AddEffectSlotArray(ALCcontext *Context, ALeffectslot **start, ALsizei count);
-static void RemoveEffectSlotArray(ALCcontext *Context, const ALeffectslot *slot);
 
+static inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id)
+{
+    id--;
+    if(UNLIKELY(id >= VECTOR_SIZE(context->EffectSlotList)))
+        return NULL;
+    return VECTOR_ELEM(context->EffectSlotList, id);
+}
 
-static UIntMap EffectStateFactoryMap;
-static inline ALeffectStateFactory *getFactoryByType(ALenum type)
+static inline ALeffect *LookupEffect(ALCdevice *device, ALuint id)
 {
-    ALeffectStateFactory* (*getFactory)(void) = LookupUIntMapKey(&EffectStateFactoryMap, type);
-    if(getFactory != NULL)
-        return getFactory();
-    return NULL;
+    EffectSubList *sublist;
+    ALuint lidx = (id-1) >> 6;
+    ALsizei slidx = (id-1) & 0x3f;
+
+    if(UNLIKELY(lidx >= VECTOR_SIZE(device->EffectList)))
+        return NULL;
+    sublist = &VECTOR_ELEM(device->EffectList, lidx);
+    if(UNLIKELY(sublist->FreeMask & (U64(1)<<slidx)))
+        return NULL;
+    return sublist->Effects + slidx;
 }
 
 
+#define DO_UPDATEPROPS() do {                                                 \
+    if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))          \
+        UpdateEffectSlotProps(slot, context);                                 \
+    else                                                                      \
+        ATOMIC_FLAG_CLEAR(&slot->PropsClean, almemory_order_release);         \
+} while(0)
+
+
 AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 {
+    ALCdevice *device;
     ALCcontext *context;
-    VECTOR(ALeffectslot*) slotvec;
     ALsizei cur;
-    ALenum err;
 
     context = GetContextRef();
     if(!context) return;
 
-    VECTOR_INIT(slotvec);
-
     if(!(n >= 0))
-        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
-    if(!VECTOR_RESERVE(slotvec, n))
-        SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
+        SETERR_GOTO(context, AL_INVALID_VALUE, done, "Generating %d effect slots", n);
+    if(n == 0) goto done;
 
+    LockEffectSlotList(context);
+    device = context->Device;
     for(cur = 0;cur < n;cur++)
     {
-        ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
-        err = AL_OUT_OF_MEMORY;
-        if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
+        ALeffectslotPtr *iter = VECTOR_BEGIN(context->EffectSlotList);
+        ALeffectslotPtr *end = VECTOR_END(context->EffectSlotList);
+        ALeffectslot *slot = NULL;
+        ALenum err = AL_OUT_OF_MEMORY;
+
+        for(;iter != end;iter++)
         {
-            al_free(slot);
-            alDeleteAuxiliaryEffectSlots(cur, effectslots);
-            SET_ERROR_AND_GOTO(context, err, done);
+            if(!*iter)
+                break;
         }
-
-        err = NewThunkEntry(&slot->id);
-        if(err == AL_NO_ERROR)
-            err = InsertUIntMapEntry(&context->EffectSlotMap, slot->id, slot);
-        if(err != AL_NO_ERROR)
+        if(iter == end)
+        {
+            if(device->AuxiliaryEffectSlotMax == VECTOR_SIZE(context->EffectSlotList))
+            {
+                UnlockEffectSlotList(context);
+                alDeleteAuxiliaryEffectSlots(cur, effectslots);
+                SETERR_GOTO(context, AL_OUT_OF_MEMORY, done,
+                    "Exceeding %u auxiliary effect slot limit", device->AuxiliaryEffectSlotMax);
+            }
+            VECTOR_PUSH_BACK(context->EffectSlotList, NULL);
+            iter = &VECTOR_BACK(context->EffectSlotList);
+        }
+        slot = al_calloc(16, sizeof(ALeffectslot));
+        if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
         {
-            FreeThunkEntry(slot->id);
-            DELETE_OBJ(slot->EffectState);
             al_free(slot);
+            UnlockEffectSlotList(context);
 
             alDeleteAuxiliaryEffectSlots(cur, effectslots);
-            SET_ERROR_AND_GOTO(context, err, done);
+            SETERR_GOTO(context, err, done, "Effect slot object allocation failed");
         }
+        aluInitEffectPanning(slot);
 
-        VECTOR_PUSH_BACK(slotvec, slot);
+        slot->id = (iter - VECTOR_BEGIN(context->EffectSlotList)) + 1;
+        *iter = slot;
 
         effectslots[cur] = slot->id;
     }
-    err = AddEffectSlotArray(context, VECTOR_ITER_BEGIN(slotvec), n);
-    if(err != AL_NO_ERROR)
-    {
-        alDeleteAuxiliaryEffectSlots(cur, effectslots);
-        SET_ERROR_AND_GOTO(context, err, done);
-    }
+    AddActiveEffectSlots(effectslots, n, context);
+    UnlockEffectSlotList(context);
 
 done:
-    VECTOR_DEINIT(slotvec);
-
     ALCcontext_DecRef(context);
 }
 
@@ -116,31 +178,37 @@ AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *
     context = GetContextRef();
     if(!context) return;
 
+    LockEffectSlotList(context);
     if(!(n >= 0))
-        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+        SETERR_GOTO(context, AL_INVALID_VALUE, done, "Deleting %d effect slots", n);
+    if(n == 0) goto done;
+
     for(i = 0;i < n;i++)
     {
         if((slot=LookupEffectSlot(context, effectslots[i])) == NULL)
-            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+            SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u",
+                        effectslots[i]);
         if(ReadRef(&slot->ref) != 0)
-            SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+            SETERR_GOTO(context, AL_INVALID_NAME, done, "Deleting in-use effect slot %u",
+                        effectslots[i]);
     }
 
     // All effectslots are valid
+    RemoveActiveEffectSlots(effectslots, n, context);
     for(i = 0;i < n;i++)
     {
-        if((slot=RemoveEffectSlot(context, effectslots[i])) == NULL)
+        if((slot=LookupEffectSlot(context, effectslots[i])) == NULL)
             continue;
-        FreeThunkEntry(slot->id);
+        VECTOR_ELEM(context->EffectSlotList, effectslots[i]-1) = NULL;
 
-        RemoveEffectSlotArray(context, slot);
-        DELETE_OBJ(slot->EffectState);
+        DeinitEffectSlot(slot);
 
         memset(slot, 0, sizeof(*slot));
         al_free(slot);
     }
 
 done:
+    UnlockEffectSlotList(context);
     ALCcontext_DecRef(context);
 }
 
@@ -152,7 +220,9 @@ AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
     context = GetContextRef();
     if(!context) return AL_FALSE;
 
+    LockEffectSlotList(context);
     ret = (LookupEffectSlot(context, effectslot) ? AL_TRUE : AL_FALSE);
+    UnlockEffectSlotList(context);
 
     ALCcontext_DecRef(context);
 
@@ -170,35 +240,45 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param
     context = GetContextRef();
     if(!context) return;
 
-    device = context->Device;
+    almtx_lock(&context->PropLock);
+    LockEffectSlotList(context);
     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     case AL_EFFECTSLOT_EFFECT:
+        device = context->Device;
+
+        LockEffectList(device);
         effect = (value ? LookupEffect(device, value) : NULL);
         if(!(value == 0 || effect != NULL))
-            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+        {
+            UnlockEffectList(device);
+            SETERR_GOTO(context, AL_INVALID_VALUE, done, "Invalid effect ID %u", value);
+        }
+        err = InitializeEffect(context, slot, effect);
+        UnlockEffectList(device);
 
-        err = InitializeEffect(device, slot, effect);
         if(err != AL_NO_ERROR)
-            SET_ERROR_AND_GOTO(context, err, done);
-        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+            SETERR_GOTO(context, err, done, "Effect initialization failed");
         break;
 
     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
         if(!(value == AL_TRUE || value == AL_FALSE))
-            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
-
+            SETERR_GOTO(context, AL_INVALID_VALUE, done,
+                        "Effect slot auxiliary send auto out of range");
         slot->AuxSendAuto = value;
-        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
         break;
 
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        SETERR_GOTO(context, AL_INVALID_ENUM, done, "Invalid effect slot integer property 0x%04x",
+                    param);
     }
+    DO_UPDATEPROPS();
 
 done:
+    UnlockEffectSlotList(context);
+    almtx_unlock(&context->PropLock);
     ALCcontext_DecRef(context);
 }
 
@@ -217,15 +297,18 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum para
     context = GetContextRef();
     if(!context) return;
 
+    LockEffectSlotList(context);
     if(LookupEffectSlot(context, effectslot) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        alSetError(context, AL_INVALID_ENUM, "Invalid effect slot integer-vector property 0x%04x",
+                   param);
     }
 
 done:
+    UnlockEffectSlotList(context);
     ALCcontext_DecRef(context);
 }
 
@@ -237,23 +320,27 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param
     context = GetContextRef();
     if(!context) return;
 
+    almtx_lock(&context->PropLock);
+    LockEffectSlotList(context);
     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     case AL_EFFECTSLOT_GAIN:
         if(!(value >= 0.0f && value <= 1.0f))
-            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
-
+            SETERR_GOTO(context, AL_INVALID_VALUE, done, "Effect slot gain out of range");
         slot->Gain = value;
-        ATOMIC_STORE(&slot->NeedsUpdate, AL_TRUE);
         break;
 
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        SETERR_GOTO(context, AL_INVALID_ENUM, done, "Invalid effect slot float property 0x%04x",
+                    param);
     }
+    DO_UPDATEPROPS();
 
 done:
+    UnlockEffectSlotList(context);
+    almtx_unlock(&context->PropLock);
     ALCcontext_DecRef(context);
 }
 
@@ -271,15 +358,18 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum para
     context = GetContextRef();
     if(!context) return;
 
+    LockEffectSlotList(context);
     if(LookupEffectSlot(context, effectslot) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        alSetError(context, AL_INVALID_ENUM, "Invalid effect slot float-vector property 0x%04x",
+                   param);
     }
 
 done:
+    UnlockEffectSlotList(context);
     ALCcontext_DecRef(context);
 }
 
@@ -291,8 +381,9 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum pa
     context = GetContextRef();
     if(!context) return;
 
+    LockEffectSlotList(context);
     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
@@ -300,10 +391,11 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum pa
         break;
 
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        alSetError(context, AL_INVALID_ENUM, "Invalid effect slot integer property 0x%04x", param);
     }
 
 done:
+    UnlockEffectSlotList(context);
     ALCcontext_DecRef(context);
 }
 
@@ -322,15 +414,18 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum p
     context = GetContextRef();
     if(!context) return;
 
+    LockEffectSlotList(context);
     if(LookupEffectSlot(context, effectslot) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        alSetError(context, AL_INVALID_ENUM, "Invalid effect slot integer-vector property 0x%04x",
+                   param);
     }
 
 done:
+    UnlockEffectSlotList(context);
     ALCcontext_DecRef(context);
 }
 
@@ -342,8 +437,9 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum pa
     context = GetContextRef();
     if(!context) return;
 
+    LockEffectSlotList(context);
     if((slot=LookupEffectSlot(context, effectslot)) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     case AL_EFFECTSLOT_GAIN:
@@ -351,10 +447,11 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum pa
         break;
 
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        alSetError(context, AL_INVALID_ENUM, "Invalid effect slot float property 0x%04x", param);
     }
 
 done:
+    UnlockEffectSlotList(context);
     ALCcontext_DecRef(context);
 }
 
@@ -372,82 +469,32 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum p
     context = GetContextRef();
     if(!context) return;
 
+    LockEffectSlotList(context);
     if(LookupEffectSlot(context, effectslot) == NULL)
-        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid effect slot ID %u", effectslot);
     switch(param)
     {
     default:
-        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+        alSetError(context, AL_INVALID_ENUM, "Invalid effect slot float-vector property 0x%04x",
+                   param);
     }
 
 done:
+    UnlockEffectSlotList(context);
     ALCcontext_DecRef(context);
 }
 
 
-static ALenum AddEffectSlotArray(ALCcontext *context, ALeffectslot **start, ALsizei count)
-{
-    ALenum err = AL_NO_ERROR;
-
-    LockContext(context);
-    if(!VECTOR_INSERT(context->ActiveAuxSlots, VECTOR_ITER_END(context->ActiveAuxSlots), start, start+count))
-        err = AL_OUT_OF_MEMORY;
-    UnlockContext(context);
-
-    return err;
-}
-
-static void RemoveEffectSlotArray(ALCcontext *context, const ALeffectslot *slot)
-{
-    ALeffectslot **iter;
-
-    LockContext(context);
-#define MATCH_SLOT(_i)  (slot == *(_i))
-    VECTOR_FIND_IF(iter, ALeffectslot*, context->ActiveAuxSlots, MATCH_SLOT);
-    if(iter != VECTOR_ITER_END(context->ActiveAuxSlots))
-    {
-        *iter = VECTOR_BACK(context->ActiveAuxSlots);
-        VECTOR_POP_BACK(context->ActiveAuxSlots);
-    }
-#undef MATCH_SLOT
-    UnlockContext(context);
-}
-
-
-void InitEffectFactoryMap(void)
-{
-    InitUIntMap(&EffectStateFactoryMap, ~0);
-
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_NULL, ALnullStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_EAXREVERB, ALreverbStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_REVERB, ALreverbStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_AUTOWAH, ALautowahStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_CHORUS, ALchorusStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_COMPRESSOR, ALcompressorStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DISTORTION, ALdistortionStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_ECHO, ALechoStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_EQUALIZER, ALequalizerStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_FLANGER, ALflangerStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_RING_MODULATOR, ALmodulatorStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DEDICATED_DIALOGUE, ALdedicatedStateFactory_getFactory);
-    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, ALdedicatedStateFactory_getFactory);
-}
-
-void DeinitEffectFactoryMap(void)
-{
-    ResetUIntMap(&EffectStateFactoryMap);
-}
-
-
-ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *effect)
+ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect)
 {
+    ALCdevice *Device = Context->Device;
     ALenum newtype = (effect ? effect->type : AL_EFFECT_NULL);
-    ALeffectStateFactory *factory;
+    struct ALeffectslotProps *props;
+    ALeffectState *State;
 
-    if(newtype != EffectSlot->EffectType)
+    if(newtype != EffectSlot->Effect.Type)
     {
-        ALeffectState *State;
-        FPUCtl oldMode;
+        EffectStateFactory *factory;
 
         factory = getFactoryByType(newtype);
         if(!factory)
@@ -455,96 +502,301 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e
             ERR("Failed to find factory for effect type 0x%04x\n", newtype);
             return AL_INVALID_ENUM;
         }
-        State = V0(factory,create)();
-        if(!State)
-            return AL_OUT_OF_MEMORY;
-
-        SetMixerFPUMode(&oldMode);
+        State = EffectStateFactory_create(factory);
+        if(!State) return AL_OUT_OF_MEMORY;
 
-        ALCdevice_Lock(Device);
+        START_MIXER_MODE();
+        almtx_lock(&Device->BackendLock);
+        State->OutBuffer = Device->Dry.Buffer;
+        State->OutChannels = Device->Dry.NumChannels;
         if(V(State,deviceUpdate)(Device) == AL_FALSE)
         {
-            ALCdevice_Unlock(Device);
-            RestoreFPUMode(&oldMode);
-            DELETE_OBJ(State);
+            almtx_unlock(&Device->BackendLock);
+            LEAVE_MIXER_MODE();
+            ALeffectState_DecRef(State);
             return AL_OUT_OF_MEMORY;
         }
+        almtx_unlock(&Device->BackendLock);
+        END_MIXER_MODE();
 
-        State = ExchangePtr((XchgPtr*)&EffectSlot->EffectState, State);
         if(!effect)
         {
-            memset(&EffectSlot->EffectProps, 0, sizeof(EffectSlot->EffectProps));
-            EffectSlot->EffectType = AL_EFFECT_NULL;
+            EffectSlot->Effect.Type = AL_EFFECT_NULL;
+            memset(&EffectSlot->Effect.Props, 0, sizeof(EffectSlot->Effect.Props));
         }
         else
         {
-            memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props));
-            EffectSlot->EffectType = effect->type;
+            EffectSlot->Effect.Type = effect->type;
+            EffectSlot->Effect.Props = effect->Props;
         }
 
-        /* FIXME: This should be done asynchronously, but since the EffectState
-         * object was changed, it needs an update before its Process method can
-         * be called. */
-        ATOMIC_STORE(&EffectSlot->NeedsUpdate, AL_FALSE);
-        V(EffectSlot->EffectState,update)(Device, EffectSlot);
-        ALCdevice_Unlock(Device);
+        ALeffectState_DecRef(EffectSlot->Effect.State);
+        EffectSlot->Effect.State = State;
+    }
+    else if(effect)
+        EffectSlot->Effect.Props = effect->Props;
+
+    /* Remove state references from old effect slot property updates. */
+    props = ATOMIC_LOAD_SEQ(&Context->FreeEffectslotProps);
+    while(props)
+    {
+        if(props->State)
+            ALeffectState_DecRef(props->State);
+        props->State = NULL;
+        props = ATOMIC_LOAD(&props->next, almemory_order_relaxed);
+    }
+
+    return AL_NO_ERROR;
+}
 
-        RestoreFPUMode(&oldMode);
 
-        DELETE_OBJ(State);
-        State = NULL;
+static void ALeffectState_IncRef(ALeffectState *state)
+{
+    uint ref;
+    ref = IncrementRef(&state->Ref);
+    TRACEREF("%p increasing refcount to %u\n", state, ref);
+}
+
+void ALeffectState_DecRef(ALeffectState *state)
+{
+    uint ref;
+    ref = DecrementRef(&state->Ref);
+    TRACEREF("%p decreasing refcount to %u\n", state, ref);
+    if(ref == 0) DELETE_OBJ(state);
+}
+
+
+void ALeffectState_Construct(ALeffectState *state)
+{
+    InitRef(&state->Ref, 1);
+
+    state->OutBuffer = NULL;
+    state->OutChannels = 0;
+}
+
+void ALeffectState_Destruct(ALeffectState *UNUSED(state))
+{
+}
+
+
+static void AddActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcontext *context)
+{
+    struct ALeffectslotArray *curarray = ATOMIC_LOAD(&context->ActiveAuxSlots,
+                                                     almemory_order_acquire);
+    struct ALeffectslotArray *newarray = NULL;
+    ALsizei newcount = curarray->count + count;
+    ALCdevice *device = context->Device;
+    ALsizei i, j;
+
+    /* Insert the new effect slots into the head of the array, followed by the
+     * existing ones.
+     */
+    newarray = al_calloc(DEF_ALIGN, FAM_SIZE(struct ALeffectslotArray, slot, newcount));
+    newarray->count = newcount;
+    for(i = 0;i < count;i++)
+        newarray->slot[i] = LookupEffectSlot(context, slotids[i]);
+    for(j = 0;i < newcount;)
+        newarray->slot[i++] = curarray->slot[j++];
+    /* Remove any duplicates (first instance of each will be kept). */
+    for(i = 1;i < newcount;i++)
+    {
+        for(j = i;j != 0;)
+        {
+            if(UNLIKELY(newarray->slot[i] == newarray->slot[--j]))
+            {
+                newcount--;
+                for(j = i;j < newcount;j++)
+                    newarray->slot[j] = newarray->slot[j+1];
+                i--;
+                break;
+            }
+        }
     }
-    else
+
+    /* Reallocate newarray if the new size ended up smaller from duplicate
+     * removal.
+     */
+    if(UNLIKELY(newcount < newarray->count))
     {
-        if(effect)
+        struct ALeffectslotArray *tmpnewarray = al_calloc(DEF_ALIGN,
+            FAM_SIZE(struct ALeffectslotArray, slot, newcount));
+        memcpy(tmpnewarray, newarray, FAM_SIZE(struct ALeffectslotArray, slot, newcount));
+        al_free(newarray);
+        newarray = tmpnewarray;
+        newarray->count = newcount;
+    }
+
+    curarray = ATOMIC_EXCHANGE_PTR(&context->ActiveAuxSlots, newarray, almemory_order_acq_rel);
+    while((ATOMIC_LOAD(&device->MixCount, almemory_order_acquire)&1))
+        althrd_yield();
+    al_free(curarray);
+}
+
+static void RemoveActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcontext *context)
+{
+    struct ALeffectslotArray *curarray = ATOMIC_LOAD(&context->ActiveAuxSlots,
+                                                     almemory_order_acquire);
+    struct ALeffectslotArray *newarray = NULL;
+    ALCdevice *device = context->Device;
+    ALsizei i, j;
+
+    /* Don't shrink the allocated array size since we don't know how many (if
+     * any) of the effect slots to remove are in the array.
+     */
+    newarray = al_calloc(DEF_ALIGN, FAM_SIZE(struct ALeffectslotArray, slot, curarray->count));
+    newarray->count = 0;
+    for(i = 0;i < curarray->count;i++)
+    {
+        /* Insert this slot into the new array only if it's not one to remove. */
+        ALeffectslot *slot = curarray->slot[i];
+        for(j = count;j != 0;)
         {
-            ALCdevice_Lock(Device);
-            memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props));
-            ALCdevice_Unlock(Device);
-            ATOMIC_STORE(&EffectSlot->NeedsUpdate, AL_TRUE);
+            if(slot->id == slotids[--j])
+                goto skip_ins;
         }
+        newarray->slot[newarray->count++] = slot;
+    skip_ins: ;
     }
 
-    return AL_NO_ERROR;
+    /* TODO: Could reallocate newarray now that we know it's needed size. */
+
+    curarray = ATOMIC_EXCHANGE_PTR(&context->ActiveAuxSlots, newarray, almemory_order_acq_rel);
+    while((ATOMIC_LOAD(&device->MixCount, almemory_order_acquire)&1))
+        althrd_yield();
+    al_free(curarray);
 }
 
 
 ALenum InitEffectSlot(ALeffectslot *slot)
 {
-    ALeffectStateFactory *factory;
-    ALuint i, c;
+    EffectStateFactory *factory;
 
-    slot->EffectType = AL_EFFECT_NULL;
+    slot->Effect.Type = AL_EFFECT_NULL;
 
     factory = getFactoryByType(AL_EFFECT_NULL);
-    if(!(slot->EffectState=V0(factory,create)()))
-        return AL_OUT_OF_MEMORY;
+    slot->Effect.State = EffectStateFactory_create(factory);
+    if(!slot->Effect.State) return AL_OUT_OF_MEMORY;
 
     slot->Gain = 1.0;
     slot->AuxSendAuto = AL_TRUE;
-    ATOMIC_INIT(&slot->NeedsUpdate, AL_FALSE);
-    for(c = 0;c < 1;c++)
-    {
-        for(i = 0;i < BUFFERSIZE;i++)
-            slot->WetBuffer[c][i] = 0.0f;
-    }
+    ATOMIC_FLAG_TEST_AND_SET(&slot->PropsClean, almemory_order_relaxed);
     InitRef(&slot->ref, 0);
 
+    ATOMIC_INIT(&slot->Update, NULL);
+
+    slot->Params.Gain = 1.0f;
+    slot->Params.AuxSendAuto = AL_TRUE;
+    ALeffectState_IncRef(slot->Effect.State);
+    slot->Params.EffectState = slot->Effect.State;
+    slot->Params.RoomRolloff = 0.0f;
+    slot->Params.DecayTime = 0.0f;
+    slot->Params.DecayLFRatio = 0.0f;
+    slot->Params.DecayHFRatio = 0.0f;
+    slot->Params.DecayHFLimit = AL_FALSE;
+    slot->Params.AirAbsorptionGainHF = 1.0f;
+
     return AL_NO_ERROR;
 }
 
-ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
+void DeinitEffectSlot(ALeffectslot *slot)
+{
+    struct ALeffectslotProps *props;
+
+    props = ATOMIC_LOAD_SEQ(&slot->Update);
+    if(props)
+    {
+        if(props->State) ALeffectState_DecRef(props->State);
+        TRACE("Freed unapplied AuxiliaryEffectSlot update %p\n", props);
+        al_free(props);
+    }
+
+    ALeffectState_DecRef(slot->Effect.State);
+    if(slot->Params.EffectState)
+        ALeffectState_DecRef(slot->Params.EffectState);
+}
+
+void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
+{
+    struct ALeffectslotProps *props;
+    ALeffectState *oldstate;
+
+    /* Get an unused property container, or allocate a new one as needed. */
+    props = ATOMIC_LOAD(&context->FreeEffectslotProps, almemory_order_relaxed);
+    if(!props)
+        props = al_calloc(16, sizeof(*props));
+    else
+    {
+        struct ALeffectslotProps *next;
+        do {
+            next = ATOMIC_LOAD(&props->next, almemory_order_relaxed);
+        } while(ATOMIC_COMPARE_EXCHANGE_PTR_WEAK(&context->FreeEffectslotProps, &props, next,
+                almemory_order_seq_cst, almemory_order_acquire) == 0);
+    }
+
+    /* Copy in current property values. */
+    props->Gain = slot->Gain;
+    props->AuxSendAuto = slot->AuxSendAuto;
+
+    props->Type = slot->Effect.Type;
+    props->Props = slot->Effect.Props;
+    /* Swap out any stale effect state object there may be in the container, to
+     * delete it.
+     */
+    ALeffectState_IncRef(slot->Effect.State);
+    oldstate = props->State;
+    props->State = slot->Effect.State;
+
+    /* Set the new container for updating internal parameters. */
+    props = ATOMIC_EXCHANGE_PTR(&slot->Update, props, almemory_order_acq_rel);
+    if(props)
+    {
+        /* If there was an unused update container, put it back in the
+         * freelist.
+         */
+        if(props->State)
+            ALeffectState_DecRef(props->State);
+        props->State = NULL;
+        ATOMIC_REPLACE_HEAD(struct ALeffectslotProps*, &context->FreeEffectslotProps, props);
+    }
+
+    if(oldstate)
+        ALeffectState_DecRef(oldstate);
+}
+
+void UpdateAllEffectSlotProps(ALCcontext *context)
 {
-    ALsizei pos;
-    for(pos = 0;pos < Context->EffectSlotMap.size;pos++)
+    struct ALeffectslotArray *auxslots;
+    ALsizei i;
+
+    LockEffectSlotList(context);
+    auxslots = ATOMIC_LOAD(&context->ActiveAuxSlots, almemory_order_acquire);
+    for(i = 0;i < auxslots->count;i++)
     {
-        ALeffectslot *temp = Context->EffectSlotMap.array[pos].value;
-        Context->EffectSlotMap.array[pos].value = NULL;
+        ALeffectslot *slot = auxslots->slot[i];
+        if(!ATOMIC_FLAG_TEST_AND_SET(&slot->PropsClean, almemory_order_acq_rel))
+            UpdateEffectSlotProps(slot, context);
+    }
+    UnlockEffectSlotList(context);
+}
+
+ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *context)
+{
+    ALeffectslotPtr *iter = VECTOR_BEGIN(context->EffectSlotList);
+    ALeffectslotPtr *end = VECTOR_END(context->EffectSlotList);
+    size_t leftover = 0;
 
-        DELETE_OBJ(temp->EffectState);
+    for(;iter != end;iter++)
+    {
+        ALeffectslot *slot = *iter;
+        if(!slot) continue;
+        *iter = NULL;
 
-        FreeThunkEntry(temp->id);
-        memset(temp, 0, sizeof(ALeffectslot));
-        al_free(temp);
+        DeinitEffectSlot(slot);
+
+        memset(slot, 0, sizeof(*slot));
+        al_free(slot);
+        ++leftover;
     }
+    if(leftover > 0)
+        WARN("(%p) Deleted "SZFMT" AuxiliaryEffectSlot%s\n", context, leftover, (leftover==1)?"":"s");
 }