al/auxeffectslot.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 "auxeffectslot.h"
  24
  25 #include <algorithm>
  26 #include <cstddef>
  27 #include <cstdint>
  28 #include <functional>
  29 #include <iterator>
  30 #include <memory>
  31 #include <mutex>
  32 #include <numeric>
  33 #include <stdexcept>
  34 #include <string>
  35 #include <tuple>
  36 #include <unordered_map>
  37 #include <vector>
  38
  39 #include "AL/al.h"
  40 #include "AL/alc.h"
  41 #include "AL/alext.h"
  42 #include "AL/efx.h"
  43
  44 #include "albit.h"
  45 #include "alc/alu.h"
  46 #include "alc/context.h"
  47 #include "alc/device.h"
  48 #include "alc/effects/base.h"
  49 #include "alc/inprogext.h"
  50 #include "almalloc.h"
  51 #include "alnumeric.h"
  52 #include "alspan.h"
  53 #include "atomic.h"
  54 #include "buffer.h"
  55 #include "core/buffer_storage.h"
  56 #include "core/device.h"
  57 #include "core/fpu_ctrl.h"
  58 #include "core/logging.h"
  59 #include "direct_defs.h"
  60 #include "effect.h"
  61 #include "error.h"
  62 #include "flexarray.h"
  63 #include "opthelpers.h"
  64
  65 #ifdef ALSOFT_EAX
  66 #include "eax/api.h"
  67 #include "eax/call.h"
  68 #include "eax/effect.h"
  69 #include "eax/fx_slot_index.h"
  70 #include "eax/utils.h"
  71 #endif
  72
  73 namespace {
  74
  75 using SubListAllocator = al::allocator<std::array<ALeffectslot,64>>;
  76
  77 EffectStateFactory *getFactoryByType(EffectSlotType type)
  78 {
  79     switch(type)
  80     {
  81     case EffectSlotType::None: return NullStateFactory_getFactory();
  82     case EffectSlotType::EAXReverb: return ReverbStateFactory_getFactory();
  83     case EffectSlotType::Reverb: return StdReverbStateFactory_getFactory();
  84     case EffectSlotType::Autowah: return AutowahStateFactory_getFactory();
  85     case EffectSlotType::Chorus: return ChorusStateFactory_getFactory();
  86     case EffectSlotType::Compressor: return CompressorStateFactory_getFactory();
  87     case EffectSlotType::Distortion: return DistortionStateFactory_getFactory();
  88     case EffectSlotType::Echo: return EchoStateFactory_getFactory();
  89     case EffectSlotType::Equalizer: return EqualizerStateFactory_getFactory();
  90     case EffectSlotType::Flanger: return ChorusStateFactory_getFactory();
  91     case EffectSlotType::FrequencyShifter: return FshifterStateFactory_getFactory();
  92     case EffectSlotType::RingModulator: return ModulatorStateFactory_getFactory();
  93     case EffectSlotType::PitchShifter: return PshifterStateFactory_getFactory();
  94     case EffectSlotType::VocalMorpher: return VmorpherStateFactory_getFactory();
  95     case EffectSlotType::DedicatedDialog: return DedicatedStateFactory_getFactory();
  96     case EffectSlotType::DedicatedLFE: return DedicatedStateFactory_getFactory();
  97     case EffectSlotType::Convolution: return ConvolutionStateFactory_getFactory();
  98     }
  99     return nullptr;
 100 }
 101
 102
 103 auto LookupEffectSlot(ALCcontext *context, ALuint id) noexcept -> ALeffectslot*
 104 {
 105     const size_t lidx{(id-1) >> 6};
 106     const ALuint slidx{(id-1) & 0x3f};
 107
 108     if(lidx >= context->mEffectSlotList.size()) UNLIKELY
 109         return nullptr;
 110     EffectSlotSubList &sublist{context->mEffectSlotList[lidx]};
 111     if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
 112         return nullptr;
 113     return al::to_address(sublist.EffectSlots->begin() + slidx);
 114 }
 115
 116 inline auto LookupEffect(ALCdevice *device, ALuint id) noexcept -> ALeffect*
 117 {
 118     const size_t lidx{(id-1) >> 6};
 119     const ALuint slidx{(id-1) & 0x3f};
 120
 121     if(lidx >= device->EffectList.size()) UNLIKELY
 122         return nullptr;
 123     EffectSubList &sublist = device->EffectList[lidx];
 124     if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
 125         return nullptr;
 126     return al::to_address(sublist.Effects->begin() + slidx);
 127 }
 128
 129 inline auto LookupBuffer(ALCdevice *device, ALuint id) noexcept -> ALbuffer*
 130 {
 131     const size_t lidx{(id-1) >> 6};
 132     const ALuint slidx{(id-1) & 0x3f};
 133
 134     if(lidx >= device->BufferList.size()) UNLIKELY
 135         return nullptr;
 136     BufferSubList &sublist = device->BufferList[lidx];
 137     if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
 138         return nullptr;
 139     return al::to_address(sublist.Buffers->begin() + slidx);
 140 }
 141
 142
 143 void AddActiveEffectSlots(const al::span<ALeffectslot*> auxslots, ALCcontext *context)
 144 {
 145     if(auxslots.empty()) return;
 146     EffectSlotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
 147     if((curarray->size()>>1) > std::numeric_limits<size_t>::max()-auxslots.size())
 148         throw std::runtime_error{"Too many active effect slots"};
 149
 150     size_t newcount{(curarray->size()>>1) + auxslots.size()};
 151     if(newcount > std::numeric_limits<size_t>::max()>>1)
 152         throw std::runtime_error{"Too many active effect slots"};
 153
 154     /* Insert the new effect slots into the head of the new array, followed by
 155      * the existing ones.
 156      */
 157     auto newarray = EffectSlot::CreatePtrArray(newcount<<1);
 158     auto new_end = std::transform(auxslots.begin(), auxslots.end(), newarray->begin(),
 159         std::mem_fn(&ALeffectslot::mSlot));
 160     new_end = std::copy_n(curarray->begin(), curarray->size()>>1, new_end);
 161
 162     /* Remove any duplicates (first instance of each will be kept). */
 163     for(auto start=newarray->begin()+1;;)
 164     {
 165         new_end = std::remove(start, new_end, *(start-1));
 166         if(start == new_end) break;
 167         ++start;
 168     }
 169     newcount = static_cast<size_t>(std::distance(newarray->begin(), new_end));
 170
 171     /* Reallocate newarray if the new size ended up smaller from duplicate
 172      * removal.
 173      */
 174     if(newcount < newarray->size()>>1) UNLIKELY
 175     {
 176         auto oldarray = std::move(newarray);
 177         newarray = EffectSlot::CreatePtrArray(newcount<<1);
 178         new_end = std::copy_n(oldarray->begin(), newcount, newarray->begin());
 179     }
 180     std::fill(new_end, newarray->end(), nullptr);
 181
 182     auto oldarray = context->mActiveAuxSlots.exchange(std::move(newarray),
 183         std::memory_order_acq_rel);
 184     std::ignore = context->mDevice->waitForMix();
 185 }
 186
 187 void RemoveActiveEffectSlots(const al::span<ALeffectslot*> auxslots, ALCcontext *context)
 188 {
 189     if(auxslots.empty()) return;
 190     EffectSlotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
 191
 192     /* Don't shrink the allocated array size since we don't know how many (if
 193      * any) of the effect slots to remove are in the array.
 194      */
 195     auto newarray = EffectSlot::CreatePtrArray(curarray->size());
 196
 197     auto new_end = std::copy_n(curarray->begin(), curarray->size()>>1, newarray->begin());
 198     /* Remove elements from newarray that match any ID in slotids. */
 199     for(const ALeffectslot *auxslot : auxslots)
 200     {
 201         auto slot_match = [auxslot](EffectSlot *slot) noexcept -> bool
 202         { return (slot == auxslot->mSlot); };
 203         new_end = std::remove_if(newarray->begin(), new_end, slot_match);
 204     }
 205
 206     /* Reallocate with the new size. */
 207     auto newsize = static_cast<size_t>(std::distance(newarray->begin(), new_end));
 208     if(newsize < newarray->size()>>1) LIKELY
 209     {
 210         auto oldarray = std::move(newarray);
 211         newarray = EffectSlot::CreatePtrArray(newsize<<1);
 212         new_end = std::copy_n(oldarray->begin(), newsize, newarray->begin());
 213     }
 214     std::fill(new_end, newarray->end(), nullptr);
 215
 216     auto oldarray = context->mActiveAuxSlots.exchange(std::move(newarray),
 217         std::memory_order_acq_rel);
 218     std::ignore = context->mDevice->waitForMix();
 219 }
 220
 221
 222 constexpr auto EffectSlotTypeFromEnum(ALenum type) noexcept -> EffectSlotType
 223 {
 224     switch(type)
 225     {
 226     case AL_EFFECT_NULL: return EffectSlotType::None;
 227     case AL_EFFECT_REVERB: return EffectSlotType::Reverb;
 228     case AL_EFFECT_CHORUS: return EffectSlotType::Chorus;
 229     case AL_EFFECT_DISTORTION: return EffectSlotType::Distortion;
 230     case AL_EFFECT_ECHO: return EffectSlotType::Echo;
 231     case AL_EFFECT_FLANGER: return EffectSlotType::Flanger;
 232     case AL_EFFECT_FREQUENCY_SHIFTER: return EffectSlotType::FrequencyShifter;
 233     case AL_EFFECT_VOCAL_MORPHER: return EffectSlotType::VocalMorpher;
 234     case AL_EFFECT_PITCH_SHIFTER: return EffectSlotType::PitchShifter;
 235     case AL_EFFECT_RING_MODULATOR: return EffectSlotType::RingModulator;
 236     case AL_EFFECT_AUTOWAH: return EffectSlotType::Autowah;
 237     case AL_EFFECT_COMPRESSOR: return EffectSlotType::Compressor;
 238     case AL_EFFECT_EQUALIZER: return EffectSlotType::Equalizer;
 239     case AL_EFFECT_EAXREVERB: return EffectSlotType::EAXReverb;
 240     case AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT: return EffectSlotType::DedicatedLFE;
 241     case AL_EFFECT_DEDICATED_DIALOGUE: return EffectSlotType::DedicatedDialog;
 242     case AL_EFFECT_CONVOLUTION_SOFT: return EffectSlotType::Convolution;
 243     }
 244     ERR("Unhandled effect enum: 0x%04x\n", type);
 245     return EffectSlotType::None;
 246 }
 247
 248 auto EnsureEffectSlots(ALCcontext *context, size_t needed) noexcept -> bool
 249 try {
 250     size_t count{std::accumulate(context->mEffectSlotList.cbegin(),
 251         context->mEffectSlotList.cend(), 0_uz,
 252         [](size_t cur, const EffectSlotSubList &sublist) noexcept -> size_t
 253         { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
 254
 255     while(needed > count)
 256     {
 257         if(context->mEffectSlotList.size() >= 1<<25) UNLIKELY
 258             return false;
 259
 260         EffectSlotSubList sublist{};
 261         sublist.FreeMask = ~0_u64;
 262         sublist.EffectSlots = SubListAllocator{}.allocate(1);
 263         context->mEffectSlotList.emplace_back(std::move(sublist));
 264         count += std::tuple_size_v<SubListAllocator::value_type>;
 265     }
 266     return true;
 267 }
 268 catch(...) {
 269     return false;
 270 }
 271
 272 ALeffectslot *AllocEffectSlot(ALCcontext *context)
 273 {
 274     auto sublist = std::find_if(context->mEffectSlotList.begin(), context->mEffectSlotList.end(),
 275         [](const EffectSlotSubList &entry) noexcept -> bool
 276         { return entry.FreeMask != 0; });
 277     auto lidx = static_cast<ALuint>(std::distance(context->mEffectSlotList.begin(), sublist));
 278     auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
 279     ASSUME(slidx < 64);
 280
 281     ALeffectslot *slot{al::construct_at(al::to_address(sublist->EffectSlots->begin() + slidx),
 282         context)};
 283     aluInitEffectPanning(slot->mSlot, context);
 284
 285     /* Add 1 to avoid ID 0. */
 286     slot->id = ((lidx<<6) | slidx) + 1;
 287
 288     context->mNumEffectSlots += 1;
 289     sublist->FreeMask &= ~(1_u64 << slidx);
 290
 291     return slot;
 292 }
 293
 294 void FreeEffectSlot(ALCcontext *context, ALeffectslot *slot)
 295 {
 296     context->mEffectSlotNames.erase(slot->id);
 297
 298     const ALuint id{slot->id - 1};
 299     const size_t lidx{id >> 6};
 300     const ALuint slidx{id & 0x3f};
 301
 302     std::destroy_at(slot);
 303
 304     context->mEffectSlotList[lidx].FreeMask |= 1_u64 << slidx;
 305     context->mNumEffectSlots--;
 306 }
 307
 308
 309 inline void UpdateProps(ALeffectslot *slot, ALCcontext *context)
 310 {
 311     if(!context->mDeferUpdates && slot->mState == SlotState::Playing)
 312     {
 313         slot->updateProps(context);
 314         return;
 315     }
 316     slot->mPropsDirty = true;
 317 }
 318
 319 } // namespace
 320
 321
 322 AL_API DECL_FUNC2(void, alGenAuxiliaryEffectSlots, ALsizei,n, ALuint*,effectslots)
 323 FORCE_ALIGN void AL_APIENTRY alGenAuxiliaryEffectSlotsDirect(ALCcontext *context, ALsizei n,
 324     ALuint *effectslots) noexcept
 325 try {
 326     if(n < 0)
 327         throw al::context_error{AL_INVALID_VALUE, "Generating %d effect slots", n};
 328     if(n <= 0) UNLIKELY return;
 329
 330     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 331     ALCdevice *device{context->mALDevice.get()};
 332
 333     const al::span eids{effectslots, static_cast<ALuint>(n)};
 334     if(eids.size() > device->AuxiliaryEffectSlotMax-context->mNumEffectSlots)
 335         throw al::context_error{AL_OUT_OF_MEMORY, "Exceeding %u effect slot limit (%u + %d)",
 336             device->AuxiliaryEffectSlotMax, context->mNumEffectSlots, n};
 337
 338     if(!EnsureEffectSlots(context, eids.size()))
 339         throw al::context_error{AL_OUT_OF_MEMORY, "Failed to allocate %d effectslot%s", n,
 340             (n == 1) ? "" : "s"};
 341
 342     std::vector<ALeffectslot*> slots;
 343     try {
 344         if(eids.size() == 1)
 345         {
 346             /* Special handling for the easy and normal case. */
 347             eids[0] = AllocEffectSlot(context)->id;
 348         }
 349         else
 350         {
 351             slots.reserve(eids.size());
 352             std::generate_n(std::back_inserter(slots), eids.size(),
 353                 [context]{ return AllocEffectSlot(context); });
 354
 355             std::transform(slots.cbegin(), slots.cend(), eids.begin(),
 356                 [](ALeffectslot *slot) -> ALuint { return slot->id; });
 357         }
 358     }
 359     catch(std::exception& e) {
 360         ERR("Exception allocating effectslot %zu of %d: %s\n", slots.size()+1, n, e.what());
 361         auto delete_effectslot = [context](ALeffectslot *slot) -> void
 362         { FreeEffectSlot(context, slot); };
 363         std::for_each(slots.begin(), slots.end(), delete_effectslot);
 364         throw al::context_error{AL_INVALID_OPERATION, "Exception allocating %d effectslots: %s", n,
 365             e.what()};
 366     }
 367 }
 368 catch(al::context_error& e) {
 369     context->setError(e.errorCode(), "%s", e.what());
 370 }
 371
 372 AL_API DECL_FUNC2(void, alDeleteAuxiliaryEffectSlots, ALsizei,n, const ALuint*,effectslots)
 373 FORCE_ALIGN void AL_APIENTRY alDeleteAuxiliaryEffectSlotsDirect(ALCcontext *context, ALsizei n,
 374     const ALuint *effectslots) noexcept
 375 try {
 376     if(n < 0) UNLIKELY
 377         throw al::context_error{AL_INVALID_VALUE, "Deleting %d effect slots", n};
 378     if(n <= 0) UNLIKELY return;
 379
 380     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 381     if(n == 1)
 382     {
 383         ALeffectslot *slot{LookupEffectSlot(context, *effectslots)};
 384         if(!slot)
 385             throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", *effectslots};
 386         if(slot->ref.load(std::memory_order_relaxed) != 0)
 387             throw al::context_error{AL_INVALID_OPERATION, "Deleting in-use effect slot %u",
 388                 *effectslots};
 389
 390         RemoveActiveEffectSlots({&slot, 1u}, context);
 391         FreeEffectSlot(context, slot);
 392     }
 393     else
 394     {
 395         const al::span eids{effectslots, static_cast<ALuint>(n)};
 396         std::vector<ALeffectslot*> slots;
 397         slots.reserve(eids.size());
 398
 399         auto lookupslot = [context](const ALuint eid) -> ALeffectslot*
 400         {
 401             ALeffectslot *slot{LookupEffectSlot(context, eid)};
 402             if(!slot)
 403                 throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", eid};
 404             if(slot->ref.load(std::memory_order_relaxed) != 0)
 405                 throw al::context_error{AL_INVALID_OPERATION, "Deleting in-use effect slot %u",
 406                     eid};
 407             return slot;
 408         };
 409         std::transform(eids.cbegin(), eids.cend(), std::back_inserter(slots), lookupslot);
 410
 411         /* All effectslots are valid, remove and delete them */
 412         RemoveActiveEffectSlots(slots, context);
 413
 414         auto delete_effectslot = [context](const ALuint eid) -> void
 415         {
 416             if(ALeffectslot *slot{LookupEffectSlot(context, eid)})
 417                 FreeEffectSlot(context, slot);
 418         };
 419         std::for_each(eids.begin(), eids.end(), delete_effectslot);
 420     }
 421 }
 422 catch(al::context_error& e) {
 423     context->setError(e.errorCode(), "%s", e.what());
 424 }
 425
 426 AL_API DECL_FUNC1(ALboolean, alIsAuxiliaryEffectSlot, ALuint,effectslot)
 427 FORCE_ALIGN ALboolean AL_APIENTRY alIsAuxiliaryEffectSlotDirect(ALCcontext *context,
 428     ALuint effectslot) noexcept
 429 {
 430     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 431     if(LookupEffectSlot(context, effectslot) != nullptr)
 432         return AL_TRUE;
 433     return AL_FALSE;
 434 }
 435
 436
 437 AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlaySOFT(ALuint slotid) noexcept
 438 {
 439     ContextRef context{GetContextRef()};
 440     if(!context) UNLIKELY return;
 441
 442     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 443     ALeffectslot *slot{LookupEffectSlot(context.get(), slotid)};
 444     if(!slot) UNLIKELY
 445     {
 446         context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotid);
 447         return;
 448     }
 449     if(slot->mState == SlotState::Playing)
 450         return;
 451
 452     slot->mPropsDirty = false;
 453     slot->updateProps(context.get());
 454
 455     AddActiveEffectSlots({&slot, 1}, context.get());
 456     slot->mState = SlotState::Playing;
 457 }
 458
 459 AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlayvSOFT(ALsizei n, const ALuint *slotids) noexcept
 460 {
 461     ContextRef context{GetContextRef()};
 462     if(!context) UNLIKELY return;
 463
 464     try {
 465         if(n < 0)
 466             throw al::context_error{AL_INVALID_VALUE, "Playing %d effect slots", n};
 467         if(n <= 0) UNLIKELY return;
 468
 469         auto ids = al::span{slotids, static_cast<ALuint>(n)};
 470         auto slots = std::vector<ALeffectslot*>(ids.size());
 471         std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 472
 473         auto lookupslot = [&context](const ALuint id) -> ALeffectslot*
 474         {
 475             ALeffectslot *slot{LookupEffectSlot(context.get(), id)};
 476             if(!slot)
 477                 throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", id};
 478
 479             if(slot->mState != SlotState::Playing)
 480             {
 481                 slot->mPropsDirty = false;
 482                 slot->updateProps(context.get());
 483             }
 484             return slot;
 485         };
 486         std::transform(ids.cbegin(), ids.cend(), slots.begin(), lookupslot);
 487
 488         AddActiveEffectSlots(slots, context.get());
 489         for(auto slot : slots)
 490             slot->mState = SlotState::Playing;
 491     }
 492     catch(al::context_error& e) {
 493         context->setError(e.errorCode(), "%s", e.what());
 494         return;
 495     }
 496 }
 497
 498 AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopSOFT(ALuint slotid) noexcept
 499 {
 500     ContextRef context{GetContextRef()};
 501     if(!context) UNLIKELY return;
 502
 503     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 504     ALeffectslot *slot{LookupEffectSlot(context.get(), slotid)};
 505     if(!slot) UNLIKELY
 506     {
 507         context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotid);
 508         return;
 509     }
 510
 511     RemoveActiveEffectSlots({&slot, 1}, context.get());
 512     slot->mState = SlotState::Stopped;
 513 }
 514
 515 AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopvSOFT(ALsizei n, const ALuint *slotids) noexcept
 516 {
 517     ContextRef context{GetContextRef()};
 518     if(!context) UNLIKELY return;
 519
 520     try {
 521         if(n < 0)
 522             throw al::context_error{AL_INVALID_VALUE, "Stopping %d effect slots", n};
 523         if(n <= 0) UNLIKELY return;
 524
 525         auto ids = al::span{slotids, static_cast<ALuint>(n)};
 526         auto slots = std::vector<ALeffectslot*>(ids.size());
 527         std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 528
 529         auto lookupslot = [&context](const ALuint id) -> ALeffectslot*
 530         {
 531             if(ALeffectslot *slot{LookupEffectSlot(context.get(), id)})
 532                 return slot;
 533             throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", id};
 534         };
 535         std::transform(ids.cbegin(), ids.cend(), slots.begin(), lookupslot);
 536
 537         RemoveActiveEffectSlots(slots, context.get());
 538         for(auto slot : slots)
 539             slot->mState = SlotState::Stopped;
 540     }
 541     catch(al::context_error& e) {
 542         context->setError(e.errorCode(), "%s", e.what());
 543         return;
 544     }
 545 }
 546
 547
 548 AL_API DECL_FUNC3(void, alAuxiliaryEffectSloti, ALuint,effectslot, ALenum,param, ALint,value)
 549 FORCE_ALIGN void AL_APIENTRY alAuxiliaryEffectSlotiDirect(ALCcontext *context, ALuint effectslot,
 550     ALenum param, ALint value) noexcept
 551 try {
 552     std::lock_guard<std::mutex> proplock{context->mPropLock};
 553     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 554
 555     ALeffectslot *slot{LookupEffectSlot(context, effectslot)};
 556     if(!slot) UNLIKELY
 557         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 558
 559     ALeffectslot *target{};
 560     ALenum err{};
 561     switch(param)
 562     {
 563     case AL_EFFECTSLOT_EFFECT:
 564         {
 565             ALCdevice *device{context->mALDevice.get()};
 566             std::lock_guard<std::mutex> effectlock{device->EffectLock};
 567             ALeffect *effect{value ? LookupEffect(device, static_cast<ALuint>(value)) : nullptr};
 568             if(effect)
 569                 err = slot->initEffect(effect->id, effect->type, effect->Props, context);
 570             else
 571             {
 572                 if(value != 0)
 573                     throw al::context_error{AL_INVALID_VALUE, "Invalid effect ID %u", value};
 574                 err = slot->initEffect(0, AL_EFFECT_NULL, EffectProps{}, context);
 575             }
 576         }
 577         if(err != AL_NO_ERROR)
 578             throw al::context_error{err, "Effect initialization failed"};
 579
 580         if(slot->mState == SlotState::Initial) UNLIKELY
 581         {
 582             slot->mPropsDirty = false;
 583             slot->updateProps(context);
 584
 585             AddActiveEffectSlots({&slot, 1}, context);
 586             slot->mState = SlotState::Playing;
 587             return;
 588         }
 589         UpdateProps(slot, context);
 590         return;
 591
 592     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 593         if(!(value == AL_TRUE || value == AL_FALSE))
 594             throw al::context_error{AL_INVALID_VALUE,
 595                 "Effect slot auxiliary send auto out of range"};
 596         if(!(slot->AuxSendAuto == !!value)) LIKELY
 597         {
 598             slot->AuxSendAuto = !!value;
 599             UpdateProps(slot, context);
 600         }
 601         return;
 602
 603     case AL_EFFECTSLOT_TARGET_SOFT:
 604         target = LookupEffectSlot(context, static_cast<ALuint>(value));
 605         if(value && !target)
 606             throw al::context_error{AL_INVALID_VALUE, "Invalid effect slot target ID"};
 607         if(slot->Target == target) UNLIKELY
 608             return;
 609         if(target)
 610         {
 611             ALeffectslot *checker{target};
 612             while(checker && checker != slot)
 613                 checker = checker->Target;
 614             if(checker)
 615                 throw al::context_error{AL_INVALID_OPERATION,
 616                     "Setting target of effect slot ID %u to %u creates circular chain", slot->id,
 617                     target->id};
 618         }
 619
 620         if(ALeffectslot *oldtarget{slot->Target})
 621         {
 622             /* We must force an update if there was an existing effect slot
 623              * target, in case it's about to be deleted.
 624              */
 625             if(target) IncrementRef(target->ref);
 626             DecrementRef(oldtarget->ref);
 627             slot->Target = target;
 628             slot->updateProps(context);
 629             return;
 630         }
 631
 632         if(target) IncrementRef(target->ref);
 633         slot->Target = target;
 634         UpdateProps(slot, context);
 635         return;
 636
 637     case AL_BUFFER:
 638         if(slot->mState == SlotState::Playing)
 639             throw al::context_error{AL_INVALID_OPERATION,
 640                 "Setting buffer on playing effect slot %u", slot->id};
 641
 642         if(ALbuffer *buffer{slot->Buffer})
 643         {
 644             if(buffer->id == static_cast<ALuint>(value)) UNLIKELY
 645                 return;
 646         }
 647         else if(value == 0) UNLIKELY
 648             return;
 649
 650         {
 651             ALCdevice *device{context->mALDevice.get()};
 652             std::lock_guard<std::mutex> bufferlock{device->BufferLock};
 653             ALbuffer *buffer{};
 654             if(value)
 655             {
 656                 buffer = LookupBuffer(device, static_cast<ALuint>(value));
 657                 if(!buffer)
 658                     throw al::context_error{AL_INVALID_VALUE, "Invalid buffer ID %u", value};
 659                 if(buffer->mCallback)
 660                     throw al::context_error{AL_INVALID_OPERATION,
 661                         "Callback buffer not valid for effects"};
 662
 663                 IncrementRef(buffer->ref);
 664             }
 665
 666             if(ALbuffer *oldbuffer{slot->Buffer})
 667                 DecrementRef(oldbuffer->ref);
 668             slot->Buffer = buffer;
 669
 670             FPUCtl mixer_mode{};
 671             auto *state = slot->Effect.State.get();
 672             state->deviceUpdate(device, buffer);
 673         }
 674         UpdateProps(slot, context);
 675         return;
 676
 677     case AL_EFFECTSLOT_STATE_SOFT:
 678         throw al::context_error{AL_INVALID_OPERATION, "AL_EFFECTSLOT_STATE_SOFT is read-only"};
 679     }
 680
 681     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot integer property 0x%04x", param};
 682 }
 683 catch(al::context_error& e) {
 684     context->setError(e.errorCode(), "%s", e.what());
 685 }
 686
 687 AL_API DECL_FUNC3(void, alAuxiliaryEffectSlotiv, ALuint,effectslot, ALenum,param, const ALint*,values)
 688 FORCE_ALIGN void AL_APIENTRY alAuxiliaryEffectSlotivDirect(ALCcontext *context, ALuint effectslot,
 689     ALenum param, const ALint *values) noexcept
 690 try {
 691     switch(param)
 692     {
 693     case AL_EFFECTSLOT_EFFECT:
 694     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 695     case AL_EFFECTSLOT_TARGET_SOFT:
 696     case AL_EFFECTSLOT_STATE_SOFT:
 697     case AL_BUFFER:
 698         alAuxiliaryEffectSlotiDirect(context, effectslot, param, *values);
 699         return;
 700     }
 701
 702     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 703     ALeffectslot *slot{LookupEffectSlot(context, effectslot)};
 704     if(!slot)
 705         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 706
 707     switch(param)
 708     {
 709     }
 710     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot integer-vector property 0x%04x",
 711         param};
 712 }
 713 catch(al::context_error& e) {
 714     context->setError(e.errorCode(), "%s", e.what());
 715 }
 716
 717 AL_API DECL_FUNC3(void, alAuxiliaryEffectSlotf, ALuint,effectslot, ALenum,param, ALfloat,value)
 718 FORCE_ALIGN void AL_APIENTRY alAuxiliaryEffectSlotfDirect(ALCcontext *context, ALuint effectslot,
 719     ALenum param, ALfloat value) noexcept
 720 try {
 721     std::lock_guard<std::mutex> proplock{context->mPropLock};
 722     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 723
 724     ALeffectslot *slot{LookupEffectSlot(context, effectslot)};
 725     if(!slot)
 726         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 727
 728     switch(param)
 729     {
 730     case AL_EFFECTSLOT_GAIN:
 731         if(!(value >= 0.0f && value <= 1.0f))
 732             throw al::context_error{AL_INVALID_VALUE, "Effect slot gain out of range"};
 733         if(!(slot->Gain == value)) LIKELY
 734         {
 735             slot->Gain = value;
 736             UpdateProps(slot, context);
 737         }
 738         return;
 739     }
 740
 741     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot float property 0x%04x", param};
 742 }
 743 catch(al::context_error& e) {
 744     context->setError(e.errorCode(), "%s", e.what());
 745 }
 746
 747 AL_API DECL_FUNC3(void, alAuxiliaryEffectSlotfv, ALuint,effectslot, ALenum,param, const ALfloat*,values)
 748 FORCE_ALIGN void AL_APIENTRY alAuxiliaryEffectSlotfvDirect(ALCcontext *context, ALuint effectslot,
 749     ALenum param, const ALfloat *values) noexcept
 750 try {
 751     switch(param)
 752     {
 753     case AL_EFFECTSLOT_GAIN:
 754         alAuxiliaryEffectSlotfDirect(context, effectslot, param, *values);
 755         return;
 756     }
 757
 758     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 759     ALeffectslot *slot{LookupEffectSlot(context, effectslot)};
 760     if(!slot)
 761         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 762
 763     switch(param)
 764     {
 765     }
 766     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot float-vector property 0x%04x",
 767         param};
 768 }
 769 catch(al::context_error& e) {
 770     context->setError(e.errorCode(), "%s", e.what());
 771 }
 772
 773
 774 AL_API DECL_FUNC3(void, alGetAuxiliaryEffectSloti, ALuint,effectslot, ALenum,param, ALint*,value)
 775 FORCE_ALIGN void AL_APIENTRY alGetAuxiliaryEffectSlotiDirect(ALCcontext *context,
 776     ALuint effectslot, ALenum param, ALint *value) noexcept
 777 try {
 778     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 779     ALeffectslot *slot{LookupEffectSlot(context, effectslot)};
 780     if(!slot)
 781         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 782
 783     switch(param)
 784     {
 785     case AL_EFFECTSLOT_EFFECT:
 786         *value = static_cast<ALint>(slot->EffectId);
 787         return;
 788
 789     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 790         *value = slot->AuxSendAuto ? AL_TRUE : AL_FALSE;
 791         return;
 792
 793     case AL_EFFECTSLOT_TARGET_SOFT:
 794         if(auto *target = slot->Target)
 795             *value = static_cast<ALint>(target->id);
 796         else
 797             *value = 0;
 798         return;
 799
 800     case AL_EFFECTSLOT_STATE_SOFT:
 801         *value = static_cast<int>(slot->mState);
 802         return;
 803
 804     case AL_BUFFER:
 805         if(auto *buffer = slot->Buffer)
 806             *value = static_cast<ALint>(buffer->id);
 807         else
 808             *value = 0;
 809         return;
 810     }
 811
 812     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot integer property 0x%04x", param};
 813 }
 814 catch(al::context_error& e) {
 815     context->setError(e.errorCode(), "%s", e.what());
 816 }
 817
 818 AL_API DECL_FUNC3(void, alGetAuxiliaryEffectSlotiv, ALuint,effectslot, ALenum,param, ALint*,values)
 819 FORCE_ALIGN void AL_APIENTRY alGetAuxiliaryEffectSlotivDirect(ALCcontext *context,
 820     ALuint effectslot, ALenum param, ALint *values) noexcept
 821 try {
 822     switch(param)
 823     {
 824     case AL_EFFECTSLOT_EFFECT:
 825     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 826     case AL_EFFECTSLOT_TARGET_SOFT:
 827     case AL_EFFECTSLOT_STATE_SOFT:
 828     case AL_BUFFER:
 829         alGetAuxiliaryEffectSlotiDirect(context, effectslot, param, values);
 830         return;
 831     }
 832
 833     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 834     ALeffectslot *slot = LookupEffectSlot(context, effectslot);
 835     if(!slot)
 836         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 837
 838     switch(param)
 839     {
 840     }
 841     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot integer-vector property 0x%04x",
 842             param};
 843 }
 844 catch(al::context_error& e) {
 845     context->setError(e.errorCode(), "%s", e.what());
 846 }
 847
 848 AL_API DECL_FUNC3(void, alGetAuxiliaryEffectSlotf, ALuint,effectslot, ALenum,param, ALfloat*,value)
 849 FORCE_ALIGN void AL_APIENTRY alGetAuxiliaryEffectSlotfDirect(ALCcontext *context,
 850     ALuint effectslot, ALenum param, ALfloat *value) noexcept
 851 try {
 852     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 853     ALeffectslot *slot{LookupEffectSlot(context, effectslot)};
 854     if(!slot)
 855         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 856
 857     switch(param)
 858     {
 859     case AL_EFFECTSLOT_GAIN:
 860         *value = slot->Gain;
 861         return;
 862     }
 863
 864     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot float property 0x%04x", param};
 865 }
 866 catch(al::context_error& e) {
 867     context->setError(e.errorCode(), "%s", e.what());
 868 }
 869
 870 AL_API DECL_FUNC3(void, alGetAuxiliaryEffectSlotfv, ALuint,effectslot, ALenum,param, ALfloat*,values)
 871 FORCE_ALIGN void AL_APIENTRY alGetAuxiliaryEffectSlotfvDirect(ALCcontext *context,
 872     ALuint effectslot, ALenum param, ALfloat *values) noexcept
 873 try {
 874     switch(param)
 875     {
 876     case AL_EFFECTSLOT_GAIN:
 877         alGetAuxiliaryEffectSlotfDirect(context, effectslot, param, values);
 878         return;
 879     }
 880
 881     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
 882     ALeffectslot *slot{LookupEffectSlot(context, effectslot)};
 883     if(!slot)
 884         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot};
 885
 886     switch(param)
 887     {
 888     }
 889     throw al::context_error{AL_INVALID_ENUM, "Invalid effect slot float-vector property 0x%04x",
 890         param};
 891 }
 892 catch(al::context_error& e) {
 893     context->setError(e.errorCode(), "%s", e.what());
 894 }
 895
 896
 897 ALeffectslot::ALeffectslot(ALCcontext *context)
 898 {
 899     EffectStateFactory *factory{getFactoryByType(EffectSlotType::None)};
 900     if(!factory) throw std::runtime_error{"Failed to get null effect factory"};
 901
 902     al::intrusive_ptr<EffectState> state{factory->create()};
 903     Effect.State = state;
 904
 905     mSlot = context->getEffectSlot();
 906     mSlot->InUse = true;
 907     mSlot->mEffectState = std::move(state);
 908 }
 909
 910 ALeffectslot::~ALeffectslot()
 911 {
 912     if(Target)
 913         DecrementRef(Target->ref);
 914     Target = nullptr;
 915     if(Buffer)
 916         DecrementRef(Buffer->ref);
 917     Buffer = nullptr;
 918
 919     if(auto *slot = mSlot->Update.exchange(nullptr, std::memory_order_relaxed))
 920         slot->State = nullptr;
 921
 922     mSlot->mEffectState = nullptr;
 923     mSlot->InUse = false;
 924 }
 925
 926 ALenum ALeffectslot::initEffect(ALuint effectId, ALenum effectType, const EffectProps &effectProps,
 927     ALCcontext *context)
 928 {
 929     EffectSlotType newtype{EffectSlotTypeFromEnum(effectType)};
 930     if(newtype != Effect.Type)
 931     {
 932         EffectStateFactory *factory{getFactoryByType(newtype)};
 933         if(!factory)
 934         {
 935             ERR("Failed to find factory for effect slot type %d\n", static_cast<int>(newtype));
 936             return AL_INVALID_ENUM;
 937         }
 938         al::intrusive_ptr<EffectState> state{factory->create()};
 939
 940         ALCdevice *device{context->mALDevice.get()};
 941         std::unique_lock<std::mutex> statelock{device->StateLock};
 942         state->mOutTarget = device->Dry.Buffer;
 943         {
 944             FPUCtl mixer_mode{};
 945             state->deviceUpdate(device, Buffer);
 946         }
 947
 948         Effect.Type = newtype;
 949         Effect.Props = effectProps;
 950
 951         Effect.State = std::move(state);
 952     }
 953     else if(newtype != EffectSlotType::None)
 954         Effect.Props = effectProps;
 955     EffectId = effectId;
 956
 957     /* Remove state references from old effect slot property updates. */
 958     EffectSlotProps *props{context->mFreeEffectSlotProps.load()};
 959     while(props)
 960     {
 961         props->State = nullptr;
 962         props = props->next.load(std::memory_order_relaxed);
 963     }
 964
 965     return AL_NO_ERROR;
 966 }
 967
 968 void ALeffectslot::updateProps(ALCcontext *context) const
 969 {
 970     /* Get an unused property container, or allocate a new one as needed. */
 971     EffectSlotProps *props{context->mFreeEffectSlotProps.load(std::memory_order_acquire)};
 972     if(!props)
 973     {
 974         context->allocEffectSlotProps();
 975         props = context->mFreeEffectSlotProps.load(std::memory_order_acquire);
 976     }
 977     EffectSlotProps *next;
 978     do {
 979         next = props->next.load(std::memory_order_relaxed);
 980     } while(!context->mFreeEffectSlotProps.compare_exchange_weak(props, next,
 981         std::memory_order_acq_rel, std::memory_order_acquire));
 982
 983     /* Copy in current property values. */
 984     props->Gain = Gain;
 985     props->AuxSendAuto = AuxSendAuto;
 986     props->Target = Target ? Target->mSlot : nullptr;
 987
 988     props->Type = Effect.Type;
 989     props->Props = Effect.Props;
 990     props->State = Effect.State;
 991
 992     /* Set the new container for updating internal parameters. */
 993     props = mSlot->Update.exchange(props, std::memory_order_acq_rel);
 994     if(props)
 995     {
 996         /* If there was an unused update container, put it back in the
 997          * freelist.
 998          */
 999         props->State = nullptr;
1000         AtomicReplaceHead(context->mFreeEffectSlotProps, props);
1001     }
1002 }
1003
1004 void ALeffectslot::SetName(ALCcontext* context, ALuint id, std::string_view name)
1005 {
1006     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
1007
1008     auto slot = LookupEffectSlot(context, id);
1009     if(!slot)
1010         throw al::context_error{AL_INVALID_NAME, "Invalid effect slot ID %u", id};
1011
1012     context->mEffectSlotNames.insert_or_assign(id, name);
1013 }
1014
1015 void UpdateAllEffectSlotProps(ALCcontext *context)
1016 {
1017     std::lock_guard<std::mutex> slotlock{context->mEffectSlotLock};
1018     for(auto &sublist : context->mEffectSlotList)
1019     {
1020         uint64_t usemask{~sublist.FreeMask};
1021         while(usemask)
1022         {
1023             const auto idx = static_cast<uint>(al::countr_zero(usemask));
1024             usemask &= ~(1_u64 << idx);
1025             auto &slot = (*sublist.EffectSlots)[idx];
1026
1027             if(slot.mState != SlotState::Stopped && std::exchange(slot.mPropsDirty, false))
1028                 slot.updateProps(context);
1029         }
1030     }
1031 }
1032
1033 EffectSlotSubList::~EffectSlotSubList()
1034 {
1035     if(!EffectSlots)
1036         return;
1037
1038     uint64_t usemask{~FreeMask};
1039     while(usemask)
1040     {
1041         const int idx{al::countr_zero(usemask)};
1042         std::destroy_at(al::to_address(EffectSlots->begin() + idx));
1043         usemask &= ~(1_u64 << idx);
1044     }
1045     FreeMask = ~usemask;
1046     SubListAllocator{}.deallocate(EffectSlots, 1);
1047     EffectSlots = nullptr;
1048 }
1049
1050 #ifdef ALSOFT_EAX
1051 void ALeffectslot::eax_initialize(ALCcontext& al_context, EaxFxSlotIndexValue index)
1052 {
1053     if(index >= EAX_MAX_FXSLOTS)
1054         eax_fail("Index out of range.");
1055
1056     eax_al_context_ = &al_context;
1057     eax_fx_slot_index_ = index;
1058     eax_fx_slot_set_defaults();
1059
1060     eax_effect_ = std::make_unique<EaxEffect>();
1061     if(index == 0) eax_effect_->init<EaxReverbCommitter>();
1062     else if(index == 1) eax_effect_->init<EaxChorusCommitter>();
1063     else eax_effect_->init<EaxNullCommitter>();
1064 }
1065
1066 void ALeffectslot::eax_commit()
1067 {
1068     if(eax_df_ != EaxDirtyFlags{})
1069     {
1070         auto df = EaxDirtyFlags{};
1071         switch(eax_version_)
1072         {
1073         case 1:
1074         case 2:
1075         case 3:
1076             eax5_fx_slot_commit(eax123_, df);
1077             break;
1078         case 4:
1079             eax4_fx_slot_commit(df);
1080             break;
1081         case 5:
1082             eax5_fx_slot_commit(eax5_, df);
1083             break;
1084         }
1085         eax_df_ = EaxDirtyFlags{};
1086
1087         if((df & eax_volume_dirty_bit) != EaxDirtyFlags{})
1088             eax_fx_slot_set_volume();
1089         if((df & eax_flags_dirty_bit) != EaxDirtyFlags{})
1090             eax_fx_slot_set_flags();
1091     }
1092
1093     if(eax_effect_->commit(eax_version_))
1094         eax_set_efx_slot_effect(*eax_effect_);
1095 }
1096
1097 [[noreturn]] void ALeffectslot::eax_fail(const char* message)
1098 {
1099     throw Exception{message};
1100 }
1101
1102 [[noreturn]] void ALeffectslot::eax_fail_unknown_effect_id()
1103 {
1104     eax_fail("Unknown effect ID.");
1105 }
1106
1107 [[noreturn]] void ALeffectslot::eax_fail_unknown_property_id()
1108 {
1109     eax_fail("Unknown property ID.");
1110 }
1111
1112 [[noreturn]] void ALeffectslot::eax_fail_unknown_version()
1113 {
1114     eax_fail("Unknown version.");
1115 }
1116
1117 void ALeffectslot::eax4_fx_slot_ensure_unlocked() const
1118 {
1119     if(eax4_fx_slot_is_legacy())
1120         eax_fail("Locked legacy slot.");
1121 }
1122
1123 ALenum ALeffectslot::eax_get_efx_effect_type(const GUID& guid)
1124 {
1125     if(guid == EAX_NULL_GUID)
1126         return AL_EFFECT_NULL;
1127     if(guid == EAX_AUTOWAH_EFFECT)
1128         return AL_EFFECT_AUTOWAH;
1129     if(guid == EAX_CHORUS_EFFECT)
1130         return AL_EFFECT_CHORUS;
1131     if(guid == EAX_AGCCOMPRESSOR_EFFECT)
1132         return AL_EFFECT_COMPRESSOR;
1133     if(guid == EAX_DISTORTION_EFFECT)
1134         return AL_EFFECT_DISTORTION;
1135     if(guid == EAX_REVERB_EFFECT)
1136         return AL_EFFECT_EAXREVERB;
1137     if(guid == EAX_ECHO_EFFECT)
1138         return AL_EFFECT_ECHO;
1139     if(guid == EAX_EQUALIZER_EFFECT)
1140         return AL_EFFECT_EQUALIZER;
1141     if(guid == EAX_FLANGER_EFFECT)
1142         return AL_EFFECT_FLANGER;
1143     if(guid == EAX_FREQUENCYSHIFTER_EFFECT)
1144         return AL_EFFECT_FREQUENCY_SHIFTER;
1145     if(guid == EAX_PITCHSHIFTER_EFFECT)
1146         return AL_EFFECT_PITCH_SHIFTER;
1147     if(guid == EAX_RINGMODULATOR_EFFECT)
1148         return AL_EFFECT_RING_MODULATOR;
1149     if(guid == EAX_VOCALMORPHER_EFFECT)
1150         return AL_EFFECT_VOCAL_MORPHER;
1151
1152     eax_fail_unknown_effect_id();
1153 }
1154
1155 const GUID& ALeffectslot::eax_get_eax_default_effect_guid() const noexcept
1156 {
1157     switch(eax_fx_slot_index_)
1158     {
1159     case 0: return EAX_REVERB_EFFECT;
1160     case 1: return EAX_CHORUS_EFFECT;
1161     default: return EAX_NULL_GUID;
1162     }
1163 }
1164
1165 long ALeffectslot::eax_get_eax_default_lock() const noexcept
1166 {
1167     return eax4_fx_slot_is_legacy() ? EAXFXSLOT_LOCKED : EAXFXSLOT_UNLOCKED;
1168 }
1169
1170 void ALeffectslot::eax4_fx_slot_set_defaults(Eax4Props& props) noexcept
1171 {
1172     props.guidLoadEffect = eax_get_eax_default_effect_guid();
1173     props.lVolume = EAXFXSLOT_DEFAULTVOLUME;
1174     props.lLock = eax_get_eax_default_lock();
1175     props.ulFlags = EAX40FXSLOT_DEFAULTFLAGS;
1176 }
1177
1178 void ALeffectslot::eax5_fx_slot_set_defaults(Eax5Props& props) noexcept
1179 {
1180     props.guidLoadEffect = eax_get_eax_default_effect_guid();
1181     props.lVolume = EAXFXSLOT_DEFAULTVOLUME;
1182     props.lLock = EAXFXSLOT_UNLOCKED;
1183     props.ulFlags = EAX50FXSLOT_DEFAULTFLAGS;
1184     props.lOcclusion = EAXFXSLOT_DEFAULTOCCLUSION;
1185     props.flOcclusionLFRatio = EAXFXSLOT_DEFAULTOCCLUSIONLFRATIO;
1186 }
1187
1188 void ALeffectslot::eax_fx_slot_set_defaults()
1189 {
1190     eax5_fx_slot_set_defaults(eax123_.i);
1191     eax4_fx_slot_set_defaults(eax4_.i);
1192     eax5_fx_slot_set_defaults(eax5_.i);
1193     eax_ = eax5_.i;
1194     eax_df_ = EaxDirtyFlags{};
1195 }
1196
1197 void ALeffectslot::eax4_fx_slot_get(const EaxCall& call, const Eax4Props& props)
1198 {
1199     switch(call.get_property_id())
1200     {
1201     case EAXFXSLOT_ALLPARAMETERS:
1202         call.set_value<Exception>(props);
1203         break;
1204     case EAXFXSLOT_LOADEFFECT:
1205         call.set_value<Exception>(props.guidLoadEffect);
1206         break;
1207     case EAXFXSLOT_VOLUME:
1208         call.set_value<Exception>(props.lVolume);
1209         break;
1210     case EAXFXSLOT_LOCK:
1211         call.set_value<Exception>(props.lLock);
1212         break;
1213     case EAXFXSLOT_FLAGS:
1214         call.set_value<Exception>(props.ulFlags);
1215         break;
1216     default:
1217         eax_fail_unknown_property_id();
1218     }
1219 }
1220
1221 void ALeffectslot::eax5_fx_slot_get(const EaxCall& call, const Eax5Props& props)
1222 {
1223     switch(call.get_property_id())
1224     {
1225     case EAXFXSLOT_ALLPARAMETERS:
1226         call.set_value<Exception>(props);
1227         break;
1228     case EAXFXSLOT_LOADEFFECT:
1229         call.set_value<Exception>(props.guidLoadEffect);
1230         break;
1231     case EAXFXSLOT_VOLUME:
1232         call.set_value<Exception>(props.lVolume);
1233         break;
1234     case EAXFXSLOT_LOCK:
1235         call.set_value<Exception>(props.lLock);
1236         break;
1237     case EAXFXSLOT_FLAGS:
1238         call.set_value<Exception>(props.ulFlags);
1239         break;
1240     case EAXFXSLOT_OCCLUSION:
1241         call.set_value<Exception>(props.lOcclusion);
1242         break;
1243     case EAXFXSLOT_OCCLUSIONLFRATIO:
1244         call.set_value<Exception>(props.flOcclusionLFRatio);
1245         break;
1246     default:
1247         eax_fail_unknown_property_id();
1248     }
1249 }
1250
1251 void ALeffectslot::eax_fx_slot_get(const EaxCall& call) const
1252 {
1253     switch(call.get_version())
1254     {
1255     case 4: eax4_fx_slot_get(call, eax4_.i); break;
1256     case 5: eax5_fx_slot_get(call, eax5_.i); break;
1257     default: eax_fail_unknown_version();
1258     }
1259 }
1260
1261 bool ALeffectslot::eax_get(const EaxCall& call)
1262 {
1263     switch(call.get_property_set_id())
1264     {
1265     case EaxCallPropertySetId::fx_slot:
1266         eax_fx_slot_get(call);
1267         break;
1268     case EaxCallPropertySetId::fx_slot_effect:
1269         eax_effect_->get(call);
1270         break;
1271     default:
1272         eax_fail_unknown_property_id();
1273     }
1274
1275     return false;
1276 }
1277
1278 void ALeffectslot::eax_fx_slot_load_effect(int version, ALenum altype)
1279 {
1280     if(!IsValidEffectType(altype))
1281         altype = AL_EFFECT_NULL;
1282     eax_effect_->set_defaults(version, altype);
1283 }
1284
1285 void ALeffectslot::eax_fx_slot_set_volume()
1286 {
1287     const auto volume = std::clamp(eax_.lVolume, EAXFXSLOT_MINVOLUME, EAXFXSLOT_MAXVOLUME);
1288     const auto gain = level_mb_to_gain(static_cast<float>(volume));
1289     eax_set_efx_slot_gain(gain);
1290 }
1291
1292 void ALeffectslot::eax_fx_slot_set_environment_flag()
1293 {
1294     eax_set_efx_slot_send_auto((eax_.ulFlags & EAXFXSLOTFLAGS_ENVIRONMENT) != 0u);
1295 }
1296
1297 void ALeffectslot::eax_fx_slot_set_flags()
1298 {
1299     eax_fx_slot_set_environment_flag();
1300 }
1301
1302 void ALeffectslot::eax4_fx_slot_set_all(const EaxCall& call)
1303 {
1304     eax4_fx_slot_ensure_unlocked();
1305     const auto& src = call.get_value<Exception, const EAX40FXSLOTPROPERTIES>();
1306     Eax4AllValidator{}(src);
1307     auto& dst = eax4_.i;
1308     eax_df_ |= eax_load_effect_dirty_bit; // Always reset the effect.
1309     eax_df_ |= (dst.lVolume != src.lVolume ? eax_volume_dirty_bit : EaxDirtyFlags{});
1310     eax_df_ |= (dst.lLock != src.lLock ? eax_lock_dirty_bit : EaxDirtyFlags{});
1311     eax_df_ |= (dst.ulFlags != src.ulFlags ? eax_flags_dirty_bit : EaxDirtyFlags{});
1312     dst = src;
1313 }
1314
1315 void ALeffectslot::eax5_fx_slot_set_all(const EaxCall& call)
1316 {
1317     const auto& src = call.get_value<Exception, const EAX50FXSLOTPROPERTIES>();
1318     Eax5AllValidator{}(src);
1319     auto& dst = eax5_.i;
1320     eax_df_ |= eax_load_effect_dirty_bit; // Always reset the effect.
1321     eax_df_ |= (dst.lVolume != src.lVolume ? eax_volume_dirty_bit : EaxDirtyFlags{});
1322     eax_df_ |= (dst.lLock != src.lLock ? eax_lock_dirty_bit : EaxDirtyFlags{});
1323     eax_df_ |= (dst.ulFlags != src.ulFlags ? eax_flags_dirty_bit : EaxDirtyFlags{});
1324     eax_df_ |= (dst.lOcclusion != src.lOcclusion ? eax_flags_dirty_bit : EaxDirtyFlags{});
1325     eax_df_ |= (dst.flOcclusionLFRatio != src.flOcclusionLFRatio ? eax_flags_dirty_bit : EaxDirtyFlags{});
1326     dst = src;
1327 }
1328
1329 bool ALeffectslot::eax_fx_slot_should_update_sources() const noexcept
1330 {
1331     static constexpr auto dirty_bits =
1332         eax_occlusion_dirty_bit |
1333         eax_occlusion_lf_ratio_dirty_bit |
1334         eax_flags_dirty_bit;
1335
1336     return (eax_df_ & dirty_bits) != EaxDirtyFlags{};
1337 }
1338
1339 // Returns `true` if all sources should be updated, or `false` otherwise.
1340 bool ALeffectslot::eax4_fx_slot_set(const EaxCall& call)
1341 {
1342     auto& dst = eax4_.i;
1343
1344     switch(call.get_property_id())
1345     {
1346     case EAXFXSLOT_NONE:
1347         break;
1348     case EAXFXSLOT_ALLPARAMETERS:
1349         eax4_fx_slot_set_all(call);
1350         if((eax_df_ & eax_load_effect_dirty_bit))
1351             eax_fx_slot_load_effect(4, eax_get_efx_effect_type(dst.guidLoadEffect));
1352         break;
1353     case EAXFXSLOT_LOADEFFECT:
1354         eax4_fx_slot_ensure_unlocked();
1355         eax_fx_slot_set_dirty<Eax4GuidLoadEffectValidator, eax_load_effect_dirty_bit>(call, dst.guidLoadEffect, eax_df_);
1356         if((eax_df_ & eax_load_effect_dirty_bit))
1357             eax_fx_slot_load_effect(4, eax_get_efx_effect_type(dst.guidLoadEffect));
1358         break;
1359     case EAXFXSLOT_VOLUME:
1360         eax_fx_slot_set<Eax4VolumeValidator, eax_volume_dirty_bit>(call, dst.lVolume, eax_df_);
1361         break;
1362     case EAXFXSLOT_LOCK:
1363         eax4_fx_slot_ensure_unlocked();
1364         eax_fx_slot_set<Eax4LockValidator, eax_lock_dirty_bit>(call, dst.lLock, eax_df_);
1365         break;
1366     case EAXFXSLOT_FLAGS:
1367         eax_fx_slot_set<Eax4FlagsValidator, eax_flags_dirty_bit>(call, dst.ulFlags, eax_df_);
1368         break;
1369     default:
1370         eax_fail_unknown_property_id();
1371     }
1372
1373     return eax_fx_slot_should_update_sources();
1374 }
1375
1376 // Returns `true` if all sources should be updated, or `false` otherwise.
1377 bool ALeffectslot::eax5_fx_slot_set(const EaxCall& call)
1378 {
1379     auto& dst = eax5_.i;
1380
1381     switch(call.get_property_id())
1382     {
1383     case EAXFXSLOT_NONE:
1384         break;
1385     case EAXFXSLOT_ALLPARAMETERS:
1386         eax5_fx_slot_set_all(call);
1387         if((eax_df_ & eax_load_effect_dirty_bit))
1388             eax_fx_slot_load_effect(5, eax_get_efx_effect_type(dst.guidLoadEffect));
1389         break;
1390     case EAXFXSLOT_LOADEFFECT:
1391         eax_fx_slot_set_dirty<Eax4GuidLoadEffectValidator, eax_load_effect_dirty_bit>(call, dst.guidLoadEffect, eax_df_);
1392         if((eax_df_ & eax_load_effect_dirty_bit))
1393             eax_fx_slot_load_effect(5, eax_get_efx_effect_type(dst.guidLoadEffect));
1394         break;
1395     case EAXFXSLOT_VOLUME:
1396         eax_fx_slot_set<Eax4VolumeValidator, eax_volume_dirty_bit>(call, dst.lVolume, eax_df_);
1397         break;
1398     case EAXFXSLOT_LOCK:
1399         eax_fx_slot_set<Eax4LockValidator, eax_lock_dirty_bit>(call, dst.lLock, eax_df_);
1400         break;
1401     case EAXFXSLOT_FLAGS:
1402         eax_fx_slot_set<Eax5FlagsValidator, eax_flags_dirty_bit>(call, dst.ulFlags, eax_df_);
1403         break;
1404     case EAXFXSLOT_OCCLUSION:
1405         eax_fx_slot_set<Eax5OcclusionValidator, eax_occlusion_dirty_bit>(call, dst.lOcclusion, eax_df_);
1406         break;
1407     case EAXFXSLOT_OCCLUSIONLFRATIO:
1408         eax_fx_slot_set<Eax5OcclusionLfRatioValidator, eax_occlusion_lf_ratio_dirty_bit>(call, dst.flOcclusionLFRatio, eax_df_);
1409         break;
1410     default:
1411         eax_fail_unknown_property_id();
1412     }
1413
1414     return eax_fx_slot_should_update_sources();
1415 }
1416
1417 // Returns `true` if all sources should be updated, or `false` otherwise.
1418 bool ALeffectslot::eax_fx_slot_set(const EaxCall& call)
1419 {
1420     switch (call.get_version())
1421     {
1422     case 4: return eax4_fx_slot_set(call);
1423     case 5: return eax5_fx_slot_set(call);
1424     default: eax_fail_unknown_version();
1425     }
1426 }
1427
1428 // Returns `true` if all sources should be updated, or `false` otherwise.
1429 bool ALeffectslot::eax_set(const EaxCall& call)
1430 {
1431     bool ret{false};
1432
1433     switch(call.get_property_set_id())
1434     {
1435     case EaxCallPropertySetId::fx_slot: ret = eax_fx_slot_set(call); break;
1436     case EaxCallPropertySetId::fx_slot_effect: eax_effect_->set(call); break;
1437     default: eax_fail_unknown_property_id();
1438     }
1439
1440     const auto version = call.get_version();
1441     if(eax_version_ != version)
1442         eax_df_ = ~EaxDirtyFlags{};
1443     eax_version_ = version;
1444
1445     return ret;
1446 }
1447
1448 void ALeffectslot::eax4_fx_slot_commit(EaxDirtyFlags& dst_df)
1449 {
1450     eax_fx_slot_commit_property<eax_load_effect_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::guidLoadEffect);
1451     eax_fx_slot_commit_property<eax_volume_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::lVolume);
1452     eax_fx_slot_commit_property<eax_lock_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::lLock);
1453     eax_fx_slot_commit_property<eax_flags_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::ulFlags);
1454
1455     auto& dst_i = eax_;
1456
1457     if(dst_i.lOcclusion != EAXFXSLOT_DEFAULTOCCLUSION) {
1458         dst_df |= eax_occlusion_dirty_bit;
1459         dst_i.lOcclusion = EAXFXSLOT_DEFAULTOCCLUSION;
1460     }
1461
1462     if(dst_i.flOcclusionLFRatio != EAXFXSLOT_DEFAULTOCCLUSIONLFRATIO) {
1463         dst_df |= eax_occlusion_lf_ratio_dirty_bit;
1464         dst_i.flOcclusionLFRatio = EAXFXSLOT_DEFAULTOCCLUSIONLFRATIO;
1465     }
1466 }
1467
1468 void ALeffectslot::eax5_fx_slot_commit(Eax5State& state, EaxDirtyFlags& dst_df)
1469 {
1470     eax_fx_slot_commit_property<eax_load_effect_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::guidLoadEffect);
1471     eax_fx_slot_commit_property<eax_volume_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::lVolume);
1472     eax_fx_slot_commit_property<eax_lock_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::lLock);
1473     eax_fx_slot_commit_property<eax_flags_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::ulFlags);
1474     eax_fx_slot_commit_property<eax_occlusion_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::lOcclusion);
1475     eax_fx_slot_commit_property<eax_occlusion_lf_ratio_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::flOcclusionLFRatio);
1476 }
1477
1478 void ALeffectslot::eax_set_efx_slot_effect(EaxEffect &effect)
1479 {
1480 #define EAX_PREFIX "[EAX_SET_EFFECT_SLOT_EFFECT] "
1481
1482     const auto error = initEffect(0, effect.al_effect_type_, effect.al_effect_props_,
1483         eax_al_context_);
1484
1485     if(error != AL_NO_ERROR) {
1486         ERR(EAX_PREFIX "%s\n", "Failed to initialize an effect.");
1487         return;
1488     }
1489
1490     if(mState == SlotState::Initial) {
1491         mPropsDirty = false;
1492         updateProps(eax_al_context_);
1493         auto effect_slot_ptr = this;
1494         AddActiveEffectSlots({&effect_slot_ptr, 1}, eax_al_context_);
1495         mState = SlotState::Playing;
1496         return;
1497     }
1498
1499     mPropsDirty = true;
1500
1501 #undef EAX_PREFIX
1502 }
1503
1504 void ALeffectslot::eax_set_efx_slot_send_auto(bool is_send_auto)
1505 {
1506     if(AuxSendAuto == is_send_auto)
1507         return;
1508
1509     AuxSendAuto = is_send_auto;
1510     mPropsDirty = true;
1511 }
1512
1513 void ALeffectslot::eax_set_efx_slot_gain(ALfloat gain)
1514 {
1515 #define EAX_PREFIX "[EAX_SET_EFFECT_SLOT_GAIN] "
1516
1517     if(gain == Gain)
1518         return;
1519     if(gain < 0.0f || gain > 1.0f)
1520         ERR(EAX_PREFIX "Gain out of range (%f)\n", gain);
1521
1522     Gain = std::clamp(gain, 0.0f, 1.0f);
1523     mPropsDirty = true;
1524
1525 #undef EAX_PREFIX
1526 }
1527
1528 void ALeffectslot::EaxDeleter::operator()(ALeffectslot* effect_slot)
1529 {
1530     eax_delete_al_effect_slot(*effect_slot->eax_al_context_, *effect_slot);
1531 }
1532
1533 EaxAlEffectSlotUPtr eax_create_al_effect_slot(ALCcontext& context)
1534 {
1535 #define EAX_PREFIX "[EAX_MAKE_EFFECT_SLOT] "
1536
1537     std::lock_guard<std::mutex> slotlock{context.mEffectSlotLock};
1538     auto& device = *context.mALDevice;
1539
1540     if(context.mNumEffectSlots == device.AuxiliaryEffectSlotMax) {
1541         ERR(EAX_PREFIX "%s\n", "Out of memory.");
1542         return nullptr;
1543     }
1544
1545     if(!EnsureEffectSlots(&context, 1)) {
1546         ERR(EAX_PREFIX "%s\n", "Failed to ensure.");
1547         return nullptr;
1548     }
1549
1550     return EaxAlEffectSlotUPtr{AllocEffectSlot(&context)};
1551
1552 #undef EAX_PREFIX
1553 }
1554
1555 void eax_delete_al_effect_slot(ALCcontext& context, ALeffectslot& effect_slot)
1556 {
1557 #define EAX_PREFIX "[EAX_DELETE_EFFECT_SLOT] "
1558
1559     std::lock_guard<std::mutex> slotlock{context.mEffectSlotLock};
1560
1561     if(effect_slot.ref.load(std::memory_order_relaxed) != 0)
1562     {
1563         ERR(EAX_PREFIX "Deleting in-use effect slot %u.\n", effect_slot.id);
1564         return;
1565     }
1566
1567     auto effect_slot_ptr = &effect_slot;
1568     RemoveActiveEffectSlots({&effect_slot_ptr, 1}, &context);
1569     FreeEffectSlot(&context, &effect_slot);
1570
1571 #undef EAX_PREFIX
1572 }
1573 #endif // ALSOFT_EAX