OpenAL32/alAuxEffectSlot.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <math.h>
  25
  26 #include <thread>
  27 #include <algorithm>
  28
  29 #include "AL/al.h"
  30 #include "AL/alc.h"
  31
  32 #include "alMain.h"
  33 #include "alcontext.h"
  34 #include "alAuxEffectSlot.h"
  35 #include "alError.h"
  36 #include "alListener.h"
  37 #include "alSource.h"
  38
  39 #include "fpu_modes.h"
  40 #include "almalloc.h"
  41
  42
  43 namespace {
  44
  45 inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id) noexcept
  46 {
  47     --id;
  48     if(UNLIKELY(id >= context->EffectSlotList.size()))
  49         return nullptr;
  50     return context->EffectSlotList[id].get();
  51 }
  52
  53 inline ALeffect *LookupEffect(ALCdevice *device, ALuint id) noexcept
  54 {
  55     ALuint lidx = (id-1) >> 6;
  56     ALsizei slidx = (id-1) & 0x3f;
  57
  58     if(UNLIKELY(lidx >= device->EffectList.size()))
  59         return nullptr;
  60     EffectSubList &sublist = device->EffectList[lidx];
  61     if(UNLIKELY(sublist.FreeMask & (U64(1)<<slidx)))
  62         return nullptr;
  63     return sublist.Effects + slidx;
  64 }
  65
  66
  67 void AddActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcontext *context)
  68 {
  69     if(count < 1) return;
  70     ALeffectslotArray *curarray{context->ActiveAuxSlots.load(std::memory_order_acquire)};
  71     ALsizei newcount{curarray->count + count};
  72
  73     /* Insert the new effect slots into the head of the array, followed by the
  74      * existing ones.
  75      */
  76     auto newarray = static_cast<ALeffectslotArray*>(al_calloc(DEF_ALIGN,
  77         FAM_SIZE(ALeffectslotArray, slot, newcount)));
  78     newarray->count = newcount;
  79     auto slotiter = std::transform(slotids, slotids+count, newarray->slot,
  80         [context](ALuint id) noexcept -> ALeffectslot*
  81         { return LookupEffectSlot(context, id); }
  82     );
  83     std::copy_n(curarray->slot, curarray->count, slotiter);
  84
  85     /* Remove any duplicates (first instance of each will be kept). */
  86     ALeffectslot **last = newarray->slot + newarray->count;
  87     for(ALeffectslot **start=newarray->slot+1;;)
  88     {
  89         last = std::remove(start, last, *(start-1));
  90         if(start == last) break;
  91         ++start;
  92     }
  93     newcount = std::distance(newarray->slot, last);
  94
  95     /* Reallocate newarray if the new size ended up smaller from duplicate
  96      * removal.
  97      */
  98     if(UNLIKELY(newcount < newarray->count))
  99     {
 100         curarray = newarray;
 101         newarray = static_cast<ALeffectslotArray*>(al_calloc(DEF_ALIGN,
 102             FAM_SIZE(ALeffectslotArray, slot, newcount)));
 103         newarray->count = newcount;
 104         std::copy_n(curarray->slot, newcount, newarray->slot);
 105         al_free(curarray);
 106         curarray = nullptr;
 107     }
 108
 109     curarray = context->ActiveAuxSlots.exchange(newarray, std::memory_order_acq_rel);
 110     ALCdevice *device{context->Device};
 111     while((device->MixCount.load(std::memory_order_acquire)&1))
 112         std::this_thread::yield();
 113     al_free(curarray);
 114 }
 115
 116 void RemoveActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcontext *context)
 117 {
 118     if(count < 1) return;
 119     ALeffectslotArray *curarray{context->ActiveAuxSlots.load(std::memory_order_acquire)};
 120
 121     /* Don't shrink the allocated array size since we don't know how many (if
 122      * any) of the effect slots to remove are in the array.
 123      */
 124     auto newarray = static_cast<ALeffectslotArray*>(al_calloc(DEF_ALIGN,
 125         FAM_SIZE(ALeffectslotArray, slot, curarray->count)));
 126
 127     /* Copy each element in curarray to newarray whose ID is not in slotids. */
 128     const ALuint *slotids_end{slotids + count};
 129     auto slotiter = std::copy_if(curarray->slot, curarray->slot+curarray->count, newarray->slot,
 130         [slotids, slotids_end](const ALeffectslot *slot) -> bool
 131         { return std::find(slotids, slotids_end, slot->id) == slotids_end; }
 132     );
 133     newarray->count = std::distance(newarray->slot, slotiter);
 134
 135     /* TODO: Could reallocate newarray now that we know it's needed size. */
 136
 137     curarray = context->ActiveAuxSlots.exchange(newarray, std::memory_order_acq_rel);
 138     ALCdevice *device{context->Device};
 139     while((device->MixCount.load(std::memory_order_acquire)&1))
 140         std::this_thread::yield();
 141     al_free(curarray);
 142 }
 143
 144 constexpr struct FactoryItem {
 145     ALenum Type;
 146     EffectStateFactory* (&GetFactory)(void);
 147 } FactoryList[] = {
 148     { AL_EFFECT_NULL, NullStateFactory_getFactory },
 149     { AL_EFFECT_EAXREVERB, ReverbStateFactory_getFactory },
 150     { AL_EFFECT_REVERB, ReverbStateFactory_getFactory },
 151     { AL_EFFECT_AUTOWAH, AutowahStateFactory_getFactory },
 152     { AL_EFFECT_CHORUS, ChorusStateFactory_getFactory },
 153     { AL_EFFECT_COMPRESSOR, CompressorStateFactory_getFactory },
 154     { AL_EFFECT_DISTORTION, DistortionStateFactory_getFactory },
 155     { AL_EFFECT_ECHO, EchoStateFactory_getFactory },
 156     { AL_EFFECT_EQUALIZER, EqualizerStateFactory_getFactory },
 157     { AL_EFFECT_FLANGER, FlangerStateFactory_getFactory },
 158     { AL_EFFECT_FREQUENCY_SHIFTER, FshifterStateFactory_getFactory },
 159     { AL_EFFECT_RING_MODULATOR, ModulatorStateFactory_getFactory },
 160     { AL_EFFECT_PITCH_SHIFTER, PshifterStateFactory_getFactory},
 161     { AL_EFFECT_DEDICATED_DIALOGUE, DedicatedStateFactory_getFactory },
 162     { AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, DedicatedStateFactory_getFactory }
 163 };
 164
 165 inline EffectStateFactory *getFactoryByType(ALenum type)
 166 {
 167     auto iter = std::find_if(std::begin(FactoryList), std::end(FactoryList),
 168         [type](const FactoryItem &item) noexcept -> bool
 169         { return item.Type == type; }
 170     );
 171     return (iter != std::end(FactoryList)) ? iter->GetFactory() : nullptr;
 172 }
 173
 174
 175 #define DO_UPDATEPROPS() do {                                                 \
 176     if(!context->DeferUpdates.load(std::memory_order_acquire))                \
 177         UpdateEffectSlotProps(slot, context.get());                           \
 178     else                                                                      \
 179         slot->PropsClean.clear(std::memory_order_release);                    \
 180 } while(0)
 181
 182 } // namespace
 183
 184 AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 185 {
 186     ContextRef context{GetContextRef()};
 187     if(UNLIKELY(!context)) return;
 188
 189     if(n < 0)
 190         SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "Generating %d effect slots", n);
 191     if(n == 0) return;
 192
 193     std::unique_lock<std::mutex> slotlock{context->EffectSlotLock};
 194     ALCdevice *device{context->Device};
 195     for(ALsizei cur{0};cur < n;cur++)
 196     {
 197         auto iter = std::find_if(context->EffectSlotList.begin(), context->EffectSlotList.end(),
 198             [](const ALeffectslotPtr &entry) noexcept -> bool
 199             { return !entry; }
 200         );
 201         if(iter == context->EffectSlotList.end())
 202         {
 203             if(UNLIKELY(device->AuxiliaryEffectSlotMax == context->EffectSlotList.size()))
 204             {
 205                 slotlock.unlock();
 206                 alDeleteAuxiliaryEffectSlots(cur, effectslots);
 207                 alSetError(context.get(), AL_OUT_OF_MEMORY,
 208                     "Exceeding %u auxiliary effect slot limit", device->AuxiliaryEffectSlotMax);
 209                 return;
 210             }
 211             context->EffectSlotList.emplace_back(nullptr);
 212             iter = context->EffectSlotList.end() - 1;
 213         }
 214
 215         *iter = std::unique_ptr<ALeffectslot>(new ALeffectslot{});
 216         ALenum err{InitEffectSlot(iter->get())};
 217         if(err != AL_NO_ERROR)
 218         {
 219             *iter = nullptr;
 220             slotlock.unlock();
 221
 222             alDeleteAuxiliaryEffectSlots(cur, effectslots);
 223             alSetError(context.get(), err, "Effect slot object allocation failed");
 224             return;
 225         }
 226         aluInitEffectPanning(iter->get());
 227
 228         ALuint id = std::distance(context->EffectSlotList.begin(), iter) + 1;
 229         (*iter)->id = id;
 230         effectslots[cur] = id;
 231     }
 232     AddActiveEffectSlots(effectslots, n, context.get());
 233 }
 234
 235 AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
 236 {
 237     ContextRef context{GetContextRef()};
 238     if(UNLIKELY(!context)) return;
 239
 240     if(n < 0)
 241         SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "Deleting %d effect slots", n);
 242     if(n == 0) return;
 243
 244     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 245     auto effectslots_end = effectslots + n;
 246     auto bad_slot = std::find_if(effectslots, effectslots_end,
 247         [&context](ALuint id) -> bool
 248         {
 249             ALeffectslot *slot{LookupEffectSlot(context.get(), id)};
 250             if(!slot)
 251             {
 252                 alSetError(context.get(), AL_INVALID_NAME, "Invalid effect slot ID %u", id);
 253                 return true;
 254             }
 255             if(ReadRef(&slot->ref) != 0)
 256             {
 257                 alSetError(context.get(), AL_INVALID_NAME, "Deleting in-use effect slot %u", id);
 258                 return true;
 259             }
 260             return false;
 261         }
 262     );
 263     if(bad_slot != effectslots_end)
 264         return;
 265
 266     // All effectslots are valid, remove and delete them
 267     RemoveActiveEffectSlots(effectslots, n, context.get());
 268     std::for_each(effectslots, effectslots_end,
 269         [&context](ALuint id) noexcept -> void
 270         { context->EffectSlotList[id-1] = nullptr; }
 271     );
 272 }
 273
 274 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 275 {
 276     ContextRef context{GetContextRef()};
 277     if(LIKELY(context))
 278     {
 279         std::lock_guard<std::mutex> _{context->EffectSlotLock};
 280         if(LookupEffectSlot(context.get(), effectslot) != nullptr)
 281             return AL_TRUE;
 282     }
 283     return AL_FALSE;
 284 }
 285
 286 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
 287 {
 288     ContextRef context{GetContextRef()};
 289     if(UNLIKELY(!context)) return;
 290
 291     std::lock_guard<std::mutex> _{context->PropLock};
 292     std::lock_guard<std::mutex> __{context->EffectSlotLock};
 293     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 294     if(UNLIKELY(!slot))
 295         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 296
 297     ALCdevice *device{};
 298     ALenum err{};
 299     switch(param)
 300     {
 301     case AL_EFFECTSLOT_EFFECT:
 302         device = context->Device;
 303
 304         { std::lock_guard<std::mutex> ___{device->EffectLock};
 305             ALeffect *effect{value ? LookupEffect(device, value) : nullptr};
 306             if(!(value == 0 || effect != nullptr))
 307                 SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "Invalid effect ID %u", value);
 308             err = InitializeEffect(context.get(), slot, effect);
 309         }
 310         if(err != AL_NO_ERROR)
 311         {
 312             alSetError(context.get(), err, "Effect initialization failed");
 313             return;
 314         }
 315         break;
 316
 317     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 318         if(!(value == AL_TRUE || value == AL_FALSE))
 319             SETERR_RETURN(context.get(), AL_INVALID_VALUE,,
 320                           "Effect slot auxiliary send auto out of range");
 321         slot->AuxSendAuto = value;
 322         break;
 323
 324     default:
 325         SETERR_RETURN(context.get(), AL_INVALID_ENUM,,
 326                       "Invalid effect slot integer property 0x%04x", param);
 327     }
 328     DO_UPDATEPROPS();
 329 }
 330
 331 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *values)
 332 {
 333     switch(param)
 334     {
 335     case AL_EFFECTSLOT_EFFECT:
 336     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 337         alAuxiliaryEffectSloti(effectslot, param, values[0]);
 338         return;
 339     }
 340
 341     ContextRef context{GetContextRef()};
 342     if(UNLIKELY(!context)) return;
 343
 344     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 345     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 346     if(UNLIKELY(!slot))
 347         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 348
 349     switch(param)
 350     {
 351     default:
 352         SETERR_RETURN(context.get(), AL_INVALID_ENUM,,
 353                       "Invalid effect slot integer-vector property 0x%04x", param);
 354     }
 355 }
 356
 357 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat value)
 358 {
 359     ContextRef context{GetContextRef()};
 360     if(UNLIKELY(!context)) return;
 361
 362     std::lock_guard<std::mutex> _{context->PropLock};
 363     std::lock_guard<std::mutex> __{context->EffectSlotLock};
 364     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 365     if(UNLIKELY(!slot))
 366         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 367
 368     switch(param)
 369     {
 370     case AL_EFFECTSLOT_GAIN:
 371         if(!(value >= 0.0f && value <= 1.0f))
 372             SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "Effect slot gain out of range");
 373         slot->Gain = value;
 374         break;
 375
 376     default:
 377         SETERR_RETURN(context.get(), AL_INVALID_ENUM,, "Invalid effect slot float property 0x%04x",
 378                       param);
 379     }
 380     DO_UPDATEPROPS();
 381 }
 382
 383 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *values)
 384 {
 385     switch(param)
 386     {
 387     case AL_EFFECTSLOT_GAIN:
 388         alAuxiliaryEffectSlotf(effectslot, param, values[0]);
 389         return;
 390     }
 391
 392     ContextRef context{GetContextRef()};
 393     if(UNLIKELY(!context)) return;
 394
 395     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 396     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 397     if(UNLIKELY(!slot))
 398         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 399
 400     switch(param)
 401     {
 402     default:
 403         SETERR_RETURN(context.get(), AL_INVALID_ENUM,,
 404                       "Invalid effect slot float-vector property 0x%04x", param);
 405     }
 406 }
 407
 408 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *value)
 409 {
 410     ContextRef context{GetContextRef()};
 411     if(UNLIKELY(!context)) return;
 412
 413     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 414     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 415     if(UNLIKELY(!slot))
 416         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 417
 418     switch(param)
 419     {
 420     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 421         *value = slot->AuxSendAuto;
 422         break;
 423
 424     default:
 425         SETERR_RETURN(context.get(), AL_INVALID_ENUM,,
 426                       "Invalid effect slot integer property 0x%04x", param);
 427     }
 428 }
 429
 430 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *values)
 431 {
 432     switch(param)
 433     {
 434     case AL_EFFECTSLOT_EFFECT:
 435     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 436         alGetAuxiliaryEffectSloti(effectslot, param, values);
 437         return;
 438     }
 439
 440     ContextRef context{GetContextRef()};
 441     if(UNLIKELY(!context)) return;
 442
 443     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 444     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 445     if(UNLIKELY(!slot))
 446         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 447
 448     switch(param)
 449     {
 450     default:
 451         SETERR_RETURN(context.get(), AL_INVALID_ENUM,,
 452                       "Invalid effect slot integer-vector property 0x%04x", param);
 453     }
 454 }
 455
 456 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value)
 457 {
 458     ContextRef context{GetContextRef()};
 459     if(UNLIKELY(!context)) return;
 460
 461     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 462     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 463     if(UNLIKELY(!slot))
 464         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 465
 466     switch(param)
 467     {
 468     case AL_EFFECTSLOT_GAIN:
 469         *value = slot->Gain;
 470         break;
 471
 472     default:
 473         SETERR_RETURN(context.get(), AL_INVALID_ENUM,,
 474                       "Invalid effect slot float property 0x%04x", param);
 475     }
 476 }
 477
 478 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *values)
 479 {
 480     switch(param)
 481     {
 482     case AL_EFFECTSLOT_GAIN:
 483         alGetAuxiliaryEffectSlotf(effectslot, param, values);
 484         return;
 485     }
 486
 487     ContextRef context{GetContextRef()};
 488     if(UNLIKELY(!context)) return;
 489
 490     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 491     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 492     if(UNLIKELY(!slot))
 493         SETERR_RETURN(context.get(), AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 494
 495     switch(param)
 496     {
 497     default:
 498         SETERR_RETURN(context.get(), AL_INVALID_ENUM,,
 499                       "Invalid effect slot float-vector property 0x%04x", param);
 500     }
 501 }
 502
 503
 504 ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect)
 505 {
 506     ALenum newtype{effect ? effect->type : AL_EFFECT_NULL};
 507     if(newtype != EffectSlot->Effect.Type)
 508     {
 509         EffectStateFactory *factory{getFactoryByType(newtype)};
 510         if(!factory)
 511         {
 512             ERR("Failed to find factory for effect type 0x%04x\n", newtype);
 513             return AL_INVALID_ENUM;
 514         }
 515         EffectState *State{factory->create()};
 516         if(!State) return AL_OUT_OF_MEMORY;
 517
 518         FPUCtl mixer_mode{};
 519         ALCdevice *Device{Context->Device};
 520         std::unique_lock<std::mutex> backlock{Device->BackendLock};
 521         State->mOutBuffer = Device->Dry.Buffer;
 522         State->mOutChannels = Device->Dry.NumChannels;
 523         if(State->deviceUpdate(Device) == AL_FALSE)
 524         {
 525             backlock.unlock();
 526             mixer_mode.leave();
 527             State->DecRef();
 528             return AL_OUT_OF_MEMORY;
 529         }
 530         mixer_mode.leave();
 531
 532         if(!effect)
 533         {
 534             EffectSlot->Effect.Type = AL_EFFECT_NULL;
 535             memset(&EffectSlot->Effect.Props, 0, sizeof(EffectSlot->Effect.Props));
 536         }
 537         else
 538         {
 539             EffectSlot->Effect.Type = effect->type;
 540             EffectSlot->Effect.Props = effect->Props;
 541         }
 542
 543         EffectSlot->Effect.State->DecRef();
 544         EffectSlot->Effect.State = State;
 545     }
 546     else if(effect)
 547         EffectSlot->Effect.Props = effect->Props;
 548
 549     /* Remove state references from old effect slot property updates. */
 550     ALeffectslotProps *props{Context->FreeEffectslotProps.load()};
 551     while(props)
 552     {
 553         if(props->State)
 554             props->State->DecRef();
 555         props->State = nullptr;
 556         props = props->next.load(std::memory_order_relaxed);
 557     }
 558
 559     return AL_NO_ERROR;
 560 }
 561
 562
 563 void EffectState::IncRef() noexcept
 564 {
 565     auto ref = IncrementRef(&mRef);
 566     TRACEREF("%p increasing refcount to %u\n", this, ref);
 567 }
 568
 569 void EffectState::DecRef() noexcept
 570 {
 571     auto ref = DecrementRef(&mRef);
 572     TRACEREF("%p decreasing refcount to %u\n", this, ref);
 573     if(ref == 0) delete this;
 574 }
 575
 576
 577 ALenum InitEffectSlot(ALeffectslot *slot)
 578 {
 579     EffectStateFactory *factory{getFactoryByType(slot->Effect.Type)};
 580     if(!factory) return AL_INVALID_VALUE;
 581     slot->Effect.State = factory->create();
 582     if(!slot->Effect.State) return AL_OUT_OF_MEMORY;
 583
 584     slot->Effect.State->IncRef();
 585     slot->Params.mEffectState = slot->Effect.State;
 586     return AL_NO_ERROR;
 587 }
 588
 589 ALeffectslot::~ALeffectslot()
 590 {
 591     struct ALeffectslotProps *props{Update.load()};
 592     if(props)
 593     {
 594         if(props->State) props->State->DecRef();
 595         TRACE("Freed unapplied AuxiliaryEffectSlot update %p\n", props);
 596         al_free(props);
 597     }
 598
 599     if(Effect.State)
 600         Effect.State->DecRef();
 601     if(Params.mEffectState)
 602         Params.mEffectState->DecRef();
 603 }
 604
 605 void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
 606 {
 607     /* Get an unused property container, or allocate a new one as needed. */
 608     ALeffectslotProps *props{context->FreeEffectslotProps.load(std::memory_order_relaxed)};
 609     if(!props)
 610         props = static_cast<ALeffectslotProps*>(al_calloc(16, sizeof(*props)));
 611     else
 612     {
 613         struct ALeffectslotProps *next;
 614         do {
 615             next = props->next.load(std::memory_order_relaxed);
 616         } while(context->FreeEffectslotProps.compare_exchange_weak(props, next,
 617                 std::memory_order_seq_cst, std::memory_order_acquire) == 0);
 618     }
 619
 620     /* Copy in current property values. */
 621     props->Gain = slot->Gain;
 622     props->AuxSendAuto = slot->AuxSendAuto;
 623
 624     props->Type = slot->Effect.Type;
 625     props->Props = slot->Effect.Props;
 626     /* Swap out any stale effect state object there may be in the container, to
 627      * delete it.
 628      */
 629     EffectState *oldstate{props->State};
 630     slot->Effect.State->IncRef();
 631     props->State = slot->Effect.State;
 632
 633     /* Set the new container for updating internal parameters. */
 634     props = slot->Update.exchange(props, std::memory_order_acq_rel);
 635     if(props)
 636     {
 637         /* If there was an unused update container, put it back in the
 638          * freelist.
 639          */
 640         if(props->State)
 641             props->State->DecRef();
 642         props->State = nullptr;
 643         AtomicReplaceHead(context->FreeEffectslotProps, props);
 644     }
 645
 646     if(oldstate)
 647         oldstate->DecRef();
 648 }
 649
 650 void UpdateAllEffectSlotProps(ALCcontext *context)
 651 {
 652     std::lock_guard<std::mutex> _{context->EffectSlotLock};
 653     ALeffectslotArray *auxslots{context->ActiveAuxSlots.load(std::memory_order_acquire)};
 654     for(ALsizei i{0};i < auxslots->count;i++)
 655     {
 656         ALeffectslot *slot = auxslots->slot[i];
 657         if(!slot->PropsClean.test_and_set(std::memory_order_acq_rel))
 658             UpdateEffectSlotProps(slot, context);
 659     }
 660 }