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 <cstdint>
  27 #include <iterator>
  28 #include <memory>
  29 #include <mutex>
  30 #include <numeric>
  31 #include <thread>
  32
  33 #include "AL/al.h"
  34 #include "AL/alc.h"
  35 #include "AL/efx.h"
  36
  37 #include "alcmain.h"
  38 #include "alcontext.h"
  39 #include "alexcpt.h"
  40 #include "almalloc.h"
  41 #include "alnumeric.h"
  42 #include "alspan.h"
  43 #include "alu.h"
  44 #include "buffer.h"
  45 #include "effect.h"
  46 #include "fpu_ctrl.h"
  47 #include "inprogext.h"
  48 #include "logging.h"
  49 #include "opthelpers.h"
  50
  51
  52 namespace {
  53
  54 inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id) noexcept
  55 {
  56     const size_t lidx{(id-1) >> 6};
  57     const ALuint slidx{(id-1) & 0x3f};
  58
  59     if UNLIKELY(lidx >= context->mEffectSlotList.size())
  60         return nullptr;
  61     EffectSlotSubList &sublist{context->mEffectSlotList[lidx]};
  62     if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
  63         return nullptr;
  64     return sublist.EffectSlots + slidx;
  65 }
  66
  67 inline ALeffect *LookupEffect(ALCdevice *device, ALuint id) noexcept
  68 {
  69     const size_t lidx{(id-1) >> 6};
  70     const ALuint slidx{(id-1) & 0x3f};
  71
  72     if UNLIKELY(lidx >= device->EffectList.size())
  73         return nullptr;
  74     EffectSubList &sublist = device->EffectList[lidx];
  75     if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
  76         return nullptr;
  77     return sublist.Effects + slidx;
  78 }
  79
  80 inline ALbuffer *LookupBuffer(ALCdevice *device, ALuint id) noexcept
  81 {
  82     const size_t lidx{(id-1) >> 6};
  83     const ALuint slidx{(id-1) & 0x3f};
  84
  85     if UNLIKELY(lidx >= device->BufferList.size())
  86         return nullptr;
  87     BufferSubList &sublist = device->BufferList[lidx];
  88     if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
  89         return nullptr;
  90     return sublist.Buffers + slidx;
  91 }
  92
  93
  94 void AddActiveEffectSlots(const ALuint *slotids, size_t count, ALCcontext *context)
  95 {
  96     if(count < 1) return;
  97     ALeffectslotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
  98     size_t newcount{curarray->size() + count};
  99
 100     /* Insert the new effect slots into the head of the array, followed by the
 101      * existing ones.
 102      */
 103     ALeffectslotArray *newarray = ALeffectslot::CreatePtrArray(newcount);
 104     auto slotiter = std::transform(slotids, slotids+count, newarray->begin(),
 105         [context](ALuint id) noexcept -> ALeffectslot*
 106         { return LookupEffectSlot(context, id); }
 107     );
 108     std::copy(curarray->begin(), curarray->end(), slotiter);
 109
 110     /* Remove any duplicates (first instance of each will be kept). */
 111     auto last = newarray->end();
 112     for(auto start=newarray->begin()+1;;)
 113     {
 114         last = std::remove(start, last, *(start-1));
 115         if(start == last) break;
 116         ++start;
 117     }
 118     newcount = static_cast<size_t>(std::distance(newarray->begin(), last));
 119
 120     /* Reallocate newarray if the new size ended up smaller from duplicate
 121      * removal.
 122      */
 123     if UNLIKELY(newcount < newarray->size())
 124     {
 125         curarray = newarray;
 126         newarray = ALeffectslot::CreatePtrArray(newcount);
 127         std::copy_n(curarray->begin(), newcount, newarray->begin());
 128         delete curarray;
 129         curarray = nullptr;
 130     }
 131     std::uninitialized_fill_n(newarray->end(), newcount, nullptr);
 132
 133     curarray = context->mActiveAuxSlots.exchange(newarray, std::memory_order_acq_rel);
 134     context->mDevice->waitForMix();
 135
 136     al::destroy_n(curarray->end(), curarray->size());
 137     delete curarray;
 138 }
 139
 140 void RemoveActiveEffectSlots(const ALuint *slotids, size_t count, ALCcontext *context)
 141 {
 142     if(count < 1) return;
 143     ALeffectslotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
 144
 145     /* Don't shrink the allocated array size since we don't know how many (if
 146      * any) of the effect slots to remove are in the array.
 147      */
 148     ALeffectslotArray *newarray = ALeffectslot::CreatePtrArray(curarray->size());
 149
 150     /* Copy each element in curarray to newarray whose ID is not in slotids. */
 151     const ALuint *slotids_end{slotids + count};
 152     auto slotiter = std::copy_if(curarray->begin(), curarray->end(), newarray->begin(),
 153         [slotids, slotids_end](const ALeffectslot *slot) -> bool
 154         { return std::find(slotids, slotids_end, slot->id) == slotids_end; }
 155     );
 156
 157     /* Reallocate with the new size. */
 158     auto newsize = static_cast<size_t>(std::distance(newarray->begin(), slotiter));
 159     if LIKELY(newsize != newarray->size())
 160     {
 161         curarray = newarray;
 162         newarray = ALeffectslot::CreatePtrArray(newsize);
 163         std::copy_n(curarray->begin(), newsize, newarray->begin());
 164
 165         delete curarray;
 166         curarray = nullptr;
 167     }
 168     std::uninitialized_fill_n(newarray->end(), newsize, nullptr);
 169
 170     curarray = context->mActiveAuxSlots.exchange(newarray, std::memory_order_acq_rel);
 171     context->mDevice->waitForMix();
 172
 173     al::destroy_n(curarray->end(), curarray->size());
 174     delete curarray;
 175 }
 176
 177
 178 bool EnsureEffectSlots(ALCcontext *context, size_t needed)
 179 {
 180     size_t count{std::accumulate(context->mEffectSlotList.cbegin(),
 181         context->mEffectSlotList.cend(), size_t{0},
 182         [](size_t cur, const EffectSlotSubList &sublist) noexcept -> size_t
 183         { return cur + static_cast<ALuint>(POPCNT64(sublist.FreeMask)); }
 184     )};
 185
 186     while(needed > count)
 187     {
 188         if UNLIKELY(context->mEffectSlotList.size() >= 1<<25)
 189             return false;
 190
 191         context->mEffectSlotList.emplace_back();
 192         auto sublist = context->mEffectSlotList.end() - 1;
 193         sublist->FreeMask = ~0_u64;
 194         sublist->EffectSlots = static_cast<ALeffectslot*>(
 195             al_calloc(alignof(ALeffectslot), sizeof(ALeffectslot)*64));
 196         if UNLIKELY(!sublist->EffectSlots)
 197         {
 198             context->mEffectSlotList.pop_back();
 199             return false;
 200         }
 201         count += 64;
 202     }
 203     return true;
 204 }
 205
 206 ALeffectslot *AllocEffectSlot(ALCcontext *context)
 207 {
 208     auto sublist = std::find_if(context->mEffectSlotList.begin(), context->mEffectSlotList.end(),
 209         [](const EffectSlotSubList &entry) noexcept -> bool
 210         { return entry.FreeMask != 0; }
 211     );
 212     auto lidx = static_cast<ALuint>(std::distance(context->mEffectSlotList.begin(), sublist));
 213     auto slidx = static_cast<ALuint>(CTZ64(sublist->FreeMask));
 214
 215     ALeffectslot *slot{::new (sublist->EffectSlots + slidx) ALeffectslot{}};
 216     if(ALenum err{slot->init()})
 217     {
 218         al::destroy_at(slot);
 219         context->setError(err, "Effect slot object initialization failed");
 220         return nullptr;
 221     }
 222     aluInitEffectPanning(slot, context->mDevice.get());
 223
 224     /* Add 1 to avoid source ID 0. */
 225     slot->id = ((lidx<<6) | slidx) + 1;
 226
 227     context->mNumEffectSlots += 1;
 228     sublist->FreeMask &= ~(1_u64 << slidx);
 229
 230     return slot;
 231 }
 232
 233 void FreeEffectSlot(ALCcontext *context, ALeffectslot *slot)
 234 {
 235     const ALuint id{slot->id - 1};
 236     const size_t lidx{id >> 6};
 237     const ALuint slidx{id & 0x3f};
 238
 239     al::destroy_at(slot);
 240
 241     context->mEffectSlotList[lidx].FreeMask |= 1_u64 << slidx;
 242     context->mNumEffectSlots--;
 243 }
 244
 245
 246 #define DO_UPDATEPROPS() do {                                                 \
 247     if(!context->mDeferUpdates.load(std::memory_order_acquire)                \
 248         && slot->mState == SlotState::Playing)                                \
 249         slot->updateProps(context.get());                                     \
 250     else                                                                      \
 251         slot->PropsClean.clear(std::memory_order_release);                    \
 252 } while(0)
 253
 254 } // namespace
 255
 256 ALeffectslotArray *ALeffectslot::CreatePtrArray(size_t count) noexcept
 257 {
 258     /* Allocate space for twice as many pointers, so the mixer has scratch
 259      * space to store a sorted list during mixing.
 260      */
 261     void *ptr{al_calloc(alignof(ALeffectslotArray), ALeffectslotArray::Sizeof(count*2))};
 262     return new (ptr) ALeffectslotArray{count};
 263 }
 264
 265
 266 AL_API void AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 267 START_API_FUNC
 268 {
 269     ContextRef context{GetContextRef()};
 270     if UNLIKELY(!context) return;
 271
 272     if UNLIKELY(n < 0)
 273         context->setError(AL_INVALID_VALUE, "Generating %d effect slots", n);
 274     if UNLIKELY(n <= 0) return;
 275
 276     std::unique_lock<std::mutex> slotlock{context->mEffectSlotLock};
 277     ALCdevice *device{context->mDevice.get()};
 278     if(static_cast<ALuint>(n) > device->AuxiliaryEffectSlotMax-context->mNumEffectSlots)
 279     {
 280         context->setError(AL_OUT_OF_MEMORY, "Exceeding %u effect slot limit (%u + %d)",
 281             device->AuxiliaryEffectSlotMax, context->mNumEffectSlots, n);
 282         return;
 283     }
 284     if(!EnsureEffectSlots(context.get(), static_cast<ALuint>(n)))
 285     {
 286         context->setError(AL_OUT_OF_MEMORY, "Failed to allocate %d effectslot%s", n,
 287             (n==1) ? "" : "s");
 288         return;
 289     }
 290
 291     if(n == 1)
 292     {
 293         ALeffectslot *slot{AllocEffectSlot(context.get())};
 294         if(!slot) return;
 295         effectslots[0] = slot->id;
 296     }
 297     else
 298     {
 299         al::vector<ALuint> ids;
 300         ALsizei count{n};
 301         ids.reserve(static_cast<ALuint>(count));
 302         do {
 303             ALeffectslot *slot{AllocEffectSlot(context.get())};
 304             if(!slot)
 305             {
 306                 slotlock.unlock();
 307                 alDeleteAuxiliaryEffectSlots(static_cast<ALsizei>(ids.size()), ids.data());
 308                 return;
 309             }
 310             ids.emplace_back(slot->id);
 311         } while(--count);
 312         std::copy(ids.cbegin(), ids.cend(), effectslots);
 313     }
 314 }
 315 END_API_FUNC
 316
 317 AL_API void AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
 318 START_API_FUNC
 319 {
 320     ContextRef context{GetContextRef()};
 321     if UNLIKELY(!context) return;
 322
 323     if UNLIKELY(n < 0)
 324         context->setError(AL_INVALID_VALUE, "Deleting %d effect slots", n);
 325     if UNLIKELY(n <= 0) return;
 326
 327     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 328     auto validate_slot = [&context](const ALuint id) -> bool
 329     {
 330         ALeffectslot *slot{LookupEffectSlot(context.get(), id)};
 331         if UNLIKELY(!slot)
 332         {
 333             context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", id);
 334             return false;
 335         }
 336         if UNLIKELY(ReadRef(slot->ref) != 0)
 337         {
 338             context->setError(AL_INVALID_OPERATION, "Deleting in-use effect slot %u", id);
 339             return false;
 340         }
 341         return true;
 342     };
 343     auto effectslots_end = effectslots + n;
 344     auto bad_slot = std::find_if_not(effectslots, effectslots_end, validate_slot);
 345     if UNLIKELY(bad_slot != effectslots_end) return;
 346
 347     // All effectslots are valid, remove and delete them
 348     RemoveActiveEffectSlots(effectslots, static_cast<ALuint>(n), context.get());
 349     auto delete_slot = [&context](const ALuint sid) -> void
 350     {
 351         ALeffectslot *slot{LookupEffectSlot(context.get(), sid)};
 352         if(slot) FreeEffectSlot(context.get(), slot);
 353     };
 354     std::for_each(effectslots, effectslots_end, delete_slot);
 355 }
 356 END_API_FUNC
 357
 358 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 359 START_API_FUNC
 360 {
 361     ContextRef context{GetContextRef()};
 362     if LIKELY(context)
 363     {
 364         std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 365         if(LookupEffectSlot(context.get(), effectslot) != nullptr)
 366             return AL_TRUE;
 367     }
 368     return AL_FALSE;
 369 }
 370 END_API_FUNC
 371
 372
 373 AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlaySOFT(ALuint slotid)
 374 START_API_FUNC
 375 {
 376     ContextRef context{GetContextRef()};
 377     if UNLIKELY(!context) return;
 378
 379     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 380     ALeffectslot *slot{LookupEffectSlot(context.get(), slotid)};
 381     if UNLIKELY(!slot)
 382     {
 383         context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotid);
 384         return;
 385     }
 386     if(slot->mState == SlotState::Playing)
 387         return;
 388
 389     slot->PropsClean.test_and_set(std::memory_order_acq_rel);
 390     slot->updateProps(context.get());
 391
 392     AddActiveEffectSlots(&slotid, 1, context.get());
 393     slot->mState = SlotState::Playing;
 394 }
 395 END_API_FUNC
 396
 397 AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlayvSOFT(ALsizei n, const ALuint *slotids)
 398 START_API_FUNC
 399 {
 400     ContextRef context{GetContextRef()};
 401     if UNLIKELY(!context) return;
 402
 403     if UNLIKELY(n < 0)
 404         context->setError(AL_INVALID_VALUE, "Playing %d effect slots", n);
 405     if UNLIKELY(n <= 0) return;
 406
 407     auto slots = al::vector<ALeffectslot*>(static_cast<ALuint>(n));
 408     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 409     for(size_t i{0};i < slots.size();++i)
 410     {
 411         ALeffectslot *slot{LookupEffectSlot(context.get(), slotids[i])};
 412         if UNLIKELY(!slot)
 413         {
 414             context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotids[i]);
 415             return;
 416         }
 417
 418         if(slot->mState != SlotState::Playing)
 419         {
 420             slot->PropsClean.test_and_set(std::memory_order_acq_rel);
 421             slot->updateProps(context.get());
 422         }
 423         slots[i] = slot;
 424     };
 425
 426     AddActiveEffectSlots(slotids, static_cast<ALuint>(n), context.get());
 427     for(auto slot : slots)
 428         slot->mState = SlotState::Playing;
 429 }
 430 END_API_FUNC
 431
 432 AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopSOFT(ALuint slotid)
 433 START_API_FUNC
 434 {
 435     ContextRef context{GetContextRef()};
 436     if UNLIKELY(!context) return;
 437
 438     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 439     ALeffectslot *slot{LookupEffectSlot(context.get(), slotid)};
 440     if UNLIKELY(!slot)
 441     {
 442         context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotid);
 443         return;
 444     }
 445
 446     RemoveActiveEffectSlots(&slotid, 1, context.get());
 447     slot->mState = SlotState::Stopped;
 448 }
 449 END_API_FUNC
 450
 451 AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopvSOFT(ALsizei n, const ALuint *slotids)
 452 START_API_FUNC
 453 {
 454     ContextRef context{GetContextRef()};
 455     if UNLIKELY(!context) return;
 456
 457     if UNLIKELY(n < 0)
 458         context->setError(AL_INVALID_VALUE, "Stopping %d effect slots", n);
 459     if UNLIKELY(n <= 0) return;
 460
 461     auto slots = al::vector<ALeffectslot*>(static_cast<ALuint>(n));
 462     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 463     for(size_t i{0};i < slots.size();++i)
 464     {
 465         ALeffectslot *slot{LookupEffectSlot(context.get(), slotids[i])};
 466         if UNLIKELY(!slot)
 467         {
 468             context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotids[i]);
 469             return;
 470         }
 471
 472         slots[i] = slot;
 473     };
 474
 475     RemoveActiveEffectSlots(slotids, static_cast<ALuint>(n), context.get());
 476     for(auto slot : slots)
 477         slot->mState = SlotState::Stopped;
 478 }
 479 END_API_FUNC
 480
 481
 482 AL_API void AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
 483 START_API_FUNC
 484 {
 485     ContextRef context{GetContextRef()};
 486     if UNLIKELY(!context) return;
 487
 488     std::lock_guard<std::mutex> _{context->mPropLock};
 489     std::lock_guard<std::mutex> __{context->mEffectSlotLock};
 490     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 491     if UNLIKELY(!slot)
 492         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 493
 494     ALeffectslot *target{};
 495     ALCdevice *device{};
 496     ALenum err{};
 497     switch(param)
 498     {
 499     case AL_EFFECTSLOT_EFFECT:
 500         device = context->mDevice.get();
 501
 502         {
 503             std::lock_guard<std::mutex> ___{device->EffectLock};
 504             ALeffect *effect{value ? LookupEffect(device, static_cast<ALuint>(value)) : nullptr};
 505             if(!(value == 0 || effect != nullptr))
 506                 SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid effect ID %u", value);
 507             err = slot->initEffect(effect, context.get());
 508         }
 509         if UNLIKELY(err != AL_NO_ERROR)
 510         {
 511             context->setError(err, "Effect initialization failed");
 512             return;
 513         }
 514         if UNLIKELY(slot->mState == SlotState::Initial)
 515         {
 516             AddActiveEffectSlots(&slot->id, 1, context.get());
 517             slot->mState = SlotState::Playing;
 518         }
 519         break;
 520
 521     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 522         if(!(value == AL_TRUE || value == AL_FALSE))
 523             SETERR_RETURN(context, AL_INVALID_VALUE,,
 524                 "Effect slot auxiliary send auto out of range");
 525         slot->AuxSendAuto = !!value;
 526         break;
 527
 528     case AL_EFFECTSLOT_TARGET_SOFT:
 529         target = LookupEffectSlot(context.get(), static_cast<ALuint>(value));
 530         if(value && !target)
 531             SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid effect slot target ID");
 532         if(target)
 533         {
 534             ALeffectslot *checker{target};
 535             while(checker && checker != slot)
 536                 checker = checker->Target;
 537             if(checker)
 538                 SETERR_RETURN(context, AL_INVALID_OPERATION,,
 539                     "Setting target of effect slot ID %u to %u creates circular chain", slot->id,
 540                     target->id);
 541         }
 542
 543         if(ALeffectslot *oldtarget{slot->Target})
 544         {
 545             /* We must force an update if there was an existing effect slot
 546              * target, in case it's about to be deleted.
 547              */
 548             if(target) IncrementRef(target->ref);
 549             DecrementRef(oldtarget->ref);
 550             slot->Target = target;
 551             slot->updateProps(context.get());
 552             return;
 553         }
 554
 555         if(target) IncrementRef(target->ref);
 556         slot->Target = target;
 557         break;
 558
 559     case AL_BUFFER:
 560         device = context->mDevice.get();
 561
 562         if(slot->mState == SlotState::Playing)
 563             SETERR_RETURN(context, AL_INVALID_OPERATION,,
 564                 "Setting buffer on playing effect slot %u", slot->id);
 565
 566         {
 567             std::lock_guard<std::mutex> ___{device->BufferLock};
 568             ALbuffer *buffer{};
 569             if(value)
 570             {
 571                 buffer = LookupBuffer(device, static_cast<ALuint>(value));
 572                 if(!buffer) SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid buffer ID");
 573                 if(buffer->mBuffer.mCallback)
 574                     SETERR_RETURN(context, AL_INVALID_OPERATION,,
 575                         "Callback buffer not valid for effects");
 576
 577                 IncrementRef(buffer->ref);
 578             }
 579
 580             if(ALbuffer *oldbuffer{slot->Buffer})
 581                 DecrementRef(oldbuffer->ref);
 582             slot->Buffer = buffer;
 583
 584             FPUCtl mixer_mode{};
 585             auto *state = slot->Effect.State.get();
 586             state->setBuffer(device, buffer ? &buffer->mBuffer : nullptr);
 587         }
 588         break;
 589
 590     case AL_EFFECTSLOT_STATE_SOFT:
 591         SETERR_RETURN(context, AL_INVALID_OPERATION,, "AL_EFFECTSLOT_STATE_SOFT is read-only");
 592
 593     default:
 594         SETERR_RETURN(context, AL_INVALID_ENUM,, "Invalid effect slot integer property 0x%04x",
 595             param);
 596     }
 597     DO_UPDATEPROPS();
 598 }
 599 END_API_FUNC
 600
 601 AL_API void AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *values)
 602 START_API_FUNC
 603 {
 604     switch(param)
 605     {
 606     case AL_EFFECTSLOT_EFFECT:
 607     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 608     case AL_EFFECTSLOT_TARGET_SOFT:
 609     case AL_EFFECTSLOT_STATE_SOFT:
 610     case AL_BUFFER:
 611         alAuxiliaryEffectSloti(effectslot, param, values[0]);
 612         return;
 613     }
 614
 615     ContextRef context{GetContextRef()};
 616     if UNLIKELY(!context) return;
 617
 618     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 619     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 620     if UNLIKELY(!slot)
 621         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 622
 623     switch(param)
 624     {
 625     default:
 626         SETERR_RETURN(context, AL_INVALID_ENUM,,
 627             "Invalid effect slot integer-vector property 0x%04x", param);
 628     }
 629 }
 630 END_API_FUNC
 631
 632 AL_API void AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat value)
 633 START_API_FUNC
 634 {
 635     ContextRef context{GetContextRef()};
 636     if UNLIKELY(!context) return;
 637
 638     std::lock_guard<std::mutex> _{context->mPropLock};
 639     std::lock_guard<std::mutex> __{context->mEffectSlotLock};
 640     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 641     if UNLIKELY(!slot)
 642         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 643
 644     switch(param)
 645     {
 646     case AL_EFFECTSLOT_GAIN:
 647         if(!(value >= 0.0f && value <= 1.0f))
 648             SETERR_RETURN(context, AL_INVALID_VALUE,, "Effect slot gain out of range");
 649         slot->Gain = value;
 650         break;
 651
 652     default:
 653         SETERR_RETURN(context, AL_INVALID_ENUM,, "Invalid effect slot float property 0x%04x",
 654             param);
 655     }
 656     DO_UPDATEPROPS();
 657 }
 658 END_API_FUNC
 659
 660 AL_API void AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *values)
 661 START_API_FUNC
 662 {
 663     switch(param)
 664     {
 665     case AL_EFFECTSLOT_GAIN:
 666         alAuxiliaryEffectSlotf(effectslot, param, values[0]);
 667         return;
 668     }
 669
 670     ContextRef context{GetContextRef()};
 671     if UNLIKELY(!context) return;
 672
 673     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 674     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 675     if UNLIKELY(!slot)
 676         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 677
 678     switch(param)
 679     {
 680     default:
 681         SETERR_RETURN(context, AL_INVALID_ENUM,,
 682             "Invalid effect slot float-vector property 0x%04x", param);
 683     }
 684 }
 685 END_API_FUNC
 686
 687
 688 AL_API void AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *value)
 689 START_API_FUNC
 690 {
 691     ContextRef context{GetContextRef()};
 692     if UNLIKELY(!context) return;
 693
 694     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 695     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 696     if UNLIKELY(!slot)
 697         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 698
 699     switch(param)
 700     {
 701     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 702         *value = slot->AuxSendAuto ? AL_TRUE : AL_FALSE;
 703         break;
 704
 705     case AL_EFFECTSLOT_TARGET_SOFT:
 706         if(auto *target = slot->Target)
 707             *value = static_cast<ALint>(target->id);
 708         else
 709             *value = 0;
 710         break;
 711
 712     case AL_EFFECTSLOT_STATE_SOFT:
 713         *value = static_cast<int>(slot->mState);
 714         break;
 715
 716     case AL_BUFFER:
 717         if(auto *buffer = slot->Buffer)
 718             *value = static_cast<ALint>(buffer->id);
 719         else
 720             *value = 0;
 721         break;
 722
 723     default:
 724         context->setError(AL_INVALID_ENUM, "Invalid effect slot integer property 0x%04x", param);
 725     }
 726 }
 727 END_API_FUNC
 728
 729 AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *values)
 730 START_API_FUNC
 731 {
 732     switch(param)
 733     {
 734     case AL_EFFECTSLOT_EFFECT:
 735     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 736     case AL_EFFECTSLOT_TARGET_SOFT:
 737     case AL_EFFECTSLOT_STATE_SOFT:
 738     case AL_BUFFER:
 739         alGetAuxiliaryEffectSloti(effectslot, param, values);
 740         return;
 741     }
 742
 743     ContextRef context{GetContextRef()};
 744     if UNLIKELY(!context) return;
 745
 746     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 747     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 748     if UNLIKELY(!slot)
 749         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 750
 751     switch(param)
 752     {
 753     default:
 754         context->setError(AL_INVALID_ENUM, "Invalid effect slot integer-vector property 0x%04x",
 755             param);
 756     }
 757 }
 758 END_API_FUNC
 759
 760 AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value)
 761 START_API_FUNC
 762 {
 763     ContextRef context{GetContextRef()};
 764     if UNLIKELY(!context) return;
 765
 766     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 767     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 768     if UNLIKELY(!slot)
 769         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 770
 771     switch(param)
 772     {
 773     case AL_EFFECTSLOT_GAIN:
 774         *value = slot->Gain;
 775         break;
 776
 777     default:
 778         context->setError(AL_INVALID_ENUM, "Invalid effect slot float property 0x%04x", param);
 779     }
 780 }
 781 END_API_FUNC
 782
 783 AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *values)
 784 START_API_FUNC
 785 {
 786     switch(param)
 787     {
 788     case AL_EFFECTSLOT_GAIN:
 789         alGetAuxiliaryEffectSlotf(effectslot, param, values);
 790         return;
 791     }
 792
 793     ContextRef context{GetContextRef()};
 794     if UNLIKELY(!context) return;
 795
 796     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 797     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
 798     if UNLIKELY(!slot)
 799         SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
 800
 801     switch(param)
 802     {
 803     default:
 804         context->setError(AL_INVALID_ENUM, "Invalid effect slot float-vector property 0x%04x",
 805             param);
 806     }
 807 }
 808 END_API_FUNC
 809
 810
 811 ALeffectslot::~ALeffectslot()
 812 {
 813     if(Target)
 814         DecrementRef(Target->ref);
 815     Target = nullptr;
 816     if(Buffer)
 817         DecrementRef(Buffer->ref);
 818     Buffer = nullptr;
 819
 820     ALeffectslotProps *props{Params.Update.load()};
 821     if(props)
 822     {
 823         TRACE("Freed unapplied AuxiliaryEffectSlot update %p\n",
 824             decltype(std::declval<void*>()){props});
 825         delete props;
 826     }
 827
 828     if(Params.mEffectState)
 829         Params.mEffectState->release();
 830 }
 831
 832 ALenum ALeffectslot::init()
 833 {
 834     EffectStateFactory *factory{getFactoryByType(Effect.Type)};
 835     if(!factory) return AL_INVALID_VALUE;
 836
 837     Effect.State.reset(factory->create());
 838     if(!Effect.State) return AL_OUT_OF_MEMORY;
 839
 840     Effect.State->add_ref();
 841     Params.mEffectState = Effect.State.get();
 842     return AL_NO_ERROR;
 843 }
 844
 845 ALenum ALeffectslot::initEffect(ALeffect *effect, ALCcontext *context)
 846 {
 847     ALenum newtype{effect ? effect->type : AL_EFFECT_NULL};
 848     if(newtype != Effect.Type)
 849     {
 850         EffectStateFactory *factory{getFactoryByType(newtype)};
 851         if(!factory)
 852         {
 853             ERR("Failed to find factory for effect type 0x%04x\n", newtype);
 854             return AL_INVALID_ENUM;
 855         }
 856         al::intrusive_ptr<EffectState> State{factory->create()};
 857         if(!State) return AL_OUT_OF_MEMORY;
 858
 859         ALCdevice *Device{context->mDevice.get()};
 860         std::unique_lock<std::mutex> statelock{Device->StateLock};
 861         State->mOutTarget = Device->Dry.Buffer;
 862         {
 863             FPUCtl mixer_mode{};
 864             State->deviceUpdate(Device);
 865             if(Buffer)
 866                 State->setBuffer(Device, &Buffer->mBuffer);
 867         }
 868
 869         if(!effect)
 870         {
 871             Effect.Type = AL_EFFECT_NULL;
 872             Effect.Props = EffectProps{};
 873         }
 874         else
 875         {
 876             Effect.Type = effect->type;
 877             Effect.Props = effect->Props;
 878         }
 879
 880         Effect.State = std::move(State);
 881     }
 882     else if(effect)
 883         Effect.Props = effect->Props;
 884
 885     /* Remove state references from old effect slot property updates. */
 886     ALeffectslotProps *props{context->mFreeEffectslotProps.load()};
 887     while(props)
 888     {
 889         props->State = nullptr;
 890         props = props->next.load(std::memory_order_relaxed);
 891     }
 892
 893     return AL_NO_ERROR;
 894 }
 895
 896 void ALeffectslot::updateProps(ALCcontext *context)
 897 {
 898     /* Get an unused property container, or allocate a new one as needed. */
 899     ALeffectslotProps *props{context->mFreeEffectslotProps.load(std::memory_order_relaxed)};
 900     if(!props)
 901         props = new ALeffectslotProps{};
 902     else
 903     {
 904         ALeffectslotProps *next;
 905         do {
 906             next = props->next.load(std::memory_order_relaxed);
 907         } while(context->mFreeEffectslotProps.compare_exchange_weak(props, next,
 908                 std::memory_order_seq_cst, std::memory_order_acquire) == 0);
 909     }
 910
 911     /* Copy in current property values. */
 912     props->Gain = Gain;
 913     props->AuxSendAuto = AuxSendAuto;
 914     props->Target = Target;
 915
 916     props->Type = Effect.Type;
 917     props->Props = Effect.Props;
 918     props->State = Effect.State;
 919
 920     /* Set the new container for updating internal parameters. */
 921     props = Params.Update.exchange(props, std::memory_order_acq_rel);
 922     if(props)
 923     {
 924         /* If there was an unused update container, put it back in the
 925          * freelist.
 926          */
 927         props->State = nullptr;
 928         AtomicReplaceHead(context->mFreeEffectslotProps, props);
 929     }
 930 }
 931
 932 void UpdateAllEffectSlotProps(ALCcontext *context)
 933 {
 934     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
 935     ALeffectslotArray *auxslots{context->mActiveAuxSlots.load(std::memory_order_acquire)};
 936     for(ALeffectslot *slot : *auxslots)
 937     {
 938         if(!slot->PropsClean.test_and_set(std::memory_order_acq_rel))
 939             slot->updateProps(context);
 940     }
 941 }
 942
 943 EffectSlotSubList::~EffectSlotSubList()
 944 {
 945     uint64_t usemask{~FreeMask};
 946     while(usemask)
 947     {
 948         ALsizei idx{CTZ64(usemask)};
 949         al::destroy_at(EffectSlots+idx);
 950         usemask &= ~(1_u64 << idx);
 951     }
 952     FreeMask = ~usemask;
 953     al_free(EffectSlots);
 954     EffectSlots = nullptr;
 955 }