al/source.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 "source.h"
  24
  25 #include <algorithm>
  26 #include <array>
  27 #include <atomic>
  28 #include <bitset>
  29 #include <cassert>
  30 #include <chrono>
  31 #include <cinttypes>
  32 #include <cmath>
  33 #include <cstdint>
  34 #include <cstdio>
  35 #include <exception>
  36 #include <iterator>
  37 #include <limits>
  38 #include <memory>
  39 #include <mutex>
  40 #include <numeric>
  41 #include <optional>
  42 #include <ratio>
  43 #include <stdexcept>
  44 #include <string>
  45 #include <tuple>
  46 #include <type_traits>
  47 #include <unordered_map>
  48 #include <utility>
  49 #include <vector>
  50
  51 #include "AL/al.h"
  52 #include "AL/alc.h"
  53 #include "AL/alext.h"
  54 #include "AL/efx.h"
  55
  56 #include "albit.h"
  57 #include "alc/backends/base.h"
  58 #include "alc/context.h"
  59 #include "alc/device.h"
  60 #include "alc/inprogext.h"
  61 #include "almalloc.h"
  62 #include "alnumeric.h"
  63 #include "alspan.h"
  64 #include "atomic.h"
  65 #include "auxeffectslot.h"
  66 #include "buffer.h"
  67 #include "core/buffer_storage.h"
  68 #include "core/logging.h"
  69 #include "core/mixer/defs.h"
  70 #include "core/voice_change.h"
  71 #include "direct_defs.h"
  72 #include "error.h"
  73 #include "filter.h"
  74 #include "flexarray.h"
  75 #include "intrusive_ptr.h"
  76 #include "opthelpers.h"
  77
  78 #ifdef ALSOFT_EAX
  79 #include "eax/api.h"
  80 #include "eax/call.h"
  81 #include "eax/fx_slot_index.h"
  82 #include "eax/utils.h"
  83 #endif
  84
  85 namespace {
  86
  87 using SubListAllocator = al::allocator<std::array<ALsource,64>>;
  88 using std::chrono::nanoseconds;
  89 using seconds_d = std::chrono::duration<double>;
  90 using source_store_array = std::array<ALsource*,3>;
  91 using source_store_vector = std::vector<ALsource*>;
  92 using source_store_variant = std::variant<std::monostate,source_store_array,source_store_vector>;
  93
  94
  95 Voice *GetSourceVoice(ALsource *source, ALCcontext *context)
  96 {
  97     auto voicelist = context->getVoicesSpan();
  98     ALuint idx{source->VoiceIdx};
  99     if(idx < voicelist.size())
 100     {
 101         ALuint sid{source->id};
 102         Voice *voice = voicelist[idx];
 103         if(voice->mSourceID.load(std::memory_order_acquire) == sid)
 104             return voice;
 105     }
 106     source->VoiceIdx = InvalidVoiceIndex;
 107     return nullptr;
 108 }
 109
 110
 111 void UpdateSourceProps(const ALsource *source, Voice *voice, ALCcontext *context)
 112 {
 113     /* Get an unused property container, or allocate a new one as needed. */
 114     VoicePropsItem *props{context->mFreeVoiceProps.load(std::memory_order_acquire)};
 115     if(!props)
 116     {
 117         context->allocVoiceProps();
 118         props = context->mFreeVoiceProps.load(std::memory_order_acquire);
 119     }
 120     VoicePropsItem *next;
 121     do {
 122         next = props->next.load(std::memory_order_relaxed);
 123     } while(context->mFreeVoiceProps.compare_exchange_weak(props, next,
 124         std::memory_order_acq_rel, std::memory_order_acquire) == false);
 125
 126     props->Pitch = source->Pitch;
 127     props->Gain = source->Gain;
 128     props->OuterGain = source->OuterGain;
 129     props->MinGain = source->MinGain;
 130     props->MaxGain = source->MaxGain;
 131     props->InnerAngle = source->InnerAngle;
 132     props->OuterAngle = source->OuterAngle;
 133     props->RefDistance = source->RefDistance;
 134     props->MaxDistance = source->MaxDistance;
 135     props->RolloffFactor = source->RolloffFactor
 136 #ifdef ALSOFT_EAX
 137         + source->RolloffFactor2
 138 #endif
 139     ;
 140     props->Position = source->Position;
 141     props->Velocity = source->Velocity;
 142     props->Direction = source->Direction;
 143     props->OrientAt = source->OrientAt;
 144     props->OrientUp = source->OrientUp;
 145     props->HeadRelative = source->HeadRelative;
 146     props->mDistanceModel = source->mDistanceModel;
 147     props->mResampler = source->mResampler;
 148     props->DirectChannels = source->DirectChannels;
 149     props->mSpatializeMode = source->mSpatialize;
 150
 151     props->DryGainHFAuto = source->DryGainHFAuto;
 152     props->WetGainAuto = source->WetGainAuto;
 153     props->WetGainHFAuto = source->WetGainHFAuto;
 154     props->OuterGainHF = source->OuterGainHF;
 155
 156     props->AirAbsorptionFactor = source->AirAbsorptionFactor;
 157     props->RoomRolloffFactor = source->RoomRolloffFactor;
 158     props->DopplerFactor = source->DopplerFactor;
 159
 160     props->StereoPan = source->StereoPan;
 161
 162     props->Radius = source->Radius;
 163     props->EnhWidth = source->EnhWidth;
 164     props->Panning = source->mPanningEnabled ? source->mPan : 0.0f;
 165
 166     props->Direct.Gain = source->Direct.Gain;
 167     props->Direct.GainHF = source->Direct.GainHF;
 168     props->Direct.HFReference = source->Direct.HFReference;
 169     props->Direct.GainLF = source->Direct.GainLF;
 170     props->Direct.LFReference = source->Direct.LFReference;
 171
 172     auto copy_send = [](const ALsource::SendData &srcsend) noexcept -> VoiceProps::SendData
 173     {
 174         VoiceProps::SendData ret{};
 175         ret.Slot = srcsend.Slot ? srcsend.Slot->mSlot : nullptr;
 176         ret.Gain = srcsend.Gain;
 177         ret.GainHF = srcsend.GainHF;
 178         ret.HFReference = srcsend.HFReference;
 179         ret.GainLF = srcsend.GainLF;
 180         ret.LFReference = srcsend.LFReference;
 181         return ret;
 182     };
 183     std::transform(source->Send.cbegin(), source->Send.cend(), props->Send.begin(), copy_send);
 184     if(!props->Send[0].Slot && context->mDefaultSlot)
 185         props->Send[0].Slot = context->mDefaultSlot->mSlot;
 186
 187     /* Set the new container for updating internal parameters. */
 188     props = voice->mUpdate.exchange(props, std::memory_order_acq_rel);
 189     if(props)
 190     {
 191         /* If there was an unused update container, put it back in the
 192          * freelist.
 193          */
 194         AtomicReplaceHead(context->mFreeVoiceProps, props);
 195     }
 196 }
 197
 198 /* GetSourceSampleOffset
 199  *
 200  * Gets the current read offset for the given Source, in 32.32 fixed-point
 201  * samples. The offset is relative to the start of the queue (not the start of
 202  * the current buffer).
 203  */
 204 int64_t GetSourceSampleOffset(ALsource *Source, ALCcontext *context, nanoseconds *clocktime)
 205 {
 206     ALCdevice *device{context->mALDevice.get()};
 207     const VoiceBufferItem *Current{};
 208     int64_t readPos{};
 209     uint refcount{};
 210     Voice *voice{};
 211
 212     do {
 213         refcount = device->waitForMix();
 214         *clocktime = device->getClockTime();
 215         voice = GetSourceVoice(Source, context);
 216         if(voice)
 217         {
 218             Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
 219
 220             readPos  = int64_t{voice->mPosition.load(std::memory_order_relaxed)} << MixerFracBits;
 221             readPos += voice->mPositionFrac.load(std::memory_order_relaxed);
 222         }
 223         std::atomic_thread_fence(std::memory_order_acquire);
 224     } while(refcount != device->mMixCount.load(std::memory_order_relaxed));
 225
 226     if(!voice)
 227         return 0;
 228
 229     for(auto &item : Source->mQueue)
 230     {
 231         if(&item == Current) break;
 232         readPos += int64_t{item.mSampleLen} << MixerFracBits;
 233     }
 234     if(readPos > std::numeric_limits<int64_t>::max() >> (32-MixerFracBits))
 235         return std::numeric_limits<int64_t>::max();
 236     return readPos << (32-MixerFracBits);
 237 }
 238
 239 /* GetSourceSecOffset
 240  *
 241  * Gets the current read offset for the given Source, in seconds. The offset is
 242  * relative to the start of the queue (not the start of the current buffer).
 243  */
 244 double GetSourceSecOffset(ALsource *Source, ALCcontext *context, nanoseconds *clocktime)
 245 {
 246     ALCdevice *device{context->mALDevice.get()};
 247     const VoiceBufferItem *Current{};
 248     int64_t readPos{};
 249     uint refcount{};
 250     Voice *voice{};
 251
 252     do {
 253         refcount = device->waitForMix();
 254         *clocktime = device->getClockTime();
 255         voice = GetSourceVoice(Source, context);
 256         if(voice)
 257         {
 258             Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
 259
 260             readPos  = int64_t{voice->mPosition.load(std::memory_order_relaxed)} << MixerFracBits;
 261             readPos += voice->mPositionFrac.load(std::memory_order_relaxed);
 262         }
 263         std::atomic_thread_fence(std::memory_order_acquire);
 264     } while(refcount != device->mMixCount.load(std::memory_order_relaxed));
 265
 266     if(!voice)
 267         return 0.0f;
 268
 269     const ALbuffer *BufferFmt{nullptr};
 270     auto BufferList = Source->mQueue.cbegin();
 271     while(BufferList != Source->mQueue.cend() && al::to_address(BufferList) != Current)
 272     {
 273         if(!BufferFmt) BufferFmt = BufferList->mBuffer;
 274         readPos += int64_t{BufferList->mSampleLen} << MixerFracBits;
 275         ++BufferList;
 276     }
 277     while(BufferList != Source->mQueue.cend() && !BufferFmt)
 278     {
 279         BufferFmt = BufferList->mBuffer;
 280         ++BufferList;
 281     }
 282     ASSUME(BufferFmt != nullptr);
 283
 284     return static_cast<double>(readPos) / double{MixerFracOne} / BufferFmt->mSampleRate;
 285 }
 286
 287 /* GetSourceOffset
 288  *
 289  * Gets the current read offset for the given Source, in the appropriate format
 290  * (Bytes, Samples or Seconds). The offset is relative to the start of the
 291  * queue (not the start of the current buffer).
 292  */
 293 template<typename T>
 294 NOINLINE T GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
 295 {
 296     ALCdevice *device{context->mALDevice.get()};
 297     const VoiceBufferItem *Current{};
 298     int64_t readPos{};
 299     uint readPosFrac{};
 300     uint refcount;
 301     Voice *voice;
 302
 303     do {
 304         refcount = device->waitForMix();
 305         voice = GetSourceVoice(Source, context);
 306         if(voice)
 307         {
 308             Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
 309
 310             readPos = voice->mPosition.load(std::memory_order_relaxed);
 311             readPosFrac = voice->mPositionFrac.load(std::memory_order_relaxed);
 312         }
 313         std::atomic_thread_fence(std::memory_order_acquire);
 314     } while(refcount != device->mMixCount.load(std::memory_order_relaxed));
 315
 316     if(!voice)
 317         return T{0};
 318
 319     const ALbuffer *BufferFmt{nullptr};
 320     auto BufferList = Source->mQueue.cbegin();
 321     while(BufferList != Source->mQueue.cend() && al::to_address(BufferList) != Current)
 322     {
 323         if(!BufferFmt) BufferFmt = BufferList->mBuffer;
 324         readPos += BufferList->mSampleLen;
 325         ++BufferList;
 326     }
 327     while(BufferList != Source->mQueue.cend() && !BufferFmt)
 328     {
 329         BufferFmt = BufferList->mBuffer;
 330         ++BufferList;
 331     }
 332     ASSUME(BufferFmt != nullptr);
 333
 334     T offset{};
 335     switch(name)
 336     {
 337     case AL_SEC_OFFSET:
 338         if constexpr(std::is_floating_point_v<T>)
 339         {
 340             offset  = static_cast<T>(readPos) + static_cast<T>(readPosFrac)/T{MixerFracOne};
 341             offset /= static_cast<T>(BufferFmt->mSampleRate);
 342         }
 343         else
 344         {
 345             readPos /= BufferFmt->mSampleRate;
 346             offset = static_cast<T>(std::clamp<int64_t>(readPos, std::numeric_limits<T>::min(),
 347                 std::numeric_limits<T>::max()));
 348         }
 349         break;
 350
 351     case AL_SAMPLE_OFFSET:
 352         if constexpr(std::is_floating_point_v<T>)
 353             offset = static_cast<T>(readPos) + static_cast<T>(readPosFrac)/T{MixerFracOne};
 354         else
 355             offset = static_cast<T>(std::clamp<int64_t>(readPos, std::numeric_limits<T>::min(),
 356                 std::numeric_limits<T>::max()));
 357         break;
 358
 359     case AL_BYTE_OFFSET:
 360         const ALuint BlockSamples{BufferFmt->mBlockAlign};
 361         const ALuint BlockSize{BufferFmt->blockSizeFromFmt()};
 362         /* Round down to the block boundary. */
 363         readPos = readPos / BlockSamples * BlockSize;
 364
 365         if constexpr(std::is_floating_point_v<T>)
 366             offset = static_cast<T>(readPos);
 367         else
 368         {
 369             if(readPos > std::numeric_limits<T>::max())
 370                 offset = RoundDown(std::numeric_limits<T>::max(), static_cast<T>(BlockSize));
 371             else if(readPos < std::numeric_limits<T>::min())
 372                 offset = RoundUp(std::numeric_limits<T>::min(), static_cast<T>(BlockSize));
 373             else
 374                 offset = static_cast<T>(readPos);
 375         }
 376         break;
 377     }
 378     return offset;
 379 }
 380
 381 /* GetSourceLength
 382  *
 383  * Gets the length of the given Source's buffer queue, in the appropriate
 384  * format (Bytes, Samples or Seconds).
 385  */
 386 template<typename T>
 387 NOINLINE T GetSourceLength(const ALsource *source, ALenum name)
 388 {
 389     uint64_t length{0};
 390     const ALbuffer *BufferFmt{nullptr};
 391     for(auto &listitem : source->mQueue)
 392     {
 393         if(!BufferFmt)
 394             BufferFmt = listitem.mBuffer;
 395         length += listitem.mSampleLen;
 396     }
 397     if(length == 0)
 398         return T{0};
 399
 400     ASSUME(BufferFmt != nullptr);
 401     switch(name)
 402     {
 403     case AL_SEC_LENGTH_SOFT:
 404         if constexpr(std::is_floating_point_v<T>)
 405             return static_cast<T>(length) / static_cast<T>(BufferFmt->mSampleRate);
 406         else
 407             return static_cast<T>(std::min<uint64_t>(length/BufferFmt->mSampleRate,
 408                 std::numeric_limits<T>::max()));
 409
 410     case AL_SAMPLE_LENGTH_SOFT:
 411         if constexpr(std::is_floating_point_v<T>)
 412             return static_cast<T>(length);
 413         else
 414             return static_cast<T>(std::min<uint64_t>(length, std::numeric_limits<T>::max()));
 415
 416     case AL_BYTE_LENGTH_SOFT:
 417         const ALuint BlockSamples{BufferFmt->mBlockAlign};
 418         const ALuint BlockSize{BufferFmt->blockSizeFromFmt()};
 419         /* Round down to the block boundary. */
 420         length = length / BlockSamples * BlockSize;
 421
 422         if constexpr(std::is_floating_point_v<T>)
 423             return static_cast<T>(length);
 424         else
 425         {
 426             if(length > uint64_t{std::numeric_limits<T>::max()})
 427                 return RoundDown(std::numeric_limits<T>::max(), static_cast<T>(BlockSize));
 428             return static_cast<T>(length);
 429         }
 430     }
 431     return T{0};
 432 }
 433
 434
 435 struct VoicePos {
 436     int pos;
 437     uint frac;
 438     ALbufferQueueItem *bufferitem;
 439 };
 440
 441 /**
 442  * GetSampleOffset
 443  *
 444  * Retrieves the voice position, fixed-point fraction, and bufferlist item
 445  * using the given offset type and offset. If the offset is out of range,
 446  * returns an empty optional.
 447  */
 448 std::optional<VoicePos> GetSampleOffset(std::deque<ALbufferQueueItem> &BufferList,
 449     ALenum OffsetType, double Offset)
 450 {
 451     /* Find the first valid Buffer in the Queue */
 452     const ALbuffer *BufferFmt{nullptr};
 453     for(auto &item : BufferList)
 454     {
 455         BufferFmt = item.mBuffer;
 456         if(BufferFmt) break;
 457     }
 458     if(!BufferFmt) UNLIKELY
 459         return std::nullopt;
 460
 461     /* Get sample frame offset */
 462     int64_t offset{};
 463     uint frac{};
 464     double dbloff, dblfrac;
 465     switch(OffsetType)
 466     {
 467     case AL_SEC_OFFSET:
 468         dblfrac = std::modf(Offset*BufferFmt->mSampleRate, &dbloff);
 469         if(dblfrac < 0.0)
 470         {
 471             /* If there's a negative fraction, reduce the offset to "floor" it,
 472              * and convert the fraction to a percentage to the next value (e.g.
 473              * -2.75 -> -3 + 0.25).
 474              */
 475             dbloff -= 1.0;
 476             dblfrac += 1.0;
 477         }
 478         offset = static_cast<int64_t>(dbloff);
 479         frac = static_cast<uint>(std::min(dblfrac*MixerFracOne, MixerFracOne-1.0));
 480         break;
 481
 482     case AL_SAMPLE_OFFSET:
 483         dblfrac = std::modf(Offset, &dbloff);
 484         if(dblfrac < 0.0)
 485         {
 486             dbloff -= 1.0;
 487             dblfrac += 1.0;
 488         }
 489         offset = static_cast<int64_t>(dbloff);
 490         frac = static_cast<uint>(std::min(dblfrac*MixerFracOne, MixerFracOne-1.0));
 491         break;
 492
 493     case AL_BYTE_OFFSET:
 494         /* Determine the ByteOffset (and ensure it is block aligned) */
 495         Offset = std::floor(Offset / BufferFmt->blockSizeFromFmt());
 496         offset = static_cast<int64_t>(Offset) * BufferFmt->mBlockAlign;
 497         frac = 0;
 498         break;
 499     }
 500
 501     /* Find the bufferlist item this offset belongs to. */
 502     if(offset < 0)
 503     {
 504         if(offset < std::numeric_limits<int>::min())
 505             return std::nullopt;
 506         return VoicePos{static_cast<int>(offset), frac, &BufferList.front()};
 507     }
 508
 509     if(BufferFmt->mCallback)
 510         return std::nullopt;
 511
 512     int64_t totalBufferLen{0};
 513     for(auto &item : BufferList)
 514     {
 515         if(totalBufferLen > offset)
 516             break;
 517         if(item.mSampleLen > offset-totalBufferLen)
 518         {
 519             /* Offset is in this buffer */
 520             return VoicePos{static_cast<int>(offset-totalBufferLen), frac, &item};
 521         }
 522         totalBufferLen += item.mSampleLen;
 523     }
 524
 525     /* Offset is out of range of the queue */
 526     return std::nullopt;
 527 }
 528
 529
 530 void InitVoice(Voice *voice, ALsource *source, ALbufferQueueItem *BufferList, ALCcontext *context,
 531     ALCdevice *device)
 532 {
 533     voice->mLoopBuffer.store(source->Looping ? &source->mQueue.front() : nullptr,
 534         std::memory_order_relaxed);
 535
 536     ALbuffer *buffer{BufferList->mBuffer};
 537     voice->mFrequency = buffer->mSampleRate;
 538     if(buffer->mChannels == FmtMono && source->mPanningEnabled)
 539         voice->mFmtChannels = FmtMonoDup;
 540     else if(buffer->mChannels == FmtStereo && source->mStereoMode == SourceStereo::Enhanced)
 541         voice->mFmtChannels = FmtSuperStereo;
 542     else
 543         voice->mFmtChannels = buffer->mChannels;
 544     voice->mFmtType = buffer->mType;
 545     voice->mFrameStep = buffer->channelsFromFmt();
 546     voice->mBytesPerBlock = buffer->blockSizeFromFmt();
 547     voice->mSamplesPerBlock = buffer->mBlockAlign;
 548     voice->mAmbiLayout = IsUHJ(voice->mFmtChannels) ? AmbiLayout::FuMa : buffer->mAmbiLayout;
 549     voice->mAmbiScaling = IsUHJ(voice->mFmtChannels) ? AmbiScaling::UHJ : buffer->mAmbiScaling;
 550     voice->mAmbiOrder = (voice->mFmtChannels == FmtSuperStereo) ? 1 : buffer->mAmbiOrder;
 551
 552     if(buffer->mCallback) voice->mFlags.set(VoiceIsCallback);
 553     else if(source->SourceType == AL_STATIC) voice->mFlags.set(VoiceIsStatic);
 554     voice->mNumCallbackBlocks = 0;
 555     voice->mCallbackBlockBase = 0;
 556
 557     voice->prepare(device);
 558
 559     source->mPropsDirty = false;
 560     UpdateSourceProps(source, voice, context);
 561
 562     voice->mSourceID.store(source->id, std::memory_order_release);
 563 }
 564
 565
 566 VoiceChange *GetVoiceChanger(ALCcontext *ctx)
 567 {
 568     VoiceChange *vchg{ctx->mVoiceChangeTail};
 569     if(vchg == ctx->mCurrentVoiceChange.load(std::memory_order_acquire)) UNLIKELY
 570     {
 571         ctx->allocVoiceChanges();
 572         vchg = ctx->mVoiceChangeTail;
 573     }
 574
 575     ctx->mVoiceChangeTail = vchg->mNext.exchange(nullptr, std::memory_order_relaxed);
 576
 577     return vchg;
 578 }
 579
 580 void SendVoiceChanges(ALCcontext *ctx, VoiceChange *tail)
 581 {
 582     ALCdevice *device{ctx->mALDevice.get()};
 583
 584     VoiceChange *oldhead{ctx->mCurrentVoiceChange.load(std::memory_order_acquire)};
 585     while(VoiceChange *next{oldhead->mNext.load(std::memory_order_relaxed)})
 586         oldhead = next;
 587     oldhead->mNext.store(tail, std::memory_order_release);
 588
 589     const bool connected{device->Connected.load(std::memory_order_acquire)};
 590     std::ignore = device->waitForMix();
 591     if(!connected) UNLIKELY
 592     {
 593         if(ctx->mStopVoicesOnDisconnect.load(std::memory_order_acquire))
 594         {
 595             /* If the device is disconnected and voices are stopped, just
 596              * ignore all pending changes.
 597              */
 598             VoiceChange *cur{ctx->mCurrentVoiceChange.load(std::memory_order_acquire)};
 599             while(VoiceChange *next{cur->mNext.load(std::memory_order_acquire)})
 600             {
 601                 cur = next;
 602                 if(Voice *voice{cur->mVoice})
 603                     voice->mSourceID.store(0, std::memory_order_relaxed);
 604             }
 605             ctx->mCurrentVoiceChange.store(cur, std::memory_order_release);
 606         }
 607     }
 608 }
 609
 610
 611 bool SetVoiceOffset(Voice *oldvoice, const VoicePos &vpos, ALsource *source, ALCcontext *context,
 612     ALCdevice *device)
 613 {
 614     /* First, get a free voice to start at the new offset. */
 615     auto voicelist = context->getVoicesSpan();
 616     Voice *newvoice{};
 617     ALuint vidx{0};
 618     for(Voice *voice : voicelist)
 619     {
 620         if(voice->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
 621             && voice->mSourceID.load(std::memory_order_relaxed) == 0u
 622             && voice->mPendingChange.load(std::memory_order_relaxed) == false)
 623         {
 624             newvoice = voice;
 625             break;
 626         }
 627         ++vidx;
 628     }
 629     if(!newvoice) UNLIKELY
 630     {
 631         auto &allvoices = *context->mVoices.load(std::memory_order_relaxed);
 632         if(allvoices.size() == voicelist.size())
 633             context->allocVoices(1);
 634         context->mActiveVoiceCount.fetch_add(1, std::memory_order_release);
 635         voicelist = context->getVoicesSpan();
 636
 637         vidx = 0;
 638         for(Voice *voice : voicelist)
 639         {
 640             if(voice->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
 641                 && voice->mSourceID.load(std::memory_order_relaxed) == 0u
 642                 && voice->mPendingChange.load(std::memory_order_relaxed) == false)
 643             {
 644                 newvoice = voice;
 645                 break;
 646             }
 647             ++vidx;
 648         }
 649         ASSUME(newvoice != nullptr);
 650     }
 651
 652     /* Initialize the new voice and set its starting offset.
 653      * TODO: It might be better to have the VoiceChange processing copy the old
 654      * voice's mixing parameters (and pending update) insead of initializing it
 655      * all here. This would just need to set the minimum properties to link the
 656      * voice to the source and its position-dependent properties (including the
 657      * fading flag).
 658      */
 659     newvoice->mPlayState.store(Voice::Pending, std::memory_order_relaxed);
 660     newvoice->mPosition.store(vpos.pos, std::memory_order_relaxed);
 661     newvoice->mPositionFrac.store(vpos.frac, std::memory_order_relaxed);
 662     newvoice->mCurrentBuffer.store(vpos.bufferitem, std::memory_order_relaxed);
 663     newvoice->mStartTime = oldvoice->mStartTime;
 664     newvoice->mFlags.reset();
 665     if(vpos.pos > 0 || (vpos.pos == 0 && vpos.frac > 0)
 666         || vpos.bufferitem != &source->mQueue.front())
 667         newvoice->mFlags.set(VoiceIsFading);
 668     InitVoice(newvoice, source, vpos.bufferitem, context, device);
 669     source->VoiceIdx = vidx;
 670
 671     /* Set the old voice as having a pending change, and send it off with the
 672      * new one with a new offset voice change.
 673      */
 674     oldvoice->mPendingChange.store(true, std::memory_order_relaxed);
 675
 676     VoiceChange *vchg{GetVoiceChanger(context)};
 677     vchg->mOldVoice = oldvoice;
 678     vchg->mVoice = newvoice;
 679     vchg->mSourceID = source->id;
 680     vchg->mState = VChangeState::Restart;
 681     SendVoiceChanges(context, vchg);
 682
 683     /* If the old voice still has a sourceID, it's still active and the change-
 684      * over will work on the next update.
 685      */
 686     if(oldvoice->mSourceID.load(std::memory_order_acquire) != 0u) LIKELY
 687         return true;
 688
 689     /* Otherwise, if the new voice's state is not pending, the change-over
 690      * already happened.
 691      */
 692     if(newvoice->mPlayState.load(std::memory_order_acquire) != Voice::Pending)
 693         return true;
 694
 695     /* Otherwise, wait for any current mix to finish and check one last time. */
 696     std::ignore = device->waitForMix();
 697     if(newvoice->mPlayState.load(std::memory_order_acquire) != Voice::Pending)
 698         return true;
 699     /* The change-over failed because the old voice stopped before the new
 700      * voice could start at the new offset. Let go of the new voice and have
 701      * the caller store the source offset since it's stopped.
 702      */
 703     newvoice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
 704     newvoice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
 705     newvoice->mSourceID.store(0u, std::memory_order_relaxed);
 706     newvoice->mPlayState.store(Voice::Stopped, std::memory_order_relaxed);
 707     return false;
 708 }
 709
 710
 711 /**
 712  * Returns if the last known state for the source was playing or paused. Does
 713  * not sync with the mixer voice.
 714  */
 715 inline bool IsPlayingOrPaused(ALsource *source)
 716 { return source->state == AL_PLAYING || source->state == AL_PAUSED; }
 717
 718 /**
 719  * Returns an updated source state using the matching voice's status (or lack
 720  * thereof).
 721  */
 722 inline ALenum GetSourceState(ALsource *source, Voice *voice)
 723 {
 724     if(!voice && source->state == AL_PLAYING)
 725         source->state = AL_STOPPED;
 726     return source->state;
 727 }
 728
 729
 730 bool EnsureSources(ALCcontext *context, size_t needed)
 731 {
 732     size_t count{std::accumulate(context->mSourceList.cbegin(), context->mSourceList.cend(), 0_uz,
 733         [](size_t cur, const SourceSubList &sublist) noexcept -> size_t
 734         { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
 735
 736     try {
 737         while(needed > count)
 738         {
 739             if(context->mSourceList.size() >= 1<<25) UNLIKELY
 740                 return false;
 741
 742             SourceSubList sublist{};
 743             sublist.FreeMask = ~0_u64;
 744             sublist.Sources = SubListAllocator{}.allocate(1);
 745             context->mSourceList.emplace_back(std::move(sublist));
 746             count += std::tuple_size_v<SubListAllocator::value_type>;
 747         }
 748     }
 749     catch(...) {
 750         return false;
 751     }
 752     return true;
 753 }
 754
 755 ALsource *AllocSource(ALCcontext *context) noexcept
 756 {
 757     auto sublist = std::find_if(context->mSourceList.begin(), context->mSourceList.end(),
 758         [](const SourceSubList &entry) noexcept -> bool
 759         { return entry.FreeMask != 0; });
 760     auto lidx = static_cast<ALuint>(std::distance(context->mSourceList.begin(), sublist));
 761     auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
 762     ASSUME(slidx < 64);
 763
 764     ALsource *source{al::construct_at(al::to_address(sublist->Sources->begin() + slidx))};
 765 #ifdef ALSOFT_EAX
 766     source->eaxInitialize(context);
 767 #endif // ALSOFT_EAX
 768
 769     /* Add 1 to avoid source ID 0. */
 770     source->id = ((lidx<<6) | slidx) + 1;
 771
 772     context->mNumSources += 1;
 773     sublist->FreeMask &= ~(1_u64 << slidx);
 774
 775     return source;
 776 }
 777
 778 void FreeSource(ALCcontext *context, ALsource *source)
 779 {
 780     context->mSourceNames.erase(source->id);
 781
 782     const ALuint id{source->id - 1};
 783     const size_t lidx{id >> 6};
 784     const ALuint slidx{id & 0x3f};
 785
 786     if(Voice *voice{GetSourceVoice(source, context)})
 787     {
 788         VoiceChange *vchg{GetVoiceChanger(context)};
 789
 790         voice->mPendingChange.store(true, std::memory_order_relaxed);
 791         vchg->mVoice = voice;
 792         vchg->mSourceID = source->id;
 793         vchg->mState = VChangeState::Stop;
 794
 795         SendVoiceChanges(context, vchg);
 796     }
 797
 798     std::destroy_at(source);
 799
 800     context->mSourceList[lidx].FreeMask |= 1_u64 << slidx;
 801     context->mNumSources--;
 802 }
 803
 804
 805 inline ALsource *LookupSource(ALCcontext *context, ALuint id) noexcept
 806 {
 807     const size_t lidx{(id-1) >> 6};
 808     const ALuint slidx{(id-1) & 0x3f};
 809
 810     if(lidx >= context->mSourceList.size()) UNLIKELY
 811         return nullptr;
 812     SourceSubList &sublist{context->mSourceList[lidx]};
 813     if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
 814         return nullptr;
 815     return al::to_address(sublist.Sources->begin() + slidx);
 816 }
 817
 818 auto LookupBuffer = [](ALCdevice *device, auto id) noexcept -> ALbuffer*
 819 {
 820     const auto lidx{(id-1) >> 6};
 821     const auto slidx{(id-1) & 0x3f};
 822
 823     if(lidx >= device->BufferList.size()) UNLIKELY
 824         return nullptr;
 825     BufferSubList &sublist = device->BufferList[static_cast<size_t>(lidx)];
 826     if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
 827         return nullptr;
 828     return al::to_address(sublist.Buffers->begin() + static_cast<size_t>(slidx));
 829 };
 830
 831 auto LookupFilter = [](ALCdevice *device, auto id) noexcept -> ALfilter*
 832 {
 833     const auto lidx{(id-1) >> 6};
 834     const auto slidx{(id-1) & 0x3f};
 835
 836     if(lidx >= device->FilterList.size()) UNLIKELY
 837         return nullptr;
 838     FilterSubList &sublist = device->FilterList[static_cast<size_t>(lidx)];
 839     if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
 840         return nullptr;
 841     return al::to_address(sublist.Filters->begin() + static_cast<size_t>(slidx));
 842 };
 843
 844 auto LookupEffectSlot = [](ALCcontext *context, auto id) noexcept -> ALeffectslot*
 845 {
 846     const auto lidx{(id-1) >> 6};
 847     const auto slidx{(id-1) & 0x3f};
 848
 849     if(lidx >= context->mEffectSlotList.size()) UNLIKELY
 850         return nullptr;
 851     EffectSlotSubList &sublist{context->mEffectSlotList[static_cast<size_t>(lidx)]};
 852     if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
 853         return nullptr;
 854     return al::to_address(sublist.EffectSlots->begin() + static_cast<size_t>(slidx));
 855 };
 856
 857
 858 auto StereoModeFromEnum = [](auto mode) noexcept -> std::optional<SourceStereo>
 859 {
 860     switch(mode)
 861     {
 862     case AL_NORMAL_SOFT: return SourceStereo::Normal;
 863     case AL_SUPER_STEREO_SOFT: return SourceStereo::Enhanced;
 864     }
 865     return std::nullopt;
 866 };
 867 ALenum EnumFromStereoMode(SourceStereo mode)
 868 {
 869     switch(mode)
 870     {
 871     case SourceStereo::Normal: return AL_NORMAL_SOFT;
 872     case SourceStereo::Enhanced: return AL_SUPER_STEREO_SOFT;
 873     }
 874     throw std::runtime_error{"Invalid SourceStereo: "+std::to_string(int(mode))};
 875 }
 876
 877 auto SpatializeModeFromEnum = [](auto mode) noexcept -> std::optional<SpatializeMode>
 878 {
 879     switch(mode)
 880     {
 881     case AL_FALSE: return SpatializeMode::Off;
 882     case AL_TRUE: return SpatializeMode::On;
 883     case AL_AUTO_SOFT: return SpatializeMode::Auto;
 884     }
 885     return std::nullopt;
 886 };
 887 ALenum EnumFromSpatializeMode(SpatializeMode mode)
 888 {
 889     switch(mode)
 890     {
 891     case SpatializeMode::Off: return AL_FALSE;
 892     case SpatializeMode::On: return AL_TRUE;
 893     case SpatializeMode::Auto: return AL_AUTO_SOFT;
 894     }
 895     throw std::runtime_error{"Invalid SpatializeMode: "+std::to_string(int(mode))};
 896 }
 897
 898 auto DirectModeFromEnum = [](auto mode) noexcept -> std::optional<DirectMode>
 899 {
 900     switch(mode)
 901     {
 902     case AL_FALSE: return DirectMode::Off;
 903     case AL_DROP_UNMATCHED_SOFT: return DirectMode::DropMismatch;
 904     case AL_REMIX_UNMATCHED_SOFT: return DirectMode::RemixMismatch;
 905     }
 906     return std::nullopt;
 907 };
 908 ALenum EnumFromDirectMode(DirectMode mode)
 909 {
 910     switch(mode)
 911     {
 912     case DirectMode::Off: return AL_FALSE;
 913     case DirectMode::DropMismatch: return AL_DROP_UNMATCHED_SOFT;
 914     case DirectMode::RemixMismatch: return AL_REMIX_UNMATCHED_SOFT;
 915     }
 916     throw std::runtime_error{"Invalid DirectMode: "+std::to_string(int(mode))};
 917 }
 918
 919 auto DistanceModelFromALenum = [](auto model) noexcept -> std::optional<DistanceModel>
 920 {
 921     switch(model)
 922     {
 923     case AL_NONE: return DistanceModel::Disable;
 924     case AL_INVERSE_DISTANCE: return DistanceModel::Inverse;
 925     case AL_INVERSE_DISTANCE_CLAMPED: return DistanceModel::InverseClamped;
 926     case AL_LINEAR_DISTANCE: return DistanceModel::Linear;
 927     case AL_LINEAR_DISTANCE_CLAMPED: return DistanceModel::LinearClamped;
 928     case AL_EXPONENT_DISTANCE: return DistanceModel::Exponent;
 929     case AL_EXPONENT_DISTANCE_CLAMPED: return DistanceModel::ExponentClamped;
 930     }
 931     return std::nullopt;
 932 };
 933 ALenum ALenumFromDistanceModel(DistanceModel model)
 934 {
 935     switch(model)
 936     {
 937     case DistanceModel::Disable: return AL_NONE;
 938     case DistanceModel::Inverse: return AL_INVERSE_DISTANCE;
 939     case DistanceModel::InverseClamped: return AL_INVERSE_DISTANCE_CLAMPED;
 940     case DistanceModel::Linear: return AL_LINEAR_DISTANCE;
 941     case DistanceModel::LinearClamped: return AL_LINEAR_DISTANCE_CLAMPED;
 942     case DistanceModel::Exponent: return AL_EXPONENT_DISTANCE;
 943     case DistanceModel::ExponentClamped: return AL_EXPONENT_DISTANCE_CLAMPED;
 944     }
 945     throw std::runtime_error{"Unexpected distance model "+std::to_string(static_cast<int>(model))};
 946 }
 947
 948 enum SourceProp : ALenum {
 949     srcPitch = AL_PITCH,
 950     srcGain = AL_GAIN,
 951     srcMinGain = AL_MIN_GAIN,
 952     srcMaxGain = AL_MAX_GAIN,
 953     srcMaxDistance = AL_MAX_DISTANCE,
 954     srcRolloffFactor = AL_ROLLOFF_FACTOR,
 955     srcDopplerFactor = AL_DOPPLER_FACTOR,
 956     srcConeOuterGain = AL_CONE_OUTER_GAIN,
 957     srcSecOffset = AL_SEC_OFFSET,
 958     srcSampleOffset = AL_SAMPLE_OFFSET,
 959     srcByteOffset = AL_BYTE_OFFSET,
 960     srcConeInnerAngle = AL_CONE_INNER_ANGLE,
 961     srcConeOuterAngle = AL_CONE_OUTER_ANGLE,
 962     srcRefDistance = AL_REFERENCE_DISTANCE,
 963
 964     srcPosition = AL_POSITION,
 965     srcVelocity = AL_VELOCITY,
 966     srcDirection = AL_DIRECTION,
 967
 968     srcSourceRelative = AL_SOURCE_RELATIVE,
 969     srcLooping = AL_LOOPING,
 970     srcBuffer = AL_BUFFER,
 971     srcSourceState = AL_SOURCE_STATE,
 972     srcBuffersQueued = AL_BUFFERS_QUEUED,
 973     srcBuffersProcessed = AL_BUFFERS_PROCESSED,
 974     srcSourceType = AL_SOURCE_TYPE,
 975
 976     /* ALC_EXT_EFX */
 977     srcConeOuterGainHF = AL_CONE_OUTER_GAINHF,
 978     srcAirAbsorptionFactor = AL_AIR_ABSORPTION_FACTOR,
 979     srcRoomRolloffFactor =  AL_ROOM_ROLLOFF_FACTOR,
 980     srcDirectFilterGainHFAuto = AL_DIRECT_FILTER_GAINHF_AUTO,
 981     srcAuxSendFilterGainAuto = AL_AUXILIARY_SEND_FILTER_GAIN_AUTO,
 982     srcAuxSendFilterGainHFAuto = AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO,
 983     srcDirectFilter = AL_DIRECT_FILTER,
 984     srcAuxSendFilter = AL_AUXILIARY_SEND_FILTER,
 985
 986     /* AL_SOFT_direct_channels */
 987     srcDirectChannelsSOFT = AL_DIRECT_CHANNELS_SOFT,
 988
 989     /* AL_EXT_source_distance_model */
 990     srcDistanceModel = AL_DISTANCE_MODEL,
 991
 992     /* AL_SOFT_source_latency */
 993     srcSampleOffsetLatencySOFT = AL_SAMPLE_OFFSET_LATENCY_SOFT,
 994     srcSecOffsetLatencySOFT = AL_SEC_OFFSET_LATENCY_SOFT,
 995
 996     /* AL_EXT_STEREO_ANGLES */
 997     srcAngles = AL_STEREO_ANGLES,
 998
 999     /* AL_EXT_SOURCE_RADIUS */
1000     srcRadius = AL_SOURCE_RADIUS,
1001
1002     /* AL_EXT_BFORMAT */
1003     srcOrientation = AL_ORIENTATION,
1004
1005     /* AL_SOFT_source_length */
1006     srcByteLength = AL_BYTE_LENGTH_SOFT,
1007     srcSampleLength = AL_SAMPLE_LENGTH_SOFT,
1008     srcSecLength = AL_SEC_LENGTH_SOFT,
1009
1010     /* AL_SOFT_source_resampler */
1011     srcResampler = AL_SOURCE_RESAMPLER_SOFT,
1012
1013     /* AL_SOFT_source_spatialize */
1014     srcSpatialize = AL_SOURCE_SPATIALIZE_SOFT,
1015
1016     /* ALC_SOFT_device_clock */
1017     srcSampleOffsetClockSOFT = AL_SAMPLE_OFFSET_CLOCK_SOFT,
1018     srcSecOffsetClockSOFT = AL_SEC_OFFSET_CLOCK_SOFT,
1019
1020     /* AL_SOFT_UHJ */
1021     srcStereoMode = AL_STEREO_MODE_SOFT,
1022     srcSuperStereoWidth = AL_SUPER_STEREO_WIDTH_SOFT,
1023
1024     /* AL_SOFT_buffer_sub_data */
1025     srcByteRWOffsetsSOFT = AL_BYTE_RW_OFFSETS_SOFT,
1026     srcSampleRWOffsetsSOFT = AL_SAMPLE_RW_OFFSETS_SOFT,
1027
1028     /* AL_SOFT_source_panning */
1029     srcPanningEnabledSOFT = AL_PANNING_ENABLED_SOFT,
1030     srcPanSOFT = AL_PAN_SOFT,
1031 };
1032
1033
1034 constexpr ALuint IntValsByProp(ALenum prop)
1035 {
1036     switch(static_cast<SourceProp>(prop))
1037     {
1038     case AL_SOURCE_STATE:
1039     case AL_SOURCE_TYPE:
1040     case AL_BUFFERS_QUEUED:
1041     case AL_BUFFERS_PROCESSED:
1042     case AL_BYTE_LENGTH_SOFT:
1043     case AL_SAMPLE_LENGTH_SOFT:
1044     case AL_SOURCE_RELATIVE:
1045     case AL_LOOPING:
1046     case AL_BUFFER:
1047     case AL_SAMPLE_OFFSET:
1048     case AL_BYTE_OFFSET:
1049     case AL_DIRECT_FILTER:
1050     case AL_DIRECT_FILTER_GAINHF_AUTO:
1051     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1052     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1053     case AL_DIRECT_CHANNELS_SOFT:
1054     case AL_DISTANCE_MODEL:
1055     case AL_SOURCE_RESAMPLER_SOFT:
1056     case AL_SOURCE_SPATIALIZE_SOFT:
1057     case AL_STEREO_MODE_SOFT:
1058     case AL_PANNING_ENABLED_SOFT:
1059     case AL_PAN_SOFT:
1060         return 1;
1061
1062     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
1063         if(sBufferSubDataCompat)
1064             return 2;
1065         /*fall-through*/
1066     case AL_CONE_INNER_ANGLE:
1067     case AL_CONE_OUTER_ANGLE:
1068     case AL_PITCH:
1069     case AL_GAIN:
1070     case AL_MIN_GAIN:
1071     case AL_MAX_GAIN:
1072     case AL_REFERENCE_DISTANCE:
1073     case AL_ROLLOFF_FACTOR:
1074     case AL_CONE_OUTER_GAIN:
1075     case AL_MAX_DISTANCE:
1076     case AL_SEC_OFFSET:
1077     case AL_DOPPLER_FACTOR:
1078     case AL_CONE_OUTER_GAINHF:
1079     case AL_AIR_ABSORPTION_FACTOR:
1080     case AL_ROOM_ROLLOFF_FACTOR:
1081     case AL_SEC_LENGTH_SOFT:
1082     case AL_SUPER_STEREO_WIDTH_SOFT:
1083         return 1; /* 1x float */
1084
1085     case AL_SAMPLE_RW_OFFSETS_SOFT:
1086         if(sBufferSubDataCompat)
1087             return 2;
1088         break;
1089
1090     case AL_AUXILIARY_SEND_FILTER:
1091         return 3;
1092
1093     case AL_POSITION:
1094     case AL_VELOCITY:
1095     case AL_DIRECTION:
1096         return 3; /* 3x float */
1097
1098     case AL_ORIENTATION:
1099         return 6; /* 6x float */
1100
1101     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1102     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1103     case AL_STEREO_ANGLES:
1104         break; /* i64 only */
1105     case AL_SEC_OFFSET_LATENCY_SOFT:
1106     case AL_SEC_OFFSET_CLOCK_SOFT:
1107         break; /* double only */
1108     }
1109
1110     return 0;
1111 }
1112
1113 constexpr ALuint Int64ValsByProp(ALenum prop)
1114 {
1115     switch(static_cast<SourceProp>(prop))
1116     {
1117     case AL_SOURCE_STATE:
1118     case AL_SOURCE_TYPE:
1119     case AL_BUFFERS_QUEUED:
1120     case AL_BUFFERS_PROCESSED:
1121     case AL_BYTE_LENGTH_SOFT:
1122     case AL_SAMPLE_LENGTH_SOFT:
1123     case AL_SOURCE_RELATIVE:
1124     case AL_LOOPING:
1125     case AL_BUFFER:
1126     case AL_SAMPLE_OFFSET:
1127     case AL_BYTE_OFFSET:
1128     case AL_DIRECT_FILTER:
1129     case AL_DIRECT_FILTER_GAINHF_AUTO:
1130     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1131     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1132     case AL_DIRECT_CHANNELS_SOFT:
1133     case AL_DISTANCE_MODEL:
1134     case AL_SOURCE_RESAMPLER_SOFT:
1135     case AL_SOURCE_SPATIALIZE_SOFT:
1136     case AL_STEREO_MODE_SOFT:
1137     case AL_PANNING_ENABLED_SOFT:
1138     case AL_PAN_SOFT:
1139         return 1;
1140
1141     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
1142         if(sBufferSubDataCompat)
1143             return 2;
1144         /*fall-through*/
1145     case AL_CONE_INNER_ANGLE:
1146     case AL_CONE_OUTER_ANGLE:
1147     case AL_PITCH:
1148     case AL_GAIN:
1149     case AL_MIN_GAIN:
1150     case AL_MAX_GAIN:
1151     case AL_REFERENCE_DISTANCE:
1152     case AL_ROLLOFF_FACTOR:
1153     case AL_CONE_OUTER_GAIN:
1154     case AL_MAX_DISTANCE:
1155     case AL_SEC_OFFSET:
1156     case AL_DOPPLER_FACTOR:
1157     case AL_CONE_OUTER_GAINHF:
1158     case AL_AIR_ABSORPTION_FACTOR:
1159     case AL_ROOM_ROLLOFF_FACTOR:
1160     case AL_SEC_LENGTH_SOFT:
1161     case AL_SUPER_STEREO_WIDTH_SOFT:
1162         return 1; /* 1x float */
1163
1164     case AL_SAMPLE_RW_OFFSETS_SOFT:
1165         if(sBufferSubDataCompat)
1166             return 2;
1167         break;
1168
1169     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1170     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1171     case AL_STEREO_ANGLES:
1172         return 2;
1173
1174     case AL_AUXILIARY_SEND_FILTER:
1175         return 3;
1176
1177     case AL_POSITION:
1178     case AL_VELOCITY:
1179     case AL_DIRECTION:
1180         return 3; /* 3x float */
1181
1182     case AL_ORIENTATION:
1183         return 6; /* 6x float */
1184
1185     case AL_SEC_OFFSET_LATENCY_SOFT:
1186     case AL_SEC_OFFSET_CLOCK_SOFT:
1187         break; /* double only */
1188     }
1189
1190     return 0;
1191 }
1192
1193 constexpr ALuint FloatValsByProp(ALenum prop)
1194 {
1195     switch(static_cast<SourceProp>(prop))
1196     {
1197     case AL_PITCH:
1198     case AL_GAIN:
1199     case AL_MIN_GAIN:
1200     case AL_MAX_GAIN:
1201     case AL_MAX_DISTANCE:
1202     case AL_ROLLOFF_FACTOR:
1203     case AL_DOPPLER_FACTOR:
1204     case AL_CONE_OUTER_GAIN:
1205     case AL_SEC_OFFSET:
1206     case AL_SAMPLE_OFFSET:
1207     case AL_BYTE_OFFSET:
1208     case AL_CONE_INNER_ANGLE:
1209     case AL_CONE_OUTER_ANGLE:
1210     case AL_REFERENCE_DISTANCE:
1211     case AL_CONE_OUTER_GAINHF:
1212     case AL_AIR_ABSORPTION_FACTOR:
1213     case AL_ROOM_ROLLOFF_FACTOR:
1214     case AL_DIRECT_FILTER_GAINHF_AUTO:
1215     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1216     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1217     case AL_DIRECT_CHANNELS_SOFT:
1218     case AL_DISTANCE_MODEL:
1219     case AL_SOURCE_RELATIVE:
1220     case AL_LOOPING:
1221     case AL_SOURCE_STATE:
1222     case AL_BUFFERS_QUEUED:
1223     case AL_BUFFERS_PROCESSED:
1224     case AL_SOURCE_TYPE:
1225     case AL_SOURCE_RESAMPLER_SOFT:
1226     case AL_SOURCE_SPATIALIZE_SOFT:
1227     case AL_BYTE_LENGTH_SOFT:
1228     case AL_SAMPLE_LENGTH_SOFT:
1229     case AL_SEC_LENGTH_SOFT:
1230     case AL_STEREO_MODE_SOFT:
1231     case AL_SUPER_STEREO_WIDTH_SOFT:
1232     case AL_PANNING_ENABLED_SOFT:
1233     case AL_PAN_SOFT:
1234         return 1;
1235
1236     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
1237         if(!sBufferSubDataCompat)
1238             return 1;
1239         /*fall-through*/
1240     case AL_SAMPLE_RW_OFFSETS_SOFT:
1241         break;
1242
1243     case AL_STEREO_ANGLES:
1244         return 2;
1245
1246     case AL_POSITION:
1247     case AL_VELOCITY:
1248     case AL_DIRECTION:
1249         return 3;
1250
1251     case AL_ORIENTATION:
1252         return 6;
1253
1254     case AL_SEC_OFFSET_LATENCY_SOFT:
1255     case AL_SEC_OFFSET_CLOCK_SOFT:
1256         break; /* Double only */
1257
1258     case AL_BUFFER:
1259     case AL_DIRECT_FILTER:
1260     case AL_AUXILIARY_SEND_FILTER:
1261         break; /* i/i64 only */
1262     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1263     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1264         break; /* i64 only */
1265     }
1266     return 0;
1267 }
1268 constexpr ALuint DoubleValsByProp(ALenum prop)
1269 {
1270     switch(static_cast<SourceProp>(prop))
1271     {
1272     case AL_PITCH:
1273     case AL_GAIN:
1274     case AL_MIN_GAIN:
1275     case AL_MAX_GAIN:
1276     case AL_MAX_DISTANCE:
1277     case AL_ROLLOFF_FACTOR:
1278     case AL_DOPPLER_FACTOR:
1279     case AL_CONE_OUTER_GAIN:
1280     case AL_SEC_OFFSET:
1281     case AL_SAMPLE_OFFSET:
1282     case AL_BYTE_OFFSET:
1283     case AL_CONE_INNER_ANGLE:
1284     case AL_CONE_OUTER_ANGLE:
1285     case AL_REFERENCE_DISTANCE:
1286     case AL_CONE_OUTER_GAINHF:
1287     case AL_AIR_ABSORPTION_FACTOR:
1288     case AL_ROOM_ROLLOFF_FACTOR:
1289     case AL_DIRECT_FILTER_GAINHF_AUTO:
1290     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1291     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1292     case AL_DIRECT_CHANNELS_SOFT:
1293     case AL_DISTANCE_MODEL:
1294     case AL_SOURCE_RELATIVE:
1295     case AL_LOOPING:
1296     case AL_SOURCE_STATE:
1297     case AL_BUFFERS_QUEUED:
1298     case AL_BUFFERS_PROCESSED:
1299     case AL_SOURCE_TYPE:
1300     case AL_SOURCE_RESAMPLER_SOFT:
1301     case AL_SOURCE_SPATIALIZE_SOFT:
1302     case AL_BYTE_LENGTH_SOFT:
1303     case AL_SAMPLE_LENGTH_SOFT:
1304     case AL_SEC_LENGTH_SOFT:
1305     case AL_STEREO_MODE_SOFT:
1306     case AL_SUPER_STEREO_WIDTH_SOFT:
1307     case AL_PANNING_ENABLED_SOFT:
1308     case AL_PAN_SOFT:
1309         return 1;
1310
1311     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
1312         if(!sBufferSubDataCompat)
1313             return 1;
1314         /*fall-through*/
1315     case AL_SAMPLE_RW_OFFSETS_SOFT:
1316         break;
1317
1318     case AL_SEC_OFFSET_LATENCY_SOFT:
1319     case AL_SEC_OFFSET_CLOCK_SOFT:
1320     case AL_STEREO_ANGLES:
1321         return 2;
1322
1323     case AL_POSITION:
1324     case AL_VELOCITY:
1325     case AL_DIRECTION:
1326         return 3;
1327
1328     case AL_ORIENTATION:
1329         return 6;
1330
1331     case AL_BUFFER:
1332     case AL_DIRECT_FILTER:
1333     case AL_AUXILIARY_SEND_FILTER:
1334         break; /* i/i64 only */
1335     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1336     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1337         break; /* i64 only */
1338     }
1339     return 0;
1340 }
1341
1342
1343 void UpdateSourceProps(ALsource *source, ALCcontext *context)
1344 {
1345     if(!context->mDeferUpdates)
1346     {
1347         if(Voice *voice{GetSourceVoice(source, context)})
1348         {
1349             UpdateSourceProps(source, voice, context);
1350             return;
1351         }
1352     }
1353     source->mPropsDirty = true;
1354 }
1355 #ifdef ALSOFT_EAX
1356 void CommitAndUpdateSourceProps(ALsource *source, ALCcontext *context)
1357 {
1358     if(!context->mDeferUpdates)
1359     {
1360         if(context->hasEax())
1361             source->eaxCommit();
1362         if(Voice *voice{GetSourceVoice(source, context)})
1363         {
1364             UpdateSourceProps(source, voice, context);
1365             return;
1366         }
1367     }
1368     source->mPropsDirty = true;
1369 }
1370
1371 #else
1372
1373 inline void CommitAndUpdateSourceProps(ALsource *source, ALCcontext *context)
1374 { UpdateSourceProps(source, context); }
1375 #endif
1376
1377
1378 template<typename T>
1379 struct PropType { };
1380 template<>
1381 struct PropType<ALint> { static const char *Name() { return "integer"; } };
1382 template<>
1383 struct PropType<ALint64SOFT> { static const char *Name() { return "int64"; } };
1384 template<>
1385 struct PropType<ALfloat> { static const char *Name() { return "float"; } };
1386 template<>
1387 struct PropType<ALdouble> { static const char *Name() { return "double"; } };
1388
1389 struct HexPrinter {
1390     std::array<char,32> mStr{};
1391
1392     template<typename T>
1393     HexPrinter(T value)
1394     {
1395         using ST = std::make_signed_t<std::remove_cv_t<T>>;
1396         if constexpr(std::is_same_v<ST,int>)
1397             std::snprintf(mStr.data(), mStr.size(), "0x%x", value);
1398         else if constexpr(std::is_same_v<ST,long>)
1399             std::snprintf(mStr.data(), mStr.size(), "0x%lx", value);
1400         else if constexpr(std::is_same_v<ST,long long>)
1401             std::snprintf(mStr.data(), mStr.size(), "0x%llx", value);
1402     }
1403
1404     [[nodiscard]] auto c_str() const noexcept -> const char* { return mStr.data(); }
1405 };
1406
1407
1408 /**
1409  * Returns a pair of lambdas to check the following setter.
1410  *
1411  * The first lambda checks the size of the span is valid for the required size,
1412  * throwing a context error if it fails.
1413  *
1414  * The second lambda tests the validity of the value check, throwing a context
1415  * error if it failed.
1416  */
1417 template<typename T, size_t N>
1418 auto GetCheckers(const SourceProp prop, const al::span<T,N> values)
1419 {
1420     return std::make_pair(
1421         [=](size_t expect) -> void
1422         {
1423             if(values.size() == expect) return;
1424             throw al::context_error{AL_INVALID_ENUM,
1425                 "Property 0x%04x expects %zu value(s), got %zu", prop, expect, values.size()};
1426         },
1427         [](bool passed) -> void
1428         {
1429             if(passed) return;
1430             throw al::context_error{AL_INVALID_VALUE, "Value out of range"};
1431         }
1432     );
1433 }
1434
1435 template<typename T>
1436 NOINLINE void SetProperty(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
1437     const al::span<const T> values)
1438 {
1439     auto [CheckSize, CheckValue] = GetCheckers(prop, values);
1440     ALCdevice *device{Context->mALDevice.get()};
1441
1442     switch(prop)
1443     {
1444     case AL_SOURCE_STATE:
1445     case AL_SOURCE_TYPE:
1446     case AL_BUFFERS_QUEUED:
1447     case AL_BUFFERS_PROCESSED:
1448         if constexpr(std::is_integral_v<T>)
1449         {
1450             /* Query only */
1451             throw al::context_error{AL_INVALID_OPERATION,
1452                 "Setting read-only source property 0x%04x", prop};
1453         }
1454         break;
1455
1456     case AL_BYTE_LENGTH_SOFT:
1457     case AL_SAMPLE_LENGTH_SOFT:
1458     case AL_SEC_LENGTH_SOFT:
1459     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1460     case AL_SEC_OFFSET_LATENCY_SOFT:
1461     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1462     case AL_SEC_OFFSET_CLOCK_SOFT:
1463         /* Query only */
1464         throw al::context_error{AL_INVALID_OPERATION, "Setting read-only source property 0x%04x",
1465             prop};
1466
1467     case AL_PITCH:
1468         CheckSize(1);
1469         if constexpr(std::is_floating_point_v<T>)
1470             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1471         else
1472             CheckValue(values[0] >= T{0});
1473
1474         Source->Pitch = static_cast<float>(values[0]);
1475         return UpdateSourceProps(Source, Context);
1476
1477     case AL_CONE_INNER_ANGLE:
1478         CheckSize(1);
1479         CheckValue(values[0] >= T{0} && values[0] <= T{360});
1480
1481         Source->InnerAngle = static_cast<float>(values[0]);
1482         return CommitAndUpdateSourceProps(Source, Context);
1483
1484     case AL_CONE_OUTER_ANGLE:
1485         CheckSize(1);
1486         CheckValue(values[0] >= T{0} && values[0] <= T{360});
1487
1488         Source->OuterAngle = static_cast<float>(values[0]);
1489         return CommitAndUpdateSourceProps(Source, Context);
1490
1491     case AL_GAIN:
1492         CheckSize(1);
1493         if constexpr(std::is_floating_point_v<T>)
1494             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1495         else
1496             CheckValue(values[0] >= T{0});
1497
1498         Source->Gain = static_cast<float>(values[0]);
1499         return UpdateSourceProps(Source, Context);
1500
1501     case AL_MAX_DISTANCE:
1502         CheckSize(1);
1503         if constexpr(std::is_floating_point_v<T>)
1504             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1505         else
1506             CheckValue(values[0] >= T{0});
1507
1508         Source->MaxDistance = static_cast<float>(values[0]);
1509         return CommitAndUpdateSourceProps(Source, Context);
1510
1511     case AL_ROLLOFF_FACTOR:
1512         CheckSize(1);
1513         if constexpr(std::is_floating_point_v<T>)
1514             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1515         else
1516             CheckValue(values[0] >= T{0});
1517
1518         Source->RolloffFactor = static_cast<float>(values[0]);
1519         return CommitAndUpdateSourceProps(Source, Context);
1520
1521     case AL_REFERENCE_DISTANCE:
1522         CheckSize(1);
1523         if constexpr(std::is_floating_point_v<T>)
1524             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1525         else
1526             CheckValue(values[0] >= T{0});
1527
1528         Source->RefDistance = static_cast<float>(values[0]);
1529         return CommitAndUpdateSourceProps(Source, Context);
1530
1531     case AL_MIN_GAIN:
1532         CheckSize(1);
1533         if constexpr(std::is_floating_point_v<T>)
1534             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1535         else
1536             CheckValue(values[0] >= T{0});
1537
1538         Source->MinGain = static_cast<float>(values[0]);
1539         return UpdateSourceProps(Source, Context);
1540
1541     case AL_MAX_GAIN:
1542         CheckSize(1);
1543         if constexpr(std::is_floating_point_v<T>)
1544             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1545         else
1546             CheckValue(values[0] >= T{0});
1547
1548         Source->MaxGain = static_cast<float>(values[0]);
1549         return UpdateSourceProps(Source, Context);
1550
1551     case AL_CONE_OUTER_GAIN:
1552         CheckSize(1);
1553         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1554
1555         Source->OuterGain = static_cast<float>(values[0]);
1556         return UpdateSourceProps(Source, Context);
1557
1558     case AL_CONE_OUTER_GAINHF:
1559         CheckSize(1);
1560         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1561
1562         Source->OuterGainHF = static_cast<float>(values[0]);
1563         return UpdateSourceProps(Source, Context);
1564
1565     case AL_AIR_ABSORPTION_FACTOR:
1566         CheckSize(1);
1567         CheckValue(values[0] >= T{0} && values[0] <= T{10});
1568
1569         Source->AirAbsorptionFactor = static_cast<float>(values[0]);
1570         return UpdateSourceProps(Source, Context);
1571
1572     case AL_ROOM_ROLLOFF_FACTOR:
1573         CheckSize(1);
1574         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1575
1576         Source->RoomRolloffFactor = static_cast<float>(values[0]);
1577         return UpdateSourceProps(Source, Context);
1578
1579     case AL_DOPPLER_FACTOR:
1580         CheckSize(1);
1581         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1582
1583         Source->DopplerFactor = static_cast<float>(values[0]);
1584         return UpdateSourceProps(Source, Context);
1585
1586
1587     case AL_SOURCE_RELATIVE:
1588         if constexpr(std::is_integral_v<T>)
1589         {
1590             CheckSize(1);
1591             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1592
1593             Source->HeadRelative = values[0] != AL_FALSE;
1594             return CommitAndUpdateSourceProps(Source, Context);
1595         }
1596         break;
1597
1598     case AL_LOOPING:
1599         if constexpr(std::is_integral_v<T>)
1600         {
1601             CheckSize(1);
1602             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1603
1604             Source->Looping = values[0] != AL_FALSE;
1605             if(Voice *voice{GetSourceVoice(Source, Context)})
1606             {
1607                 if(Source->Looping)
1608                     voice->mLoopBuffer.store(&Source->mQueue.front(), std::memory_order_release);
1609                 else
1610                     voice->mLoopBuffer.store(nullptr, std::memory_order_release);
1611
1612                 /* If the source is playing, wait for the current mix to finish
1613                  * to ensure it isn't currently looping back or reaching the
1614                  * end.
1615                  */
1616                 std::ignore = device->waitForMix();
1617             }
1618             return;
1619         }
1620         break;
1621
1622     case AL_BUFFER:
1623         if constexpr(std::is_integral_v<T>)
1624         {
1625             CheckSize(1);
1626             if(const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
1627                 state == AL_PLAYING || state == AL_PAUSED)
1628                 throw al::context_error{AL_INVALID_OPERATION,
1629                     "Setting buffer on playing or paused source %u", Source->id};
1630
1631             std::deque<ALbufferQueueItem> oldlist;
1632             if(values[0])
1633             {
1634                 using UT = std::make_unsigned_t<T>;
1635                 std::lock_guard<std::mutex> buflock{device->BufferLock};
1636                 ALbuffer *buffer{LookupBuffer(device, static_cast<UT>(values[0]))};
1637                 if(!buffer)
1638                     throw al::context_error{AL_INVALID_VALUE, "Invalid buffer ID %s",
1639                         std::to_string(values[0]).c_str()};
1640                 if(buffer->MappedAccess && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
1641                     throw al::context_error{AL_INVALID_OPERATION,
1642                         "Setting non-persistently mapped buffer %u", buffer->id};
1643                 if(buffer->mCallback && buffer->ref.load(std::memory_order_relaxed) != 0)
1644                     throw al::context_error{AL_INVALID_OPERATION,
1645                         "Setting already-set callback buffer %u", buffer->id};
1646
1647                 /* Add the selected buffer to a one-item queue */
1648                 std::deque<ALbufferQueueItem> newlist;
1649                 newlist.emplace_back();
1650                 newlist.back().mCallback = buffer->mCallback;
1651                 newlist.back().mUserData = buffer->mUserData;
1652                 newlist.back().mBlockAlign = buffer->mBlockAlign;
1653                 newlist.back().mSampleLen = buffer->mSampleLen;
1654                 newlist.back().mLoopStart = buffer->mLoopStart;
1655                 newlist.back().mLoopEnd = buffer->mLoopEnd;
1656                 newlist.back().mSamples = buffer->mData;
1657                 newlist.back().mBuffer = buffer;
1658                 IncrementRef(buffer->ref);
1659
1660                 /* Source is now Static */
1661                 Source->SourceType = AL_STATIC;
1662                 Source->mQueue.swap(oldlist);
1663                 Source->mQueue.swap(newlist);
1664             }
1665             else
1666             {
1667                 /* Source is now Undetermined */
1668                 Source->SourceType = AL_UNDETERMINED;
1669                 Source->mQueue.swap(oldlist);
1670             }
1671
1672             /* Delete all elements in the previous queue */
1673             for(auto &item : oldlist)
1674             {
1675                 if(ALbuffer *buffer{item.mBuffer})
1676                     DecrementRef(buffer->ref);
1677             }
1678             return;
1679         }
1680         break;
1681
1682
1683     case AL_SEC_OFFSET:
1684     case AL_SAMPLE_OFFSET:
1685     case AL_BYTE_OFFSET:
1686         CheckSize(1);
1687         if constexpr(std::is_floating_point_v<T>)
1688             CheckValue(std::isfinite(values[0]));
1689
1690         if(Voice *voice{GetSourceVoice(Source, Context)})
1691         {
1692             auto vpos = GetSampleOffset(Source->mQueue, prop, static_cast<double>(values[0]));
1693             if(!vpos) throw al::context_error{AL_INVALID_VALUE, "Invalid offset"};
1694
1695             if(SetVoiceOffset(voice, *vpos, Source, Context, Context->mALDevice.get()))
1696                 return;
1697         }
1698         Source->OffsetType = prop;
1699         Source->Offset = static_cast<double>(values[0]);
1700         return;
1701
1702     case AL_SAMPLE_RW_OFFSETS_SOFT:
1703         if(sBufferSubDataCompat)
1704         {
1705             if constexpr(std::is_integral_v<T>)
1706             {
1707                 /* Query only */
1708                 throw al::context_error{AL_INVALID_OPERATION,
1709                     "Setting read-only source property 0x%04x", prop};
1710             }
1711         }
1712         break;
1713
1714     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
1715         if(sBufferSubDataCompat)
1716         {
1717             if constexpr(std::is_integral_v<T>)
1718             {
1719                 /* Query only */
1720                 throw al::context_error{AL_INVALID_OPERATION,
1721                     "Setting read-only source property 0x%04x", prop};
1722             }
1723             break;
1724         }
1725         CheckSize(1);
1726         if constexpr(std::is_floating_point_v<T>)
1727             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1728         else
1729             CheckValue(values[0] >= T{0});
1730
1731         Source->Radius = static_cast<float>(values[0]);
1732         return UpdateSourceProps(Source, Context);
1733
1734     case AL_SUPER_STEREO_WIDTH_SOFT:
1735         CheckSize(1);
1736         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1737
1738         Source->EnhWidth = static_cast<float>(values[0]);
1739         return UpdateSourceProps(Source, Context);
1740
1741     case AL_PANNING_ENABLED_SOFT:
1742         CheckSize(1);
1743         if(const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
1744             state == AL_PLAYING || state == AL_PAUSED)
1745             throw al::context_error{AL_INVALID_OPERATION,
1746                 "Modifying panning enabled on playing or paused source %u", Source->id};
1747
1748         CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1749
1750         Source->mPanningEnabled = values[0] != AL_FALSE;
1751         return UpdateSourceProps(Source, Context);
1752
1753     case AL_PAN_SOFT:
1754         CheckSize(1);
1755         CheckValue(values[0] >= T{-1} && values[0] <= T{1});
1756
1757         Source->mPan = static_cast<float>(values[0]);
1758         return UpdateSourceProps(Source, Context);
1759
1760     case AL_STEREO_ANGLES:
1761         CheckSize(2);
1762         if constexpr(std::is_floating_point_v<T>)
1763             CheckValue(std::isfinite(static_cast<float>(values[0]))
1764                 && std::isfinite(static_cast<float>(values[1])));
1765
1766         Source->StereoPan[0] = static_cast<float>(values[0]);
1767         Source->StereoPan[1] = static_cast<float>(values[1]);
1768         return UpdateSourceProps(Source, Context);
1769
1770
1771     case AL_POSITION:
1772         CheckSize(3);
1773         if constexpr(std::is_floating_point_v<T>)
1774             CheckValue(std::isfinite(static_cast<float>(values[0]))
1775                 && std::isfinite(static_cast<float>(values[1]))
1776                 && std::isfinite(static_cast<float>(values[2])));
1777
1778         Source->Position[0] = static_cast<float>(values[0]);
1779         Source->Position[1] = static_cast<float>(values[1]);
1780         Source->Position[2] = static_cast<float>(values[2]);
1781         return CommitAndUpdateSourceProps(Source, Context);
1782
1783     case AL_VELOCITY:
1784         CheckSize(3);
1785         if constexpr(std::is_floating_point_v<T>)
1786             CheckValue(std::isfinite(static_cast<float>(values[0]))
1787                 && std::isfinite(static_cast<float>(values[1]))
1788                 && std::isfinite(static_cast<float>(values[2])));
1789
1790         Source->Velocity[0] = static_cast<float>(values[0]);
1791         Source->Velocity[1] = static_cast<float>(values[1]);
1792         Source->Velocity[2] = static_cast<float>(values[2]);
1793         return CommitAndUpdateSourceProps(Source, Context);
1794
1795     case AL_DIRECTION:
1796         CheckSize(3);
1797         if constexpr(std::is_floating_point_v<T>)
1798             CheckValue(std::isfinite(static_cast<float>(values[0]))
1799                 && std::isfinite(static_cast<float>(values[1]))
1800                 && std::isfinite(static_cast<float>(values[2])));
1801
1802         Source->Direction[0] = static_cast<float>(values[0]);
1803         Source->Direction[1] = static_cast<float>(values[1]);
1804         Source->Direction[2] = static_cast<float>(values[2]);
1805         return CommitAndUpdateSourceProps(Source, Context);
1806
1807     case AL_ORIENTATION:
1808         CheckSize(6);
1809         if constexpr(std::is_floating_point_v<T>)
1810             CheckValue(std::isfinite(static_cast<float>(values[0]))
1811                 && std::isfinite(static_cast<float>(values[1]))
1812                 && std::isfinite(static_cast<float>(values[2]))
1813                 && std::isfinite(static_cast<float>(values[3]))
1814                 && std::isfinite(static_cast<float>(values[4]))
1815                 && std::isfinite(static_cast<float>(values[5])));
1816
1817         Source->OrientAt[0] = static_cast<float>(values[0]);
1818         Source->OrientAt[1] = static_cast<float>(values[1]);
1819         Source->OrientAt[2] = static_cast<float>(values[2]);
1820         Source->OrientUp[0] = static_cast<float>(values[3]);
1821         Source->OrientUp[1] = static_cast<float>(values[4]);
1822         Source->OrientUp[2] = static_cast<float>(values[5]);
1823         return UpdateSourceProps(Source, Context);
1824
1825
1826     case AL_DIRECT_FILTER:
1827         if constexpr(std::is_integral_v<T>)
1828         {
1829             CheckSize(1);
1830             const auto filterid = static_cast<std::make_unsigned_t<T>>(values[0]);
1831             if(values[0])
1832             {
1833                 std::lock_guard<std::mutex> filterlock{device->FilterLock};
1834                 ALfilter *filter{LookupFilter(device, filterid)};
1835                 if(!filter)
1836                     throw al::context_error{AL_INVALID_VALUE, "Invalid filter ID %s",
1837                         std::to_string(filterid).c_str()};
1838                 Source->Direct.Gain = filter->Gain;
1839                 Source->Direct.GainHF = filter->GainHF;
1840                 Source->Direct.HFReference = filter->HFReference;
1841                 Source->Direct.GainLF = filter->GainLF;
1842                 Source->Direct.LFReference = filter->LFReference;
1843             }
1844             else
1845             {
1846                 Source->Direct.Gain = 1.0f;
1847                 Source->Direct.GainHF = 1.0f;
1848                 Source->Direct.HFReference = LowPassFreqRef;
1849                 Source->Direct.GainLF = 1.0f;
1850                 Source->Direct.LFReference = HighPassFreqRef;
1851             }
1852             return UpdateSourceProps(Source, Context);
1853         }
1854         break;
1855
1856     case AL_DIRECT_FILTER_GAINHF_AUTO:
1857         if constexpr(std::is_integral_v<T>)
1858         {
1859             CheckSize(1);
1860             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1861
1862             Source->DryGainHFAuto = values[0] != AL_FALSE;
1863             return UpdateSourceProps(Source, Context);
1864         }
1865         break;
1866
1867     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1868         if constexpr(std::is_integral_v<T>)
1869         {
1870             CheckSize(1);
1871             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1872
1873             Source->WetGainAuto = values[0] != AL_FALSE;
1874             return UpdateSourceProps(Source, Context);
1875         }
1876         break;
1877
1878     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1879         if constexpr(std::is_integral_v<T>)
1880         {
1881             CheckSize(1);
1882             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1883
1884             Source->WetGainHFAuto = values[0] != AL_FALSE;
1885             return UpdateSourceProps(Source, Context);
1886         }
1887         break;
1888
1889     case AL_DIRECT_CHANNELS_SOFT:
1890         if constexpr(std::is_integral_v<T>)
1891         {
1892             CheckSize(1);
1893             if(auto mode = DirectModeFromEnum(values[0]))
1894             {
1895                 Source->DirectChannels = *mode;
1896                 return UpdateSourceProps(Source, Context);
1897             }
1898             throw al::context_error{AL_INVALID_VALUE, "Invalid direct channels mode: %s\n",
1899                 HexPrinter{values[0]}.c_str()};
1900         }
1901         break;
1902
1903     case AL_DISTANCE_MODEL:
1904         if constexpr(std::is_integral_v<T>)
1905         {
1906             CheckSize(1);
1907             if(auto model = DistanceModelFromALenum(values[0]))
1908             {
1909                 Source->mDistanceModel = *model;
1910                 if(Context->mSourceDistanceModel)
1911                     UpdateSourceProps(Source, Context);
1912                 return;
1913             }
1914             throw al::context_error{AL_INVALID_VALUE, "Invalid distance model: %s\n",
1915                 HexPrinter{values[0]}.c_str()};
1916         }
1917         break;
1918
1919     case AL_SOURCE_RESAMPLER_SOFT:
1920         if constexpr(std::is_integral_v<T>)
1921         {
1922             CheckSize(1);
1923             CheckValue(values[0] >= 0 && values[0] <= static_cast<int>(Resampler::Max));
1924
1925             Source->mResampler = static_cast<Resampler>(values[0]);
1926             return UpdateSourceProps(Source, Context);
1927         }
1928         break;
1929
1930     case AL_SOURCE_SPATIALIZE_SOFT:
1931         if constexpr(std::is_integral_v<T>)
1932         {
1933             CheckSize(1);
1934             if(auto mode = SpatializeModeFromEnum(values[0]))
1935             {
1936                 Source->mSpatialize = *mode;
1937                 return UpdateSourceProps(Source, Context);
1938             }
1939             throw al::context_error{AL_INVALID_VALUE, "Invalid source spatialize mode: %s\n",
1940                 HexPrinter{values[0]}.c_str()};
1941         }
1942         break;
1943
1944     case AL_STEREO_MODE_SOFT:
1945         if constexpr(std::is_integral_v<T>)
1946         {
1947             CheckSize(1);
1948             if(const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
1949                 state == AL_PLAYING || state == AL_PAUSED)
1950                 throw al::context_error{AL_INVALID_OPERATION,
1951                     "Modifying stereo mode on playing or paused source %u", Source->id};
1952
1953             if(auto mode = StereoModeFromEnum(values[0]))
1954             {
1955                 Source->mStereoMode = *mode;
1956                 return;
1957             }
1958             throw al::context_error{AL_INVALID_VALUE, "Invalid stereo mode: %s\n",
1959                 HexPrinter{values[0]}.c_str()};
1960         }
1961         break;
1962
1963     case AL_AUXILIARY_SEND_FILTER:
1964         if constexpr(std::is_integral_v<T>)
1965         {
1966             CheckSize(3);
1967             const auto slotid = static_cast<std::make_unsigned_t<T>>(values[0]);
1968             const auto sendidx = static_cast<std::make_unsigned_t<T>>(values[1]);
1969             const auto filterid = static_cast<std::make_unsigned_t<T>>(values[2]);
1970
1971             std::unique_lock slotlock{Context->mEffectSlotLock};
1972             ALeffectslot *slot{};
1973             if(values[0])
1974             {
1975                 slot = LookupEffectSlot(Context, slotid);
1976                 if(!slot)
1977                     throw al::context_error{AL_INVALID_VALUE, "Invalid effect ID %s",
1978                         std::to_string(slotid).c_str()};
1979             }
1980
1981             if(sendidx >= device->NumAuxSends)
1982                 throw al::context_error{AL_INVALID_VALUE, "Invalid send %s",
1983                     std::to_string(sendidx).c_str()};
1984             auto &send = Source->Send[static_cast<size_t>(sendidx)];
1985
1986             if(values[2])
1987             {
1988                 std::lock_guard<std::mutex> filterlock{device->FilterLock};
1989                 ALfilter *filter{LookupFilter(device, filterid)};
1990                 if(!filter)
1991                     throw al::context_error{AL_INVALID_VALUE, "Invalid filter ID %s",
1992                         std::to_string(filterid).c_str()};
1993
1994                 send.Gain = filter->Gain;
1995                 send.GainHF = filter->GainHF;
1996                 send.HFReference = filter->HFReference;
1997                 send.GainLF = filter->GainLF;
1998                 send.LFReference = filter->LFReference;
1999             }
2000             else
2001             {
2002                 /* Disable filter */
2003                 send.Gain = 1.0f;
2004                 send.GainHF = 1.0f;
2005                 send.HFReference = LowPassFreqRef;
2006                 send.GainLF = 1.0f;
2007                 send.LFReference = HighPassFreqRef;
2008             }
2009
2010             /* We must force an update if the current auxiliary slot is valid
2011              * and about to be changed on an active source, in case the old
2012              * slot is about to be deleted.
2013              */
2014             if(send.Slot && slot != send.Slot && IsPlayingOrPaused(Source))
2015             {
2016                 /* Add refcount on the new slot, and release the previous slot */
2017                 if(slot) IncrementRef(slot->ref);
2018                 if(auto *oldslot = send.Slot)
2019                     DecrementRef(oldslot->ref);
2020                 send.Slot = slot;
2021
2022                 Voice *voice{GetSourceVoice(Source, Context)};
2023                 if(voice) UpdateSourceProps(Source, voice, Context);
2024                 else Source->mPropsDirty = true;
2025             }
2026             else
2027             {
2028                 if(slot) IncrementRef(slot->ref);
2029                 if(auto *oldslot = send.Slot)
2030                     DecrementRef(oldslot->ref);
2031                 send.Slot = slot;
2032                 UpdateSourceProps(Source, Context);
2033             }
2034             return;
2035         }
2036         break;
2037     }
2038
2039     ERR("Unexpected %s property: 0x%04x\n", PropType<T>::Name(), prop);
2040     throw al::context_error{AL_INVALID_ENUM, "Invalid source %s property 0x%04x",
2041         PropType<T>::Name(), prop};
2042 }
2043
2044
2045 template<typename T, size_t N>
2046 auto GetSizeChecker(const SourceProp prop, const al::span<T,N> values)
2047 {
2048     return [=](size_t expect) -> void
2049     {
2050         if(values.size() == expect) LIKELY return;
2051         throw al::context_error{AL_INVALID_ENUM, "Property 0x%04x expects %zu value(s), got %zu",
2052             prop, expect, values.size()};
2053     };
2054 }
2055
2056 template<typename T>
2057 NOINLINE void GetProperty(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
2058     const al::span<T> values)
2059 {
2060     using std::chrono::duration_cast;
2061     auto CheckSize = GetSizeChecker(prop, values);
2062     ALCdevice *device{Context->mALDevice.get()};
2063
2064     switch(prop)
2065     {
2066     case AL_GAIN:
2067         CheckSize(1);
2068         values[0] = static_cast<T>(Source->Gain);
2069         return;
2070
2071     case AL_PITCH:
2072         CheckSize(1);
2073         values[0] = static_cast<T>(Source->Pitch);
2074         return;
2075
2076     case AL_MAX_DISTANCE:
2077         CheckSize(1);
2078         values[0] = static_cast<T>(Source->MaxDistance);
2079         return;
2080
2081     case AL_ROLLOFF_FACTOR:
2082         CheckSize(1);
2083         values[0] = static_cast<T>(Source->RolloffFactor);
2084         return;
2085
2086     case AL_REFERENCE_DISTANCE:
2087         CheckSize(1);
2088         values[0] = static_cast<T>(Source->RefDistance);
2089         return;
2090
2091     case AL_CONE_INNER_ANGLE:
2092         CheckSize(1);
2093         values[0] = static_cast<T>(Source->InnerAngle);
2094         return;
2095
2096     case AL_CONE_OUTER_ANGLE:
2097         CheckSize(1);
2098         values[0] = static_cast<T>(Source->OuterAngle);
2099         return;
2100
2101     case AL_MIN_GAIN:
2102         CheckSize(1);
2103         values[0] = static_cast<T>(Source->MinGain);
2104         return;
2105
2106     case AL_MAX_GAIN:
2107         CheckSize(1);
2108         values[0] = static_cast<T>(Source->MaxGain);
2109         return;
2110
2111     case AL_CONE_OUTER_GAIN:
2112         CheckSize(1);
2113         values[0] = static_cast<T>(Source->OuterGain);
2114         return;
2115
2116     case AL_SEC_OFFSET:
2117     case AL_SAMPLE_OFFSET:
2118     case AL_BYTE_OFFSET:
2119         CheckSize(1);
2120         values[0] = GetSourceOffset<T>(Source, prop, Context);
2121         return;
2122
2123     case AL_CONE_OUTER_GAINHF:
2124         CheckSize(1);
2125         values[0] = static_cast<T>(Source->OuterGainHF);
2126         return;
2127
2128     case AL_AIR_ABSORPTION_FACTOR:
2129         CheckSize(1);
2130         values[0] = static_cast<T>(Source->AirAbsorptionFactor);
2131         return;
2132
2133     case AL_ROOM_ROLLOFF_FACTOR:
2134         CheckSize(1);
2135         values[0] = static_cast<T>(Source->RoomRolloffFactor);
2136         return;
2137
2138     case AL_DOPPLER_FACTOR:
2139         CheckSize(1);
2140         values[0] = static_cast<T>(Source->DopplerFactor);
2141         return;
2142
2143     case AL_SAMPLE_RW_OFFSETS_SOFT:
2144         if constexpr(std::is_integral_v<T>)
2145         {
2146             if(sBufferSubDataCompat)
2147             {
2148                 CheckSize(2);
2149                 values[0] = GetSourceOffset<T>(Source, AL_SAMPLE_OFFSET, Context);
2150                 /* FIXME: values[1] should be ahead of values[0] by the device
2151                  * update time. It needs to clamp or wrap the length of the
2152                  * buffer queue.
2153                  */
2154                 values[1] = values[0];
2155                 return;
2156             }
2157         }
2158         break;
2159     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
2160         if constexpr(std::is_floating_point_v<T>)
2161         {
2162             if(sBufferSubDataCompat)
2163                 break;
2164
2165             CheckSize(1);
2166             values[0] = static_cast<T>(Source->Radius);
2167             return;
2168         }
2169         else
2170         {
2171             if(sBufferSubDataCompat)
2172             {
2173                 CheckSize(2);
2174                 values[0] = GetSourceOffset<T>(Source, AL_BYTE_OFFSET, Context);
2175                 /* FIXME: values[1] should be ahead of values[0] by the device
2176                  * update time. It needs to clamp or wrap the length of the
2177                  * buffer queue.
2178                  */
2179                 values[1] = values[0];
2180                 return;
2181             }
2182             break;
2183         }
2184
2185     case AL_SUPER_STEREO_WIDTH_SOFT:
2186         CheckSize(1);
2187         values[0] = static_cast<T>(Source->EnhWidth);
2188         return;
2189
2190     case AL_BYTE_LENGTH_SOFT:
2191     case AL_SAMPLE_LENGTH_SOFT:
2192     case AL_SEC_LENGTH_SOFT:
2193         CheckSize(1);
2194         values[0] = GetSourceLength<T>(Source, prop);
2195         return;
2196
2197     case AL_PANNING_ENABLED_SOFT:
2198         CheckSize(1);
2199         values[0] = Source->mPanningEnabled;
2200         return;
2201
2202     case AL_PAN_SOFT:
2203         CheckSize(1);
2204         values[0] = static_cast<T>(Source->mPan);
2205         return;
2206
2207     case AL_STEREO_ANGLES:
2208         if constexpr(std::is_floating_point_v<T>)
2209         {
2210             CheckSize(2);
2211             values[0] = static_cast<T>(Source->StereoPan[0]);
2212             values[1] = static_cast<T>(Source->StereoPan[1]);
2213             return;
2214         }
2215         break;
2216
2217     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
2218         if constexpr(std::is_same_v<T,int64_t>)
2219         {
2220             CheckSize(2);
2221             /* Get the source offset with the clock time first. Then get the
2222              * clock time with the device latency. Order is important.
2223              */
2224             ClockLatency clocktime{};
2225             nanoseconds srcclock{};
2226             values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
2227             {
2228                 std::lock_guard<std::mutex> statelock{device->StateLock};
2229                 clocktime = GetClockLatency(device, device->Backend.get());
2230             }
2231             if(srcclock == clocktime.ClockTime)
2232                 values[1] = nanoseconds{clocktime.Latency}.count();
2233             else
2234             {
2235                 /* If the clock time incremented, reduce the latency by that
2236                  * much since it's that much closer to the source offset it got
2237                  * earlier.
2238                  */
2239                 const auto diff = std::min(clocktime.Latency, clocktime.ClockTime-srcclock);
2240                 values[1] = nanoseconds{clocktime.Latency - diff}.count();
2241             }
2242             return;
2243         }
2244         break;
2245
2246     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
2247         if constexpr(std::is_same_v<T,int64_t>)
2248         {
2249             CheckSize(2);
2250             nanoseconds srcclock{};
2251             values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
2252             values[1] = srcclock.count();
2253             return;
2254         }
2255         break;
2256
2257     case AL_SEC_OFFSET_LATENCY_SOFT:
2258         if constexpr(std::is_same_v<T,double>)
2259         {
2260             CheckSize(2);
2261             /* Get the source offset with the clock time first. Then get the
2262              * clock time with the device latency. Order is important.
2263              */
2264             ClockLatency clocktime{};
2265             nanoseconds srcclock{};
2266             values[0] = GetSourceSecOffset(Source, Context, &srcclock);
2267             {
2268                 std::lock_guard<std::mutex> statelock{device->StateLock};
2269                 clocktime = GetClockLatency(device, device->Backend.get());
2270             }
2271             if(srcclock == clocktime.ClockTime)
2272                 values[1] = duration_cast<seconds_d>(clocktime.Latency).count();
2273             else
2274             {
2275                 /* If the clock time incremented, reduce the latency by that
2276                  * much since it's that much closer to the source offset it got
2277                  * earlier.
2278                  */
2279                 const auto diff = std::min(clocktime.Latency, clocktime.ClockTime-srcclock);
2280                 values[1] = duration_cast<seconds_d>(clocktime.Latency - diff).count();
2281             }
2282             return;
2283         }
2284         break;
2285
2286     case AL_SEC_OFFSET_CLOCK_SOFT:
2287         if constexpr(std::is_same_v<T,double>)
2288         {
2289             CheckSize(2);
2290             nanoseconds srcclock{};
2291             values[0] = GetSourceSecOffset(Source, Context, &srcclock);
2292             values[1] = duration_cast<seconds_d>(srcclock).count();
2293             return;
2294         }
2295         break;
2296
2297     case AL_POSITION:
2298         CheckSize(3);
2299         values[0] = static_cast<T>(Source->Position[0]);
2300         values[1] = static_cast<T>(Source->Position[1]);
2301         values[2] = static_cast<T>(Source->Position[2]);
2302         return;
2303
2304     case AL_VELOCITY:
2305         CheckSize(3);
2306         values[0] = static_cast<T>(Source->Velocity[0]);
2307         values[1] = static_cast<T>(Source->Velocity[1]);
2308         values[2] = static_cast<T>(Source->Velocity[2]);
2309         return;
2310
2311     case AL_DIRECTION:
2312         CheckSize(3);
2313         values[0] = static_cast<T>(Source->Direction[0]);
2314         values[1] = static_cast<T>(Source->Direction[1]);
2315         values[2] = static_cast<T>(Source->Direction[2]);
2316         return;
2317
2318     case AL_ORIENTATION:
2319         CheckSize(6);
2320         values[0] = static_cast<T>(Source->OrientAt[0]);
2321         values[1] = static_cast<T>(Source->OrientAt[1]);
2322         values[2] = static_cast<T>(Source->OrientAt[2]);
2323         values[3] = static_cast<T>(Source->OrientUp[0]);
2324         values[4] = static_cast<T>(Source->OrientUp[1]);
2325         values[5] = static_cast<T>(Source->OrientUp[2]);
2326         return;
2327
2328
2329     case AL_SOURCE_RELATIVE:
2330         if constexpr(std::is_integral_v<T>)
2331         {
2332             CheckSize(1);
2333             values[0] = Source->HeadRelative;
2334             return;
2335         }
2336         break;
2337
2338     case AL_LOOPING:
2339         if constexpr(std::is_integral_v<T>)
2340         {
2341             CheckSize(1);
2342             values[0] = Source->Looping;
2343             return;
2344         }
2345         break;
2346
2347     case AL_BUFFER:
2348         if constexpr(std::is_integral_v<T>)
2349         {
2350             CheckSize(1);
2351             ALbufferQueueItem *BufferList{};
2352             /* HACK: This query should technically only return the buffer set
2353              * on a static source. However, some apps had used it to detect
2354              * when a streaming source changed buffers, so report the current
2355              * buffer's ID when playing.
2356              */
2357             if(Source->SourceType == AL_STATIC || Source->state == AL_INITIAL)
2358             {
2359                 if(!Source->mQueue.empty())
2360                     BufferList = &Source->mQueue.front();
2361             }
2362             else if(Voice *voice{GetSourceVoice(Source, Context)})
2363             {
2364                 VoiceBufferItem *Current{voice->mCurrentBuffer.load(std::memory_order_relaxed)};
2365                 BufferList = static_cast<ALbufferQueueItem*>(Current);
2366             }
2367             ALbuffer *buffer{BufferList ? BufferList->mBuffer : nullptr};
2368             values[0] = buffer ? static_cast<T>(buffer->id) : T{0};
2369             return;
2370         }
2371         break;
2372
2373     case AL_SOURCE_STATE:
2374         if constexpr(std::is_integral_v<T>)
2375         {
2376             CheckSize(1);
2377             values[0] = GetSourceState(Source, GetSourceVoice(Source, Context));
2378             return;
2379         }
2380         break;
2381
2382     case AL_BUFFERS_QUEUED:
2383         if constexpr(std::is_integral_v<T>)
2384         {
2385             CheckSize(1);
2386             values[0] = static_cast<T>(Source->mQueue.size());
2387             return;
2388         }
2389         break;
2390
2391     case AL_BUFFERS_PROCESSED:
2392         if constexpr(std::is_integral_v<T>)
2393         {
2394             CheckSize(1);
2395             if(Source->Looping || Source->SourceType != AL_STREAMING)
2396             {
2397                 /* Buffers on a looping source are in a perpetual state of
2398                  * PENDING, so don't report any as PROCESSED
2399                  */
2400                 values[0] = 0;
2401             }
2402             else
2403             {
2404                 int played{0};
2405                 if(Source->state != AL_INITIAL)
2406                 {
2407                     const VoiceBufferItem *Current{nullptr};
2408                     if(Voice *voice{GetSourceVoice(Source, Context)})
2409                         Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
2410                     for(auto &item : Source->mQueue)
2411                     {
2412                         if(&item == Current)
2413                             break;
2414                         ++played;
2415                     }
2416                 }
2417                 values[0] = played;
2418             }
2419             return;
2420         }
2421         break;
2422
2423     case AL_SOURCE_TYPE:
2424         if constexpr(std::is_integral_v<T>)
2425         {
2426             CheckSize(1);
2427             values[0] = Source->SourceType;
2428             return;
2429         }
2430         break;
2431
2432     case AL_DIRECT_FILTER_GAINHF_AUTO:
2433         if constexpr(std::is_integral_v<T>)
2434         {
2435             CheckSize(1);
2436             values[0] = Source->DryGainHFAuto;
2437             return;
2438         }
2439         break;
2440
2441     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
2442         if constexpr(std::is_integral_v<T>)
2443         {
2444             CheckSize(1);
2445             values[0] = Source->WetGainAuto;
2446             return;
2447         }
2448         break;
2449
2450     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
2451         if constexpr(std::is_integral_v<T>)
2452         {
2453             CheckSize(1);
2454             values[0] = Source->WetGainHFAuto;
2455             return;
2456         }
2457         break;
2458
2459     case AL_DIRECT_CHANNELS_SOFT:
2460         if constexpr(std::is_integral_v<T>)
2461         {
2462             CheckSize(1);
2463             values[0] = EnumFromDirectMode(Source->DirectChannels);
2464             return;
2465         }
2466         break;
2467
2468     case AL_DISTANCE_MODEL:
2469         if constexpr(std::is_integral_v<T>)
2470         {
2471             CheckSize(1);
2472             values[0] = ALenumFromDistanceModel(Source->mDistanceModel);
2473             return;
2474         }
2475         break;
2476
2477     case AL_SOURCE_RESAMPLER_SOFT:
2478         if constexpr(std::is_integral_v<T>)
2479         {
2480             CheckSize(1);
2481             values[0] = static_cast<T>(Source->mResampler);
2482             return;
2483         }
2484         break;
2485
2486     case AL_SOURCE_SPATIALIZE_SOFT:
2487         if constexpr(std::is_integral_v<T>)
2488         {
2489             CheckSize(1);
2490             values[0] = EnumFromSpatializeMode(Source->mSpatialize);
2491             return;
2492         }
2493         break;
2494
2495     case AL_STEREO_MODE_SOFT:
2496         if constexpr(std::is_integral_v<T>)
2497         {
2498             CheckSize(1);
2499             values[0] = EnumFromStereoMode(Source->mStereoMode);
2500             return;
2501         }
2502         break;
2503
2504     case AL_DIRECT_FILTER:
2505     case AL_AUXILIARY_SEND_FILTER:
2506         break;
2507     }
2508
2509     ERR("Unexpected %s query property: 0x%04x\n", PropType<T>::Name(), prop);
2510     throw al::context_error{AL_INVALID_ENUM, "Invalid source %s query property 0x%04x",
2511         PropType<T>::Name(), prop};
2512 }
2513
2514
2515 void StartSources(ALCcontext *const context, const al::span<ALsource*> srchandles,
2516     const nanoseconds start_time=nanoseconds::min())
2517 {
2518     ALCdevice *device{context->mALDevice.get()};
2519     /* If the device is disconnected, and voices stop on disconnect, go right
2520      * to stopped.
2521      */
2522     if(!device->Connected.load(std::memory_order_acquire)) UNLIKELY
2523     {
2524         if(context->mStopVoicesOnDisconnect.load(std::memory_order_acquire))
2525         {
2526             for(ALsource *source : srchandles)
2527             {
2528                 /* TODO: Send state change event? */
2529                 source->Offset = 0.0;
2530                 source->OffsetType = AL_NONE;
2531                 source->state = AL_STOPPED;
2532             }
2533             return;
2534         }
2535     }
2536
2537     /* Count the number of reusable voices. */
2538     auto voicelist = context->getVoicesSpan();
2539     size_t free_voices{0};
2540     for(const Voice *voice : voicelist)
2541     {
2542         free_voices += (voice->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
2543             && voice->mSourceID.load(std::memory_order_relaxed) == 0u
2544             && voice->mPendingChange.load(std::memory_order_relaxed) == false);
2545         if(free_voices == srchandles.size())
2546             break;
2547     }
2548     if(srchandles.size() != free_voices) UNLIKELY
2549     {
2550         const size_t inc_amount{srchandles.size() - free_voices};
2551         auto &allvoices = *context->mVoices.load(std::memory_order_relaxed);
2552         if(inc_amount > allvoices.size() - voicelist.size())
2553         {
2554             /* Increase the number of voices to handle the request. */
2555             context->allocVoices(inc_amount - (allvoices.size() - voicelist.size()));
2556         }
2557         context->mActiveVoiceCount.fetch_add(inc_amount, std::memory_order_release);
2558         voicelist = context->getVoicesSpan();
2559     }
2560
2561     auto voiceiter = voicelist.begin();
2562     ALuint vidx{0};
2563     VoiceChange *tail{}, *cur{};
2564     for(ALsource *source : srchandles)
2565     {
2566         /* Check that there is a queue containing at least one valid, non zero
2567          * length buffer.
2568          */
2569         auto find_buffer = [](ALbufferQueueItem &entry) noexcept
2570         { return entry.mSampleLen != 0 || entry.mCallback != nullptr; };
2571         auto BufferList = std::find_if(source->mQueue.begin(), source->mQueue.end(), find_buffer);
2572
2573         /* If there's nothing to play, go right to stopped. */
2574         if(BufferList == source->mQueue.end()) UNLIKELY
2575         {
2576             /* NOTE: A source without any playable buffers should not have a
2577              * Voice since it shouldn't be in a playing or paused state. So
2578              * there's no need to look up its voice and clear the source.
2579              */
2580             source->Offset = 0.0;
2581             source->OffsetType = AL_NONE;
2582             source->state = AL_STOPPED;
2583             continue;
2584         }
2585
2586         if(!cur)
2587             cur = tail = GetVoiceChanger(context);
2588         else
2589         {
2590             cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
2591             cur = cur->mNext.load(std::memory_order_relaxed);
2592         }
2593
2594         Voice *voice{GetSourceVoice(source, context)};
2595         switch(GetSourceState(source, voice))
2596         {
2597         case AL_PAUSED:
2598             /* A source that's paused simply resumes. If there's no voice, it
2599              * was lost from a disconnect, so just start over with a new one.
2600              */
2601             cur->mOldVoice = nullptr;
2602             if(!voice) break;
2603             cur->mVoice = voice;
2604             cur->mSourceID = source->id;
2605             cur->mState = VChangeState::Play;
2606             source->state = AL_PLAYING;
2607 #ifdef ALSOFT_EAX
2608             if(context->hasEax())
2609                 source->eaxCommit();
2610 #endif // ALSOFT_EAX
2611             continue;
2612
2613         case AL_PLAYING:
2614             /* A source that's already playing is restarted from the beginning.
2615              * Stop the current voice and start a new one so it properly cross-
2616              * fades back to the beginning.
2617              */
2618             if(voice)
2619                 voice->mPendingChange.store(true, std::memory_order_relaxed);
2620             cur->mOldVoice = voice;
2621             voice = nullptr;
2622             break;
2623
2624         default:
2625             assert(voice == nullptr);
2626             cur->mOldVoice = nullptr;
2627 #ifdef ALSOFT_EAX
2628             if(context->hasEax())
2629                 source->eaxCommit();
2630 #endif // ALSOFT_EAX
2631             break;
2632         }
2633
2634         /* Find the next unused voice to play this source with. */
2635         for(;voiceiter != voicelist.end();++voiceiter,++vidx)
2636         {
2637             Voice *v{*voiceiter};
2638             if(v->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
2639                 && v->mSourceID.load(std::memory_order_relaxed) == 0u
2640                 && v->mPendingChange.load(std::memory_order_relaxed) == false)
2641             {
2642                 voice = v;
2643                 break;
2644             }
2645         }
2646         ASSUME(voice != nullptr);
2647
2648         voice->mPosition.store(0, std::memory_order_relaxed);
2649         voice->mPositionFrac.store(0, std::memory_order_relaxed);
2650         voice->mCurrentBuffer.store(&source->mQueue.front(), std::memory_order_relaxed);
2651         voice->mStartTime = start_time;
2652         voice->mFlags.reset();
2653         /* A source that's not playing or paused has any offset applied when it
2654          * starts playing.
2655          */
2656         if(const ALenum offsettype{source->OffsetType})
2657         {
2658             const double offset{source->Offset};
2659             source->OffsetType = AL_NONE;
2660             source->Offset = 0.0;
2661             if(auto vpos = GetSampleOffset(source->mQueue, offsettype, offset))
2662             {
2663                 voice->mPosition.store(vpos->pos, std::memory_order_relaxed);
2664                 voice->mPositionFrac.store(vpos->frac, std::memory_order_relaxed);
2665                 voice->mCurrentBuffer.store(vpos->bufferitem, std::memory_order_relaxed);
2666                 if(vpos->pos > 0 || (vpos->pos == 0 && vpos->frac > 0)
2667                     || vpos->bufferitem != &source->mQueue.front())
2668                     voice->mFlags.set(VoiceIsFading);
2669             }
2670         }
2671         InitVoice(voice, source, al::to_address(BufferList), context, device);
2672
2673         source->VoiceIdx = vidx;
2674         source->state = AL_PLAYING;
2675
2676         cur->mVoice = voice;
2677         cur->mSourceID = source->id;
2678         cur->mState = VChangeState::Play;
2679     }
2680     if(tail) LIKELY
2681         SendVoiceChanges(context, tail);
2682 }
2683
2684 } // namespace
2685
2686 AL_API DECL_FUNC2(void, alGenSources, ALsizei,n, ALuint*,sources)
2687 FORCE_ALIGN void AL_APIENTRY alGenSourcesDirect(ALCcontext *context, ALsizei n, ALuint *sources) noexcept
2688 try {
2689     if(n < 0)
2690         throw al::context_error{AL_INVALID_VALUE, "Generating %d sources", n};
2691     if(n <= 0) UNLIKELY return;
2692
2693     std::unique_lock<std::mutex> srclock{context->mSourceLock};
2694     ALCdevice *device{context->mALDevice.get()};
2695
2696     const al::span sids{sources, static_cast<ALuint>(n)};
2697     if(sids.size() > device->SourcesMax-context->mNumSources)
2698         throw al::context_error{AL_OUT_OF_MEMORY, "Exceeding %u source limit (%u + %d)",
2699             device->SourcesMax, context->mNumSources, n};
2700     if(!EnsureSources(context, sids.size()))
2701         throw al::context_error{AL_OUT_OF_MEMORY, "Failed to allocate %d source%s", n,
2702             (n == 1) ? "" : "s"};
2703
2704     std::generate(sids.begin(), sids.end(), [context]{ return AllocSource(context)->id; });
2705 }
2706 catch(al::context_error& e) {
2707     context->setError(e.errorCode(), "%s", e.what());
2708 }
2709
2710 AL_API DECL_FUNC2(void, alDeleteSources, ALsizei,n, const ALuint*,sources)
2711 FORCE_ALIGN void AL_APIENTRY alDeleteSourcesDirect(ALCcontext *context, ALsizei n,
2712     const ALuint *sources) noexcept
2713 try {
2714     if(n < 0)
2715         throw al::context_error{AL_INVALID_VALUE, "Deleting %d sources", n};
2716     if(n <= 0) UNLIKELY return;
2717
2718     std::lock_guard<std::mutex> srclock{context->mSourceLock};
2719
2720     /* Check that all Sources are valid */
2721     auto validate_source = [context](const ALuint sid) -> bool
2722     { return LookupSource(context, sid) != nullptr; };
2723
2724     const al::span sids{sources, static_cast<ALuint>(n)};
2725     auto invsrc = std::find_if_not(sids.begin(), sids.end(), validate_source);
2726     if(invsrc != sids.end())
2727         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", *invsrc};
2728
2729     /* All good. Delete source IDs. */
2730     auto delete_source = [&context](const ALuint sid) -> void
2731     {
2732         if(ALsource *src{LookupSource(context, sid)})
2733             FreeSource(context, src);
2734     };
2735     std::for_each(sids.begin(), sids.end(), delete_source);
2736 }
2737 catch(al::context_error& e) {
2738     context->setError(e.errorCode(), "%s", e.what());
2739 }
2740
2741 AL_API DECL_FUNC1(ALboolean, alIsSource, ALuint,source)
2742 FORCE_ALIGN ALboolean AL_APIENTRY alIsSourceDirect(ALCcontext *context, ALuint source) noexcept
2743 {
2744     std::lock_guard<std::mutex> srclock{context->mSourceLock};
2745     if(LookupSource(context, source) != nullptr)
2746         return AL_TRUE;
2747     return AL_FALSE;
2748 }
2749
2750
2751 AL_API DECL_FUNC3(void, alSourcef, ALuint,source, ALenum,param, ALfloat,value)
2752 FORCE_ALIGN void AL_APIENTRY alSourcefDirect(ALCcontext *context, ALuint source, ALenum param,
2753     ALfloat value) noexcept
2754 try {
2755     std::lock_guard<std::mutex> proplock{context->mPropLock};
2756     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2757     ALsource *Source{LookupSource(context, source)};
2758     if(!Source)
2759         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2760
2761     SetProperty<float>(Source, context, static_cast<SourceProp>(param), {&value, 1u});
2762 }
2763 catch(al::context_error& e) {
2764     context->setError(e.errorCode(), "%s", e.what());
2765 }
2766
2767 AL_API DECL_FUNC5(void, alSource3f, ALuint,source, ALenum,param, ALfloat,value1, ALfloat,value2, ALfloat,value3)
2768 FORCE_ALIGN void AL_APIENTRY alSource3fDirect(ALCcontext *context, ALuint source, ALenum param,
2769     ALfloat value1, ALfloat value2, ALfloat value3) noexcept
2770 try {
2771     std::lock_guard<std::mutex> proplock{context->mPropLock};
2772     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2773     ALsource *Source{LookupSource(context, source)};
2774     if(!Source)
2775         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2776
2777     const std::array fvals{value1, value2, value3};
2778     SetProperty<float>(Source, context, static_cast<SourceProp>(param), fvals);
2779 }
2780 catch(al::context_error& e) {
2781     context->setError(e.errorCode(), "%s", e.what());
2782 }
2783
2784 AL_API DECL_FUNC3(void, alSourcefv, ALuint,source, ALenum,param, const ALfloat*,values)
2785 FORCE_ALIGN void AL_APIENTRY alSourcefvDirect(ALCcontext *context, ALuint source, ALenum param,
2786     const ALfloat *values) noexcept
2787 try {
2788     std::lock_guard<std::mutex> proplock{context->mPropLock};
2789     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2790     ALsource *Source{LookupSource(context, source)};
2791     if(!Source)
2792         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2793     if(!values)
2794         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2795
2796     const ALuint count{FloatValsByProp(param)};
2797     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2798 }
2799 catch(al::context_error& e) {
2800     context->setError(e.errorCode(), "%s", e.what());
2801 }
2802
2803
2804 AL_API DECL_FUNCEXT3(void, alSourced,SOFT, ALuint,source, ALenum,param, ALdouble,value)
2805 FORCE_ALIGN void AL_APIENTRY alSourcedDirectSOFT(ALCcontext *context, ALuint source, ALenum param,
2806     ALdouble value) noexcept
2807 try {
2808     std::lock_guard<std::mutex> proplock{context->mPropLock};
2809     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2810     ALsource *Source{LookupSource(context, source)};
2811     if(!Source)
2812         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2813
2814     SetProperty<double>(Source, context, static_cast<SourceProp>(param), {&value, 1});
2815 }
2816 catch(al::context_error& e) {
2817     context->setError(e.errorCode(), "%s", e.what());
2818 }
2819
2820 AL_API DECL_FUNCEXT5(void, alSource3d,SOFT, ALuint,source, ALenum,param, ALdouble,value1, ALdouble,value2, ALdouble,value3)
2821 FORCE_ALIGN void AL_APIENTRY alSource3dDirectSOFT(ALCcontext *context, ALuint source, ALenum param,
2822     ALdouble value1, ALdouble value2, ALdouble value3) noexcept
2823 try {
2824     std::lock_guard<std::mutex> proplock{context->mPropLock};
2825     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2826     ALsource *Source{LookupSource(context, source)};
2827     if(!Source)
2828         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2829
2830     const std::array dvals{value1, value2, value3};
2831     SetProperty<double>(Source, context, static_cast<SourceProp>(param), dvals);
2832 }
2833 catch(al::context_error& e) {
2834     context->setError(e.errorCode(), "%s", e.what());
2835 }
2836
2837 AL_API DECL_FUNCEXT3(void, alSourcedv,SOFT, ALuint,source, ALenum,param, const ALdouble*,values)
2838 FORCE_ALIGN void AL_APIENTRY alSourcedvDirectSOFT(ALCcontext *context, ALuint source, ALenum param,
2839     const ALdouble *values) noexcept
2840 try {
2841     std::lock_guard<std::mutex> proplock{context->mPropLock};
2842     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2843     ALsource *Source{LookupSource(context, source)};
2844     if(!Source)
2845         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2846     if(!values)
2847         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2848
2849     const ALuint count{DoubleValsByProp(param)};
2850     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2851 }
2852 catch(al::context_error& e) {
2853     context->setError(e.errorCode(), "%s", e.what());
2854 }
2855
2856
2857 AL_API DECL_FUNC3(void, alSourcei, ALuint,source, ALenum,param, ALint,value)
2858 FORCE_ALIGN void AL_APIENTRY alSourceiDirect(ALCcontext *context, ALuint source, ALenum param,
2859     ALint value) noexcept
2860 try {
2861     std::lock_guard<std::mutex> proplock{context->mPropLock};
2862     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2863     ALsource *Source{LookupSource(context, source)};
2864     if(!Source)
2865         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2866
2867     SetProperty<int>(Source, context, static_cast<SourceProp>(param), {&value, 1u});
2868 }
2869 catch(al::context_error& e) {
2870     context->setError(e.errorCode(), "%s", e.what());
2871 }
2872
2873 AL_API DECL_FUNC5(void, alSource3i, ALuint,buffer, ALenum,param, ALint,value1, ALint,value2, ALint,value3)
2874 FORCE_ALIGN void AL_APIENTRY alSource3iDirect(ALCcontext *context, ALuint source, ALenum param,
2875     ALint value1, ALint value2, ALint value3) noexcept
2876 try {
2877     std::lock_guard<std::mutex> proplock{context->mPropLock};
2878     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2879     ALsource *Source{LookupSource(context, source)};
2880     if(!Source)
2881         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2882
2883     const std::array ivals{value1, value2, value3};
2884     SetProperty<int>(Source, context, static_cast<SourceProp>(param), ivals);
2885 }
2886 catch(al::context_error& e) {
2887     context->setError(e.errorCode(), "%s", e.what());
2888 }
2889
2890 AL_API DECL_FUNC3(void, alSourceiv, ALuint,source, ALenum,param, const ALint*,values)
2891 FORCE_ALIGN void AL_APIENTRY alSourceivDirect(ALCcontext *context, ALuint source, ALenum param,
2892     const ALint *values) noexcept
2893 try {
2894     std::lock_guard<std::mutex> proplock{context->mPropLock};
2895     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2896     ALsource *Source{LookupSource(context, source)};
2897     if(!Source)
2898         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2899     if(!values)
2900         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2901
2902     const ALuint count{IntValsByProp(param)};
2903     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2904 }
2905 catch(al::context_error& e) {
2906     context->setError(e.errorCode(), "%s", e.what());
2907 }
2908
2909
2910 AL_API DECL_FUNCEXT3(void, alSourcei64,SOFT, ALuint,source, ALenum,param, ALint64SOFT,value)
2911 FORCE_ALIGN void AL_APIENTRY alSourcei64DirectSOFT(ALCcontext *context, ALuint source,
2912     ALenum param, ALint64SOFT value) noexcept
2913 try {
2914     std::lock_guard<std::mutex> proplock{context->mPropLock};
2915     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2916     ALsource *Source{LookupSource(context, source)};
2917     if(!Source)
2918         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2919
2920     SetProperty<int64_t>(Source, context, static_cast<SourceProp>(param), {&value, 1u});
2921 }
2922 catch(al::context_error& e) {
2923     context->setError(e.errorCode(), "%s", e.what());
2924 }
2925
2926 AL_API DECL_FUNCEXT5(void, alSource3i64,SOFT, ALuint,source, ALenum,param, ALint64SOFT,value1, ALint64SOFT,value2, ALint64SOFT,value3)
2927 FORCE_ALIGN void AL_APIENTRY alSource3i64DirectSOFT(ALCcontext *context, ALuint source,
2928     ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3) noexcept
2929 try {
2930     std::lock_guard<std::mutex> proplock{context->mPropLock};
2931     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2932     ALsource *Source{LookupSource(context, source)};
2933     if(!Source)
2934         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2935
2936     const std::array i64vals{value1, value2, value3};
2937     SetProperty<int64_t>(Source, context, static_cast<SourceProp>(param), i64vals);
2938 }
2939 catch(al::context_error& e) {
2940     context->setError(e.errorCode(), "%s", e.what());
2941 }
2942
2943 AL_API DECL_FUNCEXT3(void, alSourcei64v,SOFT, ALuint,source, ALenum,param, const ALint64SOFT*,values)
2944 FORCE_ALIGN void AL_APIENTRY alSourcei64vDirectSOFT(ALCcontext *context, ALuint source,
2945     ALenum param, const ALint64SOFT *values) noexcept
2946 try {
2947     std::lock_guard<std::mutex> proplock{context->mPropLock};
2948     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2949     ALsource *Source{LookupSource(context, source)};
2950     if(!Source)
2951         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2952     if(!values)
2953         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2954
2955     const ALuint count{Int64ValsByProp(param)};
2956     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2957 }
2958 catch(al::context_error& e) {
2959     context->setError(e.errorCode(), "%s", e.what());
2960 }
2961
2962
2963 AL_API DECL_FUNC3(void, alGetSourcef, ALuint,source, ALenum,param, ALfloat*,value)
2964 FORCE_ALIGN void AL_APIENTRY alGetSourcefDirect(ALCcontext *context, ALuint source, ALenum param,
2965     ALfloat *value) noexcept
2966 try {
2967     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2968     ALsource *Source{LookupSource(context, source)};
2969     if(!Source)
2970         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2971     if(!value)
2972         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2973
2974     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
2975 }
2976 catch(al::context_error& e) {
2977     context->setError(e.errorCode(), "%s", e.what());
2978 }
2979
2980 AL_API DECL_FUNC5(void, alGetSource3f, ALuint,source, ALenum,param, ALfloat*,value1, ALfloat*,value2, ALfloat*,value3)
2981 FORCE_ALIGN void AL_APIENTRY alGetSource3fDirect(ALCcontext *context, ALuint source, ALenum param,
2982     ALfloat *value1, ALfloat *value2, ALfloat *value3) noexcept
2983 try {
2984     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2985     ALsource *Source{LookupSource(context, source)};
2986     if(!Source)
2987         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2988     if(!(value1 && value2 && value3))
2989         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2990
2991     std::array<float,3> fvals{};
2992     GetProperty<float>(Source, context, static_cast<SourceProp>(param), fvals);
2993     *value1 = fvals[0];
2994     *value2 = fvals[1];
2995     *value3 = fvals[2];
2996 }
2997 catch(al::context_error& e) {
2998     context->setError(e.errorCode(), "%s", e.what());
2999 }
3000
3001 AL_API DECL_FUNC3(void, alGetSourcefv, ALuint,source, ALenum,param, ALfloat*,values)
3002 FORCE_ALIGN void AL_APIENTRY alGetSourcefvDirect(ALCcontext *context, ALuint source, ALenum param,
3003     ALfloat *values) noexcept
3004 try {
3005     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3006     ALsource *Source{LookupSource(context, source)};
3007     if(!Source)
3008         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3009     if(!values)
3010         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3011
3012     const ALuint count{FloatValsByProp(param)};
3013     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
3014 }
3015 catch(al::context_error& e) {
3016     context->setError(e.errorCode(), "%s", e.what());
3017 }
3018
3019
3020 AL_API DECL_FUNCEXT3(void, alGetSourced,SOFT, ALuint,source, ALenum,param, ALdouble*,value)
3021 FORCE_ALIGN void AL_APIENTRY alGetSourcedDirectSOFT(ALCcontext *context, ALuint source,
3022     ALenum param, ALdouble *value) noexcept
3023 try {
3024     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3025     ALsource *Source{LookupSource(context, source)};
3026     if(!Source)
3027         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3028     if(!value)
3029         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3030
3031     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
3032 }
3033 catch(al::context_error& e) {
3034     context->setError(e.errorCode(), "%s", e.what());
3035 }
3036
3037 AL_API DECL_FUNCEXT5(void, alGetSource3d,SOFT, ALuint,source, ALenum,param, ALdouble*,value1, ALdouble*,value2, ALdouble*,value3)
3038 FORCE_ALIGN void AL_APIENTRY alGetSource3dDirectSOFT(ALCcontext *context, ALuint source,
3039     ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3) noexcept
3040 try {
3041     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3042     ALsource *Source{LookupSource(context, source)};
3043     if(!Source)
3044         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3045     if(!(value1 && value2 && value3))
3046         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3047
3048     std::array<double,3> dvals{};
3049     GetProperty<double>(Source, context, static_cast<SourceProp>(param), dvals);
3050     *value1 = dvals[0];
3051     *value2 = dvals[1];
3052     *value3 = dvals[2];
3053 }
3054 catch(al::context_error& e) {
3055     context->setError(e.errorCode(), "%s", e.what());
3056 }
3057
3058 AL_API DECL_FUNCEXT3(void, alGetSourcedv,SOFT, ALuint,source, ALenum,param, ALdouble*,values)
3059 FORCE_ALIGN void AL_APIENTRY alGetSourcedvDirectSOFT(ALCcontext *context, ALuint source,
3060     ALenum param, ALdouble *values) noexcept
3061 try {
3062     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3063     ALsource *Source{LookupSource(context, source)};
3064     if(!Source)
3065         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3066     if(!values)
3067         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3068
3069     const ALuint count{DoubleValsByProp(param)};
3070     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
3071 }
3072 catch(al::context_error& e) {
3073     context->setError(e.errorCode(), "%s", e.what());
3074 }
3075
3076
3077 AL_API DECL_FUNC3(void, alGetSourcei, ALuint,source, ALenum,param, ALint*,value)
3078 FORCE_ALIGN void AL_APIENTRY alGetSourceiDirect(ALCcontext *context, ALuint source, ALenum param,
3079     ALint *value) noexcept
3080 try {
3081     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3082     ALsource *Source{LookupSource(context, source)};
3083     if(!Source)
3084         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3085     if(!value)
3086         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3087
3088     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
3089 }
3090 catch(al::context_error& e) {
3091     context->setError(e.errorCode(), "%s", e.what());
3092 }
3093
3094 AL_API DECL_FUNC5(void, alGetSource3i, ALuint,source, ALenum,param, ALint*,value1, ALint*,value2, ALint*,value3)
3095 FORCE_ALIGN void AL_APIENTRY alGetSource3iDirect(ALCcontext *context, ALuint source, ALenum param,
3096     ALint *value1, ALint *value2, ALint *value3) noexcept
3097 try {
3098     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3099     ALsource *Source{LookupSource(context, source)};
3100     if(!Source)
3101         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3102     if(!(value1 && value2 && value3))
3103         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3104
3105     std::array<int,3> ivals{};
3106     GetProperty<int>(Source, context, static_cast<SourceProp>(param), ivals);
3107     *value1 = ivals[0];
3108     *value2 = ivals[1];
3109     *value3 = ivals[2];
3110 }
3111 catch(al::context_error& e) {
3112     context->setError(e.errorCode(), "%s", e.what());
3113 }
3114
3115 AL_API DECL_FUNC3(void, alGetSourceiv, ALuint,source, ALenum,param, ALint*,values)
3116 FORCE_ALIGN void AL_APIENTRY alGetSourceivDirect(ALCcontext *context, ALuint source, ALenum param,
3117     ALint *values) noexcept
3118 try {
3119     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3120     ALsource *Source{LookupSource(context, source)};
3121     if(!Source)
3122         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3123     if(!values)
3124         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3125
3126     const ALuint count{IntValsByProp(param)};
3127     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
3128 }
3129 catch(al::context_error& e) {
3130     context->setError(e.errorCode(), "%s", e.what());
3131 }
3132
3133
3134 AL_API DECL_FUNCEXT3(void, alGetSourcei64,SOFT, ALuint,source, ALenum,param, ALint64SOFT*,value)
3135 FORCE_ALIGN void AL_APIENTRY alGetSourcei64DirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALint64SOFT *value) noexcept
3136 try {
3137     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3138     ALsource *Source{LookupSource(context, source)};
3139     if(!Source)
3140         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3141     if(!value)
3142         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3143
3144     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
3145 }
3146 catch(al::context_error& e) {
3147     context->setError(e.errorCode(), "%s", e.what());
3148 }
3149
3150 AL_API DECL_FUNCEXT5(void, alGetSource3i64,SOFT, ALuint,source, ALenum,param, ALint64SOFT*,value1, ALint64SOFT*,value2, ALint64SOFT*,value3)
3151 FORCE_ALIGN void AL_APIENTRY alGetSource3i64DirectSOFT(ALCcontext *context, ALuint source,
3152     ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3) noexcept
3153 try {
3154     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3155     ALsource *Source{LookupSource(context, source)};
3156     if(!Source)
3157         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3158     if(!(value1 && value2 && value3))
3159         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3160
3161     std::array<int64_t,3> i64vals{};
3162     GetProperty<int64_t>(Source, context, static_cast<SourceProp>(param), i64vals);
3163     *value1 = i64vals[0];
3164     *value2 = i64vals[1];
3165     *value3 = i64vals[2];
3166 }
3167 catch(al::context_error& e) {
3168     context->setError(e.errorCode(), "%s", e.what());
3169 }
3170
3171 AL_API DECL_FUNCEXT3(void, alGetSourcei64v,SOFT, ALuint,source, ALenum,param, ALint64SOFT*,values)
3172 FORCE_ALIGN void AL_APIENTRY alGetSourcei64vDirectSOFT(ALCcontext *context, ALuint source,
3173     ALenum param, ALint64SOFT *values) noexcept
3174 try {
3175     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3176     ALsource *Source{LookupSource(context, source)};
3177     if(!Source)
3178         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3179     if(!values)
3180         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3181
3182     const ALuint count{Int64ValsByProp(param)};
3183     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
3184 }
3185 catch(al::context_error& e) {
3186     context->setError(e.errorCode(), "%s", e.what());
3187 }
3188
3189
3190 AL_API DECL_FUNC1(void, alSourcePlay, ALuint,source)
3191 FORCE_ALIGN void AL_APIENTRY alSourcePlayDirect(ALCcontext *context, ALuint source) noexcept
3192 try {
3193     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3194     ALsource *Source{LookupSource(context, source)};
3195     if(!Source)
3196         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3197
3198     StartSources(context, {&Source, 1});
3199 }
3200 catch(al::context_error& e) {
3201     context->setError(e.errorCode(), "%s", e.what());
3202 }
3203
3204 FORCE_ALIGN DECL_FUNCEXT2(void, alSourcePlayAtTime,SOFT, ALuint,source, ALint64SOFT,start_time)
3205 FORCE_ALIGN void AL_APIENTRY alSourcePlayAtTimeDirectSOFT(ALCcontext *context, ALuint source,
3206     ALint64SOFT start_time) noexcept
3207 try {
3208     if(start_time < 0)
3209         throw al::context_error{AL_INVALID_VALUE, "Invalid time point %" PRId64, start_time};
3210
3211     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3212     ALsource *Source{LookupSource(context, source)};
3213     if(!Source)
3214         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3215
3216     StartSources(context, {&Source, 1}, nanoseconds{start_time});
3217 }
3218 catch(al::context_error& e) {
3219     context->setError(e.errorCode(), "%s", e.what());
3220 }
3221
3222 AL_API DECL_FUNC2(void, alSourcePlayv, ALsizei,n, const ALuint*,sources)
3223 FORCE_ALIGN void AL_APIENTRY alSourcePlayvDirect(ALCcontext *context, ALsizei n,
3224     const ALuint *sources) noexcept
3225 try {
3226     if(n < 0)
3227         throw al::context_error{AL_INVALID_VALUE, "Playing %d sources", n};
3228     if(n <= 0) UNLIKELY return;
3229
3230     al::span sids{sources, static_cast<ALuint>(n)};
3231     source_store_variant source_store;
3232     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3233     {
3234         if(count > std::tuple_size_v<source_store_array>)
3235             return al::span{source_store.emplace<source_store_vector>(count)};
3236         return al::span{source_store.emplace<source_store_array>()}.first(count);
3237     }(sids.size());
3238
3239     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3240     auto lookup_src = [context](const ALuint sid) -> ALsource*
3241     {
3242         if(ALsource *src{LookupSource(context, sid)})
3243             return src;
3244         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3245     };
3246     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3247
3248     StartSources(context, srchandles);
3249 }
3250 catch(al::context_error& e) {
3251     context->setError(e.errorCode(), "%s", e.what());
3252 }
3253
3254 FORCE_ALIGN DECL_FUNCEXT3(void, alSourcePlayAtTimev,SOFT, ALsizei,n, const ALuint*,sources, ALint64SOFT,start_time)
3255 FORCE_ALIGN void AL_APIENTRY alSourcePlayAtTimevDirectSOFT(ALCcontext *context, ALsizei n,
3256     const ALuint *sources, ALint64SOFT start_time) noexcept
3257 try {
3258     if(n < 0)
3259         throw al::context_error{AL_INVALID_VALUE, "Playing %d sources", n};
3260     if(n <= 0) UNLIKELY return;
3261
3262     if(start_time < 0)
3263         throw al::context_error{AL_INVALID_VALUE, "Invalid time point %" PRId64, start_time};
3264
3265     al::span sids{sources, static_cast<ALuint>(n)};
3266     source_store_variant source_store;
3267     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3268     {
3269         if(count > std::tuple_size_v<source_store_array>)
3270             return al::span{source_store.emplace<source_store_vector>(count)};
3271         return al::span{source_store.emplace<source_store_array>()}.first(count);
3272     }(sids.size());
3273
3274     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3275     auto lookup_src = [context](const ALuint sid) -> ALsource*
3276     {
3277         if(ALsource *src{LookupSource(context, sid)})
3278             return src;
3279         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3280     };
3281     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3282
3283     StartSources(context, srchandles, nanoseconds{start_time});
3284 }
3285 catch(al::context_error& e) {
3286     context->setError(e.errorCode(), "%s", e.what());
3287 }
3288
3289
3290 AL_API DECL_FUNC1(void, alSourcePause, ALuint,source)
3291 FORCE_ALIGN void AL_APIENTRY alSourcePauseDirect(ALCcontext *context, ALuint source) noexcept
3292 { alSourcePausevDirect(context, 1, &source); }
3293
3294 AL_API DECL_FUNC2(void, alSourcePausev, ALsizei,n, const ALuint*,sources)
3295 FORCE_ALIGN void AL_APIENTRY alSourcePausevDirect(ALCcontext *context, ALsizei n,
3296     const ALuint *sources) noexcept
3297 try {
3298     if(n < 0)
3299         throw al::context_error{AL_INVALID_VALUE, "Pausing %d sources", n};
3300     if(n <= 0) UNLIKELY return;
3301
3302     al::span sids{sources, static_cast<ALuint>(n)};
3303     source_store_variant source_store;
3304     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3305     {
3306         if(count > std::tuple_size_v<source_store_array>)
3307             return al::span{source_store.emplace<source_store_vector>(count)};
3308         return al::span{source_store.emplace<source_store_array>()}.first(count);
3309     }(sids.size());
3310
3311     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3312     auto lookup_src = [context](const ALuint sid) -> ALsource*
3313     {
3314         if(ALsource *src{LookupSource(context, sid)})
3315             return src;
3316         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3317     };
3318     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3319
3320     /* Pausing has to be done in two steps. First, for each source that's
3321      * detected to be playing, chamge the voice (asynchronously) to
3322      * stopping/paused.
3323      */
3324     VoiceChange *tail{}, *cur{};
3325     for(ALsource *source : srchandles)
3326     {
3327         Voice *voice{GetSourceVoice(source, context)};
3328         if(GetSourceState(source, voice) == AL_PLAYING)
3329         {
3330             if(!cur)
3331                 cur = tail = GetVoiceChanger(context);
3332             else
3333             {
3334                 cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
3335                 cur = cur->mNext.load(std::memory_order_relaxed);
3336             }
3337             cur->mVoice = voice;
3338             cur->mSourceID = source->id;
3339             cur->mState = VChangeState::Pause;
3340         }
3341     }
3342     if(tail) LIKELY
3343     {
3344         SendVoiceChanges(context, tail);
3345         /* Second, now that the voice changes have been sent, because it's
3346          * possible that the voice stopped after it was detected playing and
3347          * before the voice got paused, recheck that the source is still
3348          * considered playing and set it to paused if so.
3349          */
3350         for(ALsource *source : srchandles)
3351         {
3352             Voice *voice{GetSourceVoice(source, context)};
3353             if(GetSourceState(source, voice) == AL_PLAYING)
3354                 source->state = AL_PAUSED;
3355         }
3356     }
3357 }
3358 catch(al::context_error& e) {
3359     context->setError(e.errorCode(), "%s", e.what());
3360 }
3361
3362
3363 AL_API DECL_FUNC1(void, alSourceStop, ALuint,source)
3364 FORCE_ALIGN void AL_APIENTRY alSourceStopDirect(ALCcontext *context, ALuint source) noexcept
3365 { alSourceStopvDirect(context, 1, &source); }
3366
3367 AL_API DECL_FUNC2(void, alSourceStopv, ALsizei,n, const ALuint*,sources)
3368 FORCE_ALIGN void AL_APIENTRY alSourceStopvDirect(ALCcontext *context, ALsizei n,
3369     const ALuint *sources) noexcept
3370 try {
3371     if(n < 0)
3372         throw al::context_error{AL_INVALID_VALUE, "Stopping %d sources", n};
3373     if(n <= 0) UNLIKELY return;
3374
3375     al::span sids{sources, static_cast<ALuint>(n)};
3376     source_store_variant source_store;
3377     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3378     {
3379         if(count > std::tuple_size_v<source_store_array>)
3380             return al::span{source_store.emplace<source_store_vector>(count)};
3381         return al::span{source_store.emplace<source_store_array>()}.first(count);
3382     }(sids.size());
3383
3384     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3385     auto lookup_src = [context](const ALuint sid) -> ALsource*
3386     {
3387         if(ALsource *src{LookupSource(context, sid)})
3388             return src;
3389         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3390     };
3391     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3392
3393     VoiceChange *tail{}, *cur{};
3394     for(ALsource *source : srchandles)
3395     {
3396         if(Voice *voice{GetSourceVoice(source, context)})
3397         {
3398             if(!cur)
3399                 cur = tail = GetVoiceChanger(context);
3400             else
3401             {
3402                 cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
3403                 cur = cur->mNext.load(std::memory_order_relaxed);
3404             }
3405             voice->mPendingChange.store(true, std::memory_order_relaxed);
3406             cur->mVoice = voice;
3407             cur->mSourceID = source->id;
3408             cur->mState = VChangeState::Stop;
3409             source->state = AL_STOPPED;
3410         }
3411         source->Offset = 0.0;
3412         source->OffsetType = AL_NONE;
3413         source->VoiceIdx = InvalidVoiceIndex;
3414     }
3415     if(tail) LIKELY
3416         SendVoiceChanges(context, tail);
3417 }
3418 catch(al::context_error& e) {
3419     context->setError(e.errorCode(), "%s", e.what());
3420 }
3421
3422
3423 AL_API DECL_FUNC1(void, alSourceRewind, ALuint,source)
3424 FORCE_ALIGN void AL_APIENTRY alSourceRewindDirect(ALCcontext *context, ALuint source) noexcept
3425 { alSourceRewindvDirect(context, 1, &source); }
3426
3427 AL_API DECL_FUNC2(void, alSourceRewindv, ALsizei,n, const ALuint*,sources)
3428 FORCE_ALIGN void AL_APIENTRY alSourceRewindvDirect(ALCcontext *context, ALsizei n,
3429     const ALuint *sources) noexcept
3430 try {
3431     if(n < 0)
3432         throw al::context_error{AL_INVALID_VALUE, "Rewinding %d sources", n};
3433     if(n <= 0) UNLIKELY return;
3434
3435     al::span sids{sources, static_cast<ALuint>(n)};
3436     source_store_variant source_store;
3437     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3438     {
3439         if(count > std::tuple_size_v<source_store_array>)
3440             return al::span{source_store.emplace<source_store_vector>(count)};
3441         return al::span{source_store.emplace<source_store_array>()}.first(count);
3442     }(sids.size());
3443
3444     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3445     auto lookup_src = [context](const ALuint sid) -> ALsource*
3446     {
3447         if(ALsource *src{LookupSource(context, sid)})
3448             return src;
3449         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3450     };
3451     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3452
3453     VoiceChange *tail{}, *cur{};
3454     for(ALsource *source : srchandles)
3455     {
3456         Voice *voice{GetSourceVoice(source, context)};
3457         if(source->state != AL_INITIAL)
3458         {
3459             if(!cur)
3460                 cur = tail = GetVoiceChanger(context);
3461             else
3462             {
3463                 cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
3464                 cur = cur->mNext.load(std::memory_order_relaxed);
3465             }
3466             if(voice)
3467                 voice->mPendingChange.store(true, std::memory_order_relaxed);
3468             cur->mVoice = voice;
3469             cur->mSourceID = source->id;
3470             cur->mState = VChangeState::Reset;
3471             source->state = AL_INITIAL;
3472         }
3473         source->Offset = 0.0;
3474         source->OffsetType = AL_NONE;
3475         source->VoiceIdx = InvalidVoiceIndex;
3476     }
3477     if(tail) LIKELY
3478         SendVoiceChanges(context, tail);
3479 }
3480 catch(al::context_error& e) {
3481     context->setError(e.errorCode(), "%s", e.what());
3482 }
3483
3484
3485 AL_API DECL_FUNC3(void, alSourceQueueBuffers, ALuint,source, ALsizei,nb, const ALuint*,buffers)
3486 FORCE_ALIGN void AL_APIENTRY alSourceQueueBuffersDirect(ALCcontext *context, ALuint src,
3487     ALsizei nb, const ALuint *buffers) noexcept
3488 try {
3489     if(nb < 0)
3490         throw al::context_error{AL_INVALID_VALUE, "Queueing %d buffers", nb};
3491     if(nb <= 0) UNLIKELY return;
3492
3493     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3494     ALsource *source{LookupSource(context,src)};
3495     if(!source)
3496         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", src};
3497
3498     /* Can't queue on a Static Source */
3499     if(source->SourceType == AL_STATIC)
3500         throw al::context_error{AL_INVALID_OPERATION, "Queueing onto static source %u", src};
3501
3502     /* Check for a valid Buffer, for its frequency and format */
3503     ALCdevice *device{context->mALDevice.get()};
3504     ALbuffer *BufferFmt{nullptr};
3505     for(auto &item : source->mQueue)
3506     {
3507         BufferFmt = item.mBuffer;
3508         if(BufferFmt) break;
3509     }
3510
3511     std::unique_lock<std::mutex> buflock{device->BufferLock};
3512     const auto bids = al::span{buffers, static_cast<ALuint>(nb)};
3513     const size_t NewListStart{source->mQueue.size()};
3514     try {
3515         ALbufferQueueItem *BufferList{nullptr};
3516         std::for_each(bids.cbegin(), bids.cend(),
3517         [source,device,&BufferFmt,&BufferList](const ALuint bid)
3518         {
3519             ALbuffer *buffer{bid ? LookupBuffer(device, bid) : nullptr};
3520             if(bid && !buffer)
3521                 throw al::context_error{AL_INVALID_NAME, "Queueing invalid buffer ID %u", bid};
3522
3523             if(buffer)
3524             {
3525                 if(buffer->mSampleRate < 1)
3526                     throw al::context_error{AL_INVALID_OPERATION,
3527                         "Queueing buffer %u with no format", buffer->id};
3528
3529                 if(buffer->mCallback)
3530                     throw al::context_error{AL_INVALID_OPERATION, "Queueing callback buffer %u",
3531                         buffer->id};
3532
3533                 if(buffer->MappedAccess != 0 && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
3534                     throw al::context_error{AL_INVALID_OPERATION,
3535                         "Queueing non-persistently mapped buffer %u", buffer->id};
3536             }
3537
3538             source->mQueue.emplace_back();
3539             if(!BufferList)
3540                 BufferList = &source->mQueue.back();
3541             else
3542             {
3543                 auto &item = source->mQueue.back();
3544                 BufferList->mNext.store(&item, std::memory_order_relaxed);
3545                 BufferList = &item;
3546             }
3547             if(!buffer) return;
3548             BufferList->mBlockAlign = buffer->mBlockAlign;
3549             BufferList->mSampleLen = buffer->mSampleLen;
3550             BufferList->mLoopEnd = buffer->mSampleLen;
3551             BufferList->mSamples = buffer->mData;
3552             BufferList->mBuffer = buffer;
3553             IncrementRef(buffer->ref);
3554
3555             bool fmt_mismatch{false};
3556             if(BufferFmt == nullptr)
3557                 BufferFmt = buffer;
3558             else
3559             {
3560                 fmt_mismatch |= BufferFmt->mSampleRate != buffer->mSampleRate;
3561                 fmt_mismatch |= BufferFmt->mChannels != buffer->mChannels;
3562                 fmt_mismatch |= BufferFmt->mType != buffer->mType;
3563                 if(BufferFmt->isBFormat())
3564                 {
3565                     fmt_mismatch |= BufferFmt->mAmbiLayout != buffer->mAmbiLayout;
3566                     fmt_mismatch |= BufferFmt->mAmbiScaling != buffer->mAmbiScaling;
3567                 }
3568                 fmt_mismatch |= BufferFmt->mAmbiOrder != buffer->mAmbiOrder;
3569             }
3570             if(fmt_mismatch)
3571                 throw al::context_error{AL_INVALID_OPERATION,
3572                     "Queueing buffer with mismatched format\n"
3573                     "  Expected: %uhz, %s, %s ; Got: %uhz, %s, %s\n", BufferFmt->mSampleRate,
3574                     NameFromFormat(BufferFmt->mType), NameFromFormat(BufferFmt->mChannels),
3575                     buffer->mSampleRate, NameFromFormat(buffer->mType),
3576                     NameFromFormat(buffer->mChannels)};
3577         });
3578     }
3579     catch(...) {
3580         /* A buffer failed (invalid ID or format), or there was some other
3581          * unexpected error, so unlock and release each buffer we had.
3582          */
3583         auto iter = source->mQueue.begin() + ptrdiff_t(NewListStart);
3584         for(;iter != source->mQueue.end();++iter)
3585         {
3586             if(ALbuffer *buf{iter->mBuffer})
3587                 DecrementRef(buf->ref);
3588         }
3589         source->mQueue.resize(NewListStart);
3590         throw;
3591     }
3592     /* All buffers good. */
3593     buflock.unlock();
3594
3595     /* Source is now streaming */
3596     source->SourceType = AL_STREAMING;
3597
3598     if(NewListStart != 0)
3599     {
3600         auto iter = source->mQueue.begin() + ptrdiff_t(NewListStart);
3601         (iter-1)->mNext.store(al::to_address(iter), std::memory_order_release);
3602     }
3603 }
3604 catch(al::context_error& e) {
3605     context->setError(e.errorCode(), "%s", e.what());
3606 }
3607
3608 AL_API DECL_FUNC3(void, alSourceUnqueueBuffers, ALuint,source, ALsizei,nb, ALuint*,buffers)
3609 FORCE_ALIGN void AL_APIENTRY alSourceUnqueueBuffersDirect(ALCcontext *context, ALuint src,
3610     ALsizei nb, ALuint *buffers) noexcept
3611 try {
3612     if(nb < 0)
3613         throw al::context_error{AL_INVALID_VALUE, "Unqueueing %d buffers", nb};
3614     if(nb <= 0) UNLIKELY return;
3615
3616     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3617     ALsource *source{LookupSource(context,src)};
3618     if(!source)
3619         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", src};
3620
3621     if(source->SourceType != AL_STREAMING)
3622         throw al::context_error{AL_INVALID_VALUE, "Unqueueing from a non-streaming source %u",src};
3623     if(source->Looping)
3624         throw al::context_error{AL_INVALID_VALUE, "Unqueueing from looping source %u", src};
3625
3626     /* Make sure enough buffers have been processed to unqueue. */
3627     const al::span bids{buffers, static_cast<ALuint>(nb)};
3628     size_t processed{0};
3629     if(source->state != AL_INITIAL) LIKELY
3630     {
3631         VoiceBufferItem *Current{nullptr};
3632         if(Voice *voice{GetSourceVoice(source, context)})
3633             Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
3634         for(auto &item : source->mQueue)
3635         {
3636             if(&item == Current)
3637                 break;
3638             ++processed;
3639         }
3640     }
3641     if(processed < bids.size())
3642         throw al::context_error{AL_INVALID_VALUE, "Unqueueing %d buffer%s (only %zu processed)",
3643             nb, (nb==1)?"":"s", processed};
3644
3645     std::generate(bids.begin(), bids.end(), [source]() noexcept -> ALuint
3646     {
3647         auto &head = source->mQueue.front();
3648         ALuint bid{0};
3649         if(ALbuffer *buffer{head.mBuffer})
3650         {
3651             bid = buffer->id;
3652             DecrementRef(buffer->ref);
3653         }
3654         source->mQueue.pop_front();
3655         return bid;
3656     });
3657 }
3658 catch(al::context_error& e) {
3659     context->setError(e.errorCode(), "%s", e.what());
3660 }
3661
3662
3663 AL_API void AL_APIENTRY alSourceQueueBufferLayersSOFT(ALuint, ALsizei, const ALuint*) noexcept
3664 {
3665     ContextRef context{GetContextRef()};
3666     if(!context) UNLIKELY return;
3667
3668     context->setError(AL_INVALID_OPERATION, "alSourceQueueBufferLayersSOFT not supported");
3669 }
3670
3671
3672 ALsource::ALsource() noexcept
3673 {
3674     Direct.Gain = 1.0f;
3675     Direct.GainHF = 1.0f;
3676     Direct.HFReference = LowPassFreqRef;
3677     Direct.GainLF = 1.0f;
3678     Direct.LFReference = HighPassFreqRef;
3679     for(auto &send : Send)
3680     {
3681         send.Slot = nullptr;
3682         send.Gain = 1.0f;
3683         send.GainHF = 1.0f;
3684         send.HFReference = LowPassFreqRef;
3685         send.GainLF = 1.0f;
3686         send.LFReference = HighPassFreqRef;
3687     }
3688 }
3689
3690 ALsource::~ALsource()
3691 {
3692     for(auto &item : mQueue)
3693     {
3694         if(ALbuffer *buffer{item.mBuffer})
3695             DecrementRef(buffer->ref);
3696     }
3697
3698     auto clear_send = [](ALsource::SendData &send) -> void
3699     { if(send.Slot) DecrementRef(send.Slot->ref); };
3700     std::for_each(Send.begin(), Send.end(), clear_send);
3701 }
3702
3703 void UpdateAllSourceProps(ALCcontext *context)
3704 {
3705     std::lock_guard<std::mutex> srclock{context->mSourceLock};
3706     auto voicelist = context->getVoicesSpan();
3707     ALuint vidx{0u};
3708     for(Voice *voice : voicelist)
3709     {
3710         ALuint sid{voice->mSourceID.load(std::memory_order_acquire)};
3711         ALsource *source{sid ? LookupSource(context, sid) : nullptr};
3712         if(source && source->VoiceIdx == vidx)
3713         {
3714             if(std::exchange(source->mPropsDirty, false))
3715                 UpdateSourceProps(source, voice, context);
3716         }
3717         ++vidx;
3718     }
3719 }
3720
3721 void ALsource::SetName(ALCcontext *context, ALuint id, std::string_view name)
3722 {
3723     std::lock_guard<std::mutex> srclock{context->mSourceLock};
3724
3725     auto source = LookupSource(context, id);
3726     if(!source)
3727         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", id};
3728
3729     context->mSourceNames.insert_or_assign(id, name);
3730 }
3731
3732
3733 SourceSubList::~SourceSubList()
3734 {
3735     if(!Sources)
3736         return;
3737
3738     uint64_t usemask{~FreeMask};
3739     while(usemask)
3740     {
3741         const int idx{al::countr_zero(usemask)};
3742         usemask &= ~(1_u64 << idx);
3743         std::destroy_at(al::to_address(Sources->begin() + idx));
3744     }
3745     FreeMask = ~usemask;
3746     SubListAllocator{}.deallocate(Sources, 1);
3747     Sources = nullptr;
3748 }
3749
3750
3751 #ifdef ALSOFT_EAX
3752 void ALsource::eaxInitialize(ALCcontext *context) noexcept
3753 {
3754     assert(context != nullptr);
3755     mEaxAlContext = context;
3756
3757     mEaxPrimaryFxSlotId = context->eaxGetPrimaryFxSlotIndex();
3758     eax_set_defaults();
3759
3760     eax1_translate(mEax1.i, mEax);
3761     mEaxVersion = 1;
3762     mEaxChanged = true;
3763 }
3764
3765 void ALsource::eaxDispatch(const EaxCall& call)
3766 {
3767     call.is_get() ? eax_get(call) : eax_set(call);
3768 }
3769
3770 ALsource* ALsource::EaxLookupSource(ALCcontext& al_context, ALuint source_id) noexcept
3771 {
3772     return LookupSource(&al_context, source_id);
3773 }
3774
3775 [[noreturn]] void ALsource::eax_fail(const char* message)
3776 {
3777     throw Exception{message};
3778 }
3779
3780 [[noreturn]] void ALsource::eax_fail_unknown_property_id()
3781 {
3782     eax_fail("Unknown property id.");
3783 }
3784
3785 [[noreturn]] void ALsource::eax_fail_unknown_version()
3786 {
3787     eax_fail("Unknown version.");
3788 }
3789
3790 [[noreturn]] void ALsource::eax_fail_unknown_active_fx_slot_id()
3791 {
3792     eax_fail("Unknown active FX slot ID.");
3793 }
3794
3795 [[noreturn]] void ALsource::eax_fail_unknown_receiving_fx_slot_id()
3796 {
3797     eax_fail("Unknown receiving FX slot ID.");
3798 }
3799
3800 void ALsource::eax_set_sends_defaults(EaxSends& sends, const EaxFxSlotIds& ids) noexcept
3801 {
3802     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
3803     {
3804         auto& send = sends[i];
3805         send.guidReceivingFXSlotID = *(ids[i]);
3806         send.lSend = EAXSOURCE_DEFAULTSEND;
3807         send.lSendHF = EAXSOURCE_DEFAULTSENDHF;
3808         send.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
3809         send.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
3810         send.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
3811         send.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
3812         send.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
3813         send.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
3814     }
3815 }
3816
3817 void ALsource::eax1_set_defaults(Eax1Props& props) noexcept
3818 {
3819     props.fMix = EAX_REVERBMIX_USEDISTANCE;
3820 }
3821
3822 void ALsource::eax1_set_defaults() noexcept
3823 {
3824     eax1_set_defaults(mEax1.i);
3825     mEax1.d = mEax1.i;
3826 }
3827
3828 void ALsource::eax2_set_defaults(Eax2Props& props) noexcept
3829 {
3830     props.lDirect = EAXSOURCE_DEFAULTDIRECT;
3831     props.lDirectHF = EAXSOURCE_DEFAULTDIRECTHF;
3832     props.lRoom = EAXSOURCE_DEFAULTROOM;
3833     props.lRoomHF = EAXSOURCE_DEFAULTROOMHF;
3834     props.flRoomRolloffFactor = EAXSOURCE_DEFAULTROOMROLLOFFFACTOR;
3835     props.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
3836     props.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
3837     props.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
3838     props.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
3839     props.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
3840     props.lOutsideVolumeHF = EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF;
3841     props.flAirAbsorptionFactor = EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR;
3842     props.dwFlags = EAXSOURCE_DEFAULTFLAGS;
3843 }
3844
3845 void ALsource::eax2_set_defaults() noexcept
3846 {
3847     eax2_set_defaults(mEax2.i);
3848     mEax2.d = mEax2.i;
3849 }
3850
3851 void ALsource::eax3_set_defaults(Eax3Props& props) noexcept
3852 {
3853     props.lDirect = EAXSOURCE_DEFAULTDIRECT;
3854     props.lDirectHF = EAXSOURCE_DEFAULTDIRECTHF;
3855     props.lRoom = EAXSOURCE_DEFAULTROOM;
3856     props.lRoomHF = EAXSOURCE_DEFAULTROOMHF;
3857     props.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
3858     props.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
3859     props.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
3860     props.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
3861     props.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
3862     props.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
3863     props.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
3864     props.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
3865     props.lOutsideVolumeHF = EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF;
3866     props.flDopplerFactor = EAXSOURCE_DEFAULTDOPPLERFACTOR;
3867     props.flRolloffFactor = EAXSOURCE_DEFAULTROLLOFFFACTOR;
3868     props.flRoomRolloffFactor = EAXSOURCE_DEFAULTROOMROLLOFFFACTOR;
3869     props.flAirAbsorptionFactor = EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR;
3870     props.ulFlags = EAXSOURCE_DEFAULTFLAGS;
3871 }
3872
3873 void ALsource::eax3_set_defaults() noexcept
3874 {
3875     eax3_set_defaults(mEax3.i);
3876     mEax3.d = mEax3.i;
3877 }
3878
3879 void ALsource::eax4_set_sends_defaults(EaxSends& sends) noexcept
3880 {
3881     eax_set_sends_defaults(sends, eax4_fx_slot_ids);
3882 }
3883
3884 void ALsource::eax4_set_active_fx_slots_defaults(EAX40ACTIVEFXSLOTS& slots) noexcept
3885 {
3886     slots = EAX40SOURCE_DEFAULTACTIVEFXSLOTID;
3887 }
3888
3889 void ALsource::eax4_set_defaults() noexcept
3890 {
3891     eax3_set_defaults(mEax4.i.source);
3892     eax4_set_sends_defaults(mEax4.i.sends);
3893     eax4_set_active_fx_slots_defaults(mEax4.i.active_fx_slots);
3894     mEax4.d = mEax4.i;
3895 }
3896
3897 void ALsource::eax5_set_source_defaults(EAX50SOURCEPROPERTIES& props) noexcept
3898 {
3899     eax3_set_defaults(static_cast<Eax3Props&>(props));
3900     props.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
3901 }
3902
3903 void ALsource::eax5_set_sends_defaults(EaxSends& sends) noexcept
3904 {
3905     eax_set_sends_defaults(sends, eax5_fx_slot_ids);
3906 }
3907
3908 void ALsource::eax5_set_active_fx_slots_defaults(EAX50ACTIVEFXSLOTS& slots) noexcept
3909 {
3910     slots = EAX50SOURCE_3DDEFAULTACTIVEFXSLOTID;
3911 }
3912
3913 void ALsource::eax5_set_speaker_levels_defaults(EaxSpeakerLevels& speaker_levels) noexcept
3914 {
3915     for(size_t i{0};i < eax_max_speakers;++i)
3916     {
3917         auto& speaker_level = speaker_levels[i];
3918         speaker_level.lSpeakerID = static_cast<long>(EAXSPEAKER_FRONT_LEFT + i);
3919         speaker_level.lLevel = EAXSOURCE_DEFAULTSPEAKERLEVEL;
3920     }
3921 }
3922
3923 void ALsource::eax5_set_defaults(Eax5Props& props) noexcept
3924 {
3925     eax5_set_source_defaults(props.source);
3926     eax5_set_sends_defaults(props.sends);
3927     eax5_set_active_fx_slots_defaults(props.active_fx_slots);
3928     eax5_set_speaker_levels_defaults(props.speaker_levels);
3929 }
3930
3931 void ALsource::eax5_set_defaults() noexcept
3932 {
3933     eax5_set_defaults(mEax5.i);
3934     mEax5.d = mEax5.i;
3935 }
3936
3937 void ALsource::eax_set_defaults() noexcept
3938 {
3939     eax1_set_defaults();
3940     eax2_set_defaults();
3941     eax3_set_defaults();
3942     eax4_set_defaults();
3943     eax5_set_defaults();
3944 }
3945
3946 void ALsource::eax1_translate(const Eax1Props& src, Eax5Props& dst) noexcept
3947 {
3948     eax5_set_defaults(dst);
3949
3950     if (src.fMix == EAX_REVERBMIX_USEDISTANCE)
3951     {
3952         dst.source.ulFlags |= EAXSOURCEFLAGS_ROOMAUTO;
3953         dst.sends[0].lSend = 0;
3954     }
3955     else
3956     {
3957         dst.source.ulFlags &= ~EAXSOURCEFLAGS_ROOMAUTO;
3958         dst.sends[0].lSend = std::clamp(static_cast<long>(gain_to_level_mb(src.fMix)),
3959             EAXSOURCE_MINSEND, EAXSOURCE_MAXSEND);
3960     }
3961 }
3962
3963 void ALsource::eax2_translate(const Eax2Props& src, Eax5Props& dst) noexcept
3964 {
3965     // Source.
3966     //
3967     dst.source.lDirect = src.lDirect;
3968     dst.source.lDirectHF = src.lDirectHF;
3969     dst.source.lRoom = src.lRoom;
3970     dst.source.lRoomHF = src.lRoomHF;
3971     dst.source.lObstruction = src.lObstruction;
3972     dst.source.flObstructionLFRatio = src.flObstructionLFRatio;
3973     dst.source.lOcclusion = src.lOcclusion;
3974     dst.source.flOcclusionLFRatio = src.flOcclusionLFRatio;
3975     dst.source.flOcclusionRoomRatio = src.flOcclusionRoomRatio;
3976     dst.source.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
3977     dst.source.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
3978     dst.source.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
3979     dst.source.lOutsideVolumeHF = src.lOutsideVolumeHF;
3980     dst.source.flDopplerFactor = EAXSOURCE_DEFAULTDOPPLERFACTOR;
3981     dst.source.flRolloffFactor = EAXSOURCE_DEFAULTROLLOFFFACTOR;
3982     dst.source.flRoomRolloffFactor = src.flRoomRolloffFactor;
3983     dst.source.flAirAbsorptionFactor = src.flAirAbsorptionFactor;
3984     dst.source.ulFlags = src.dwFlags;
3985     dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
3986
3987     // Set everything else to defaults.
3988     //
3989     eax5_set_sends_defaults(dst.sends);
3990     eax5_set_active_fx_slots_defaults(dst.active_fx_slots);
3991     eax5_set_speaker_levels_defaults(dst.speaker_levels);
3992 }
3993
3994 void ALsource::eax3_translate(const Eax3Props& src, Eax5Props& dst) noexcept
3995 {
3996     // Source.
3997     //
3998     static_cast<Eax3Props&>(dst.source) = src;
3999     dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
4000
4001     // Set everything else to defaults.
4002     //
4003     eax5_set_sends_defaults(dst.sends);
4004     eax5_set_active_fx_slots_defaults(dst.active_fx_slots);
4005     eax5_set_speaker_levels_defaults(dst.speaker_levels);
4006 }
4007
4008 void ALsource::eax4_translate(const Eax4Props& src, Eax5Props& dst) noexcept
4009 {
4010     // Source.
4011     //
4012     static_cast<Eax3Props&>(dst.source) = src.source;
4013     dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
4014
4015     // Sends.
4016     //
4017     dst.sends = src.sends;
4018
4019     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4020         dst.sends[i].guidReceivingFXSlotID = *(eax5_fx_slot_ids[i]);
4021
4022     // Active FX slots.
4023     //
4024     auto translate_slotid = [](const GUID &src_id) -> GUID
4025     {
4026         if(src_id == EAX_NULL_GUID)
4027             return EAX_NULL_GUID;
4028         if(src_id == EAX_PrimaryFXSlotID)
4029             return EAX_PrimaryFXSlotID;
4030         if(src_id == EAXPROPERTYID_EAX40_FXSlot0)
4031             return EAXPROPERTYID_EAX50_FXSlot0;
4032         if(src_id == EAXPROPERTYID_EAX40_FXSlot1)
4033             return EAXPROPERTYID_EAX50_FXSlot1;
4034         if(src_id == EAXPROPERTYID_EAX40_FXSlot2)
4035             return EAXPROPERTYID_EAX50_FXSlot2;
4036         if(src_id == EAXPROPERTYID_EAX40_FXSlot3)
4037             return EAXPROPERTYID_EAX50_FXSlot3;
4038
4039         UNLIKELY
4040         ERR("Unexpected active FX slot ID\n");
4041         return EAX_NULL_GUID;
4042     };
4043     const auto src_slots = al::span{src.active_fx_slots.guidActiveFXSlots};
4044     const auto dst_slots = al::span{dst.active_fx_slots.guidActiveFXSlots};
4045     auto dstiter = std::transform(src_slots.cbegin(), src_slots.cend(), dst_slots.begin(),
4046         translate_slotid);
4047     std::fill(dstiter, dst_slots.end(), EAX_NULL_GUID);
4048
4049     // Speaker levels.
4050     //
4051     eax5_set_speaker_levels_defaults(dst.speaker_levels);
4052 }
4053
4054 float ALsource::eax_calculate_dst_occlusion_mb(
4055     long src_occlusion_mb,
4056     float path_ratio,
4057     float lf_ratio) noexcept
4058 {
4059     const auto ratio_1 = path_ratio + lf_ratio - 1.0F;
4060     const auto ratio_2 = path_ratio * lf_ratio;
4061     const auto ratio = (ratio_2 > ratio_1) ? ratio_2 : ratio_1;
4062     const auto dst_occlustion_mb = static_cast<float>(src_occlusion_mb) * ratio;
4063     return dst_occlustion_mb;
4064 }
4065
4066 EaxAlLowPassParam ALsource::eax_create_direct_filter_param() const noexcept
4067 {
4068     const auto &source = mEax.source;
4069
4070     auto gain_mb = static_cast<float>(source.lObstruction) * source.flObstructionLFRatio;
4071     auto gainhf_mb = static_cast<float>(source.lObstruction);
4072
4073     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4074     {
4075         if(!mEaxActiveFxSlots[i])
4076             continue;
4077
4078         if(source.lOcclusion != 0)
4079         {
4080             const auto& fx_slot = mEaxAlContext->eaxGetFxSlot(i);
4081             const auto& fx_slot_eax = fx_slot.eax_get_eax_fx_slot();
4082             const auto is_environmental_fx = ((fx_slot_eax.ulFlags&EAXFXSLOTFLAGS_ENVIRONMENT) != 0);
4083             const auto is_primary = (mEaxPrimaryFxSlotId.value_or(-1) == fx_slot.eax_get_index());
4084
4085             if(is_environmental_fx && is_primary)
4086             {
4087                 gain_mb += eax_calculate_dst_occlusion_mb(source.lOcclusion,
4088                     source.flOcclusionDirectRatio, source.flOcclusionLFRatio);
4089
4090                 gainhf_mb += static_cast<float>(source.lOcclusion) * source.flOcclusionDirectRatio;
4091             }
4092         }
4093
4094         const auto& send = mEax.sends[i];
4095         if(send.lOcclusion != 0)
4096         {
4097             gain_mb += eax_calculate_dst_occlusion_mb(send.lOcclusion, send.flOcclusionDirectRatio,
4098                 send.flOcclusionLFRatio);
4099
4100             gainhf_mb += static_cast<float>(send.lOcclusion) * send.flOcclusionDirectRatio;
4101         }
4102     }
4103
4104     /* gainhf_mb is the absolute mBFS of the filter's high-frequency volume,
4105      * and gain_mb is the absolute mBFS of the filter's low-frequency volume.
4106      * Adjust the HF volume to be relative to the LF volume, to make the
4107      * appropriate main and relative HF filter volumes.
4108      *
4109      * Also add the Direct and DirectHF properties to the filter, which are
4110      * already the main and relative HF volumes.
4111      */
4112     gainhf_mb -= gain_mb - static_cast<float>(source.lDirectHF);
4113     gain_mb += static_cast<float>(source.lDirect);
4114
4115     return EaxAlLowPassParam{level_mb_to_gain(gain_mb),
4116         std::min(level_mb_to_gain(gainhf_mb), 1.0f)};
4117 }
4118
4119 EaxAlLowPassParam ALsource::eax_create_room_filter_param(
4120     const ALeffectslot& fx_slot,
4121     const EAXSOURCEALLSENDPROPERTIES& send) const noexcept
4122 {
4123     const auto& fx_slot_eax = fx_slot.eax_get_eax_fx_slot();
4124     const auto is_environmental_fx = bool{(fx_slot_eax.ulFlags & EAXFXSLOTFLAGS_ENVIRONMENT) != 0};
4125     const auto is_primary = bool{mEaxPrimaryFxSlotId.value_or(-1) == fx_slot.eax_get_index()};
4126
4127     auto gain_mb = (static_cast<float>(fx_slot_eax.lOcclusion) * fx_slot_eax.flOcclusionLFRatio)
4128         + eax_calculate_dst_occlusion_mb(send.lOcclusion, send.flOcclusionRoomRatio,
4129             send.flOcclusionLFRatio)
4130         + (static_cast<float>(send.lExclusion) * send.flExclusionLFRatio);
4131
4132     auto gainhf_mb = static_cast<float>(fx_slot_eax.lOcclusion)
4133         + (static_cast<float>(send.lOcclusion) * send.flOcclusionRoomRatio);
4134
4135     if(is_environmental_fx && is_primary)
4136     {
4137         const auto &source = mEax.source;
4138
4139         gain_mb += eax_calculate_dst_occlusion_mb(source.lOcclusion, source.flOcclusionRoomRatio,
4140             source.flOcclusionLFRatio);
4141         gain_mb += static_cast<float>(source.lExclusion) * source.flExclusionLFRatio;
4142
4143         gainhf_mb += static_cast<float>(source.lOcclusion) * source.flOcclusionRoomRatio;
4144         gainhf_mb += static_cast<float>(source.lExclusion + send.lExclusion);
4145     }
4146
4147     gainhf_mb -= gain_mb - static_cast<float>(send.lSendHF);
4148     gain_mb += static_cast<float>(send.lSend);
4149     if(is_environmental_fx)
4150     {
4151         const auto &source = mEax.source;
4152         gain_mb += static_cast<float>(source.lRoom);
4153         gainhf_mb += static_cast<float>(source.lRoomHF);
4154     }
4155
4156     return EaxAlLowPassParam{level_mb_to_gain(gain_mb),
4157         std::min(level_mb_to_gain(gainhf_mb), 1.0f)};
4158 }
4159
4160 void ALsource::eax_update_direct_filter()
4161 {
4162     const auto& direct_param = eax_create_direct_filter_param();
4163     Direct.Gain = direct_param.gain;
4164     Direct.GainHF = direct_param.gain_hf;
4165     Direct.HFReference = LowPassFreqRef;
4166     Direct.GainLF = 1.0f;
4167     Direct.LFReference = HighPassFreqRef;
4168     mPropsDirty = true;
4169 }
4170
4171 void ALsource::eax_update_room_filters()
4172 {
4173     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4174     {
4175         if(!mEaxActiveFxSlots[i])
4176             continue;
4177
4178         auto& fx_slot = mEaxAlContext->eaxGetFxSlot(i);
4179         const auto& send = mEax.sends[i];
4180         const auto& room_param = eax_create_room_filter_param(fx_slot, send);
4181         eax_set_al_source_send(&fx_slot, i, room_param);
4182     }
4183 }
4184
4185 void ALsource::eax_set_efx_outer_gain_hf()
4186 {
4187     OuterGainHF = std::clamp(
4188         level_mb_to_gain(static_cast<float>(mEax.source.lOutsideVolumeHF)),
4189         AL_MIN_CONE_OUTER_GAINHF,
4190         AL_MAX_CONE_OUTER_GAINHF);
4191 }
4192
4193 void ALsource::eax_set_efx_doppler_factor()
4194 {
4195     DopplerFactor = mEax.source.flDopplerFactor;
4196 }
4197
4198 void ALsource::eax_set_efx_rolloff_factor()
4199 {
4200     RolloffFactor2 = mEax.source.flRolloffFactor;
4201 }
4202
4203 void ALsource::eax_set_efx_room_rolloff_factor()
4204 {
4205     RoomRolloffFactor = mEax.source.flRoomRolloffFactor;
4206 }
4207
4208 void ALsource::eax_set_efx_air_absorption_factor()
4209 {
4210     AirAbsorptionFactor = mEax.source.flAirAbsorptionFactor;
4211 }
4212
4213 void ALsource::eax_set_efx_dry_gain_hf_auto()
4214 {
4215     DryGainHFAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_DIRECTHFAUTO) != 0);
4216 }
4217
4218 void ALsource::eax_set_efx_wet_gain_auto()
4219 {
4220     WetGainAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_ROOMAUTO) != 0);
4221 }
4222
4223 void ALsource::eax_set_efx_wet_gain_hf_auto()
4224 {
4225     WetGainHFAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_ROOMHFAUTO) != 0);
4226 }
4227
4228 void ALsource::eax1_set(const EaxCall& call, Eax1Props& props)
4229 {
4230     switch (call.get_property_id()) {
4231         case DSPROPERTY_EAXBUFFER_ALL:
4232             eax_defer<Eax1SourceAllValidator>(call, props);
4233             break;
4234
4235         case DSPROPERTY_EAXBUFFER_REVERBMIX:
4236             eax_defer<Eax1SourceReverbMixValidator>(call, props.fMix);
4237             break;
4238
4239         default:
4240             eax_fail_unknown_property_id();
4241     }
4242 }
4243
4244 void ALsource::eax2_set(const EaxCall& call, Eax2Props& props)
4245 {
4246     switch (call.get_property_id()) {
4247         case DSPROPERTY_EAX20BUFFER_NONE:
4248             break;
4249
4250         case DSPROPERTY_EAX20BUFFER_ALLPARAMETERS:
4251             eax_defer<Eax2SourceAllValidator>(call, props);
4252             break;
4253
4254         case DSPROPERTY_EAX20BUFFER_DIRECT:
4255             eax_defer<Eax2SourceDirectValidator>(call, props.lDirect);
4256             break;
4257
4258         case DSPROPERTY_EAX20BUFFER_DIRECTHF:
4259             eax_defer<Eax2SourceDirectHfValidator>(call, props.lDirectHF);
4260             break;
4261
4262         case DSPROPERTY_EAX20BUFFER_ROOM:
4263             eax_defer<Eax2SourceRoomValidator>(call, props.lRoom);
4264             break;
4265
4266         case DSPROPERTY_EAX20BUFFER_ROOMHF:
4267             eax_defer<Eax2SourceRoomHfValidator>(call, props.lRoomHF);
4268             break;
4269
4270         case DSPROPERTY_EAX20BUFFER_ROOMROLLOFFFACTOR:
4271             eax_defer<Eax2SourceRoomRolloffFactorValidator>(call, props.flRoomRolloffFactor);
4272             break;
4273
4274         case DSPROPERTY_EAX20BUFFER_OBSTRUCTION:
4275             eax_defer<Eax2SourceObstructionValidator>(call, props.lObstruction);
4276             break;
4277
4278         case DSPROPERTY_EAX20BUFFER_OBSTRUCTIONLFRATIO:
4279             eax_defer<Eax2SourceObstructionLfRatioValidator>(call, props.flObstructionLFRatio);
4280             break;
4281
4282         case DSPROPERTY_EAX20BUFFER_OCCLUSION:
4283             eax_defer<Eax2SourceOcclusionValidator>(call, props.lOcclusion);
4284             break;
4285
4286         case DSPROPERTY_EAX20BUFFER_OCCLUSIONLFRATIO:
4287             eax_defer<Eax2SourceOcclusionLfRatioValidator>(call, props.flOcclusionLFRatio);
4288             break;
4289
4290         case DSPROPERTY_EAX20BUFFER_OCCLUSIONROOMRATIO:
4291             eax_defer<Eax2SourceOcclusionRoomRatioValidator>(call, props.flOcclusionRoomRatio);
4292             break;
4293
4294         case DSPROPERTY_EAX20BUFFER_OUTSIDEVOLUMEHF:
4295             eax_defer<Eax2SourceOutsideVolumeHfValidator>(call, props.lOutsideVolumeHF);
4296             break;
4297
4298         case DSPROPERTY_EAX20BUFFER_AIRABSORPTIONFACTOR:
4299             eax_defer<Eax2SourceAirAbsorptionFactorValidator>(call, props.flAirAbsorptionFactor);
4300             break;
4301
4302         case DSPROPERTY_EAX20BUFFER_FLAGS:
4303             eax_defer<Eax2SourceFlagsValidator>(call, props.dwFlags);
4304             break;
4305
4306         default:
4307             eax_fail_unknown_property_id();
4308     }
4309 }
4310
4311 void ALsource::eax3_set(const EaxCall& call, Eax3Props& props)
4312 {
4313     switch (call.get_property_id()) {
4314         case EAXSOURCE_NONE:
4315             break;
4316
4317         case EAXSOURCE_ALLPARAMETERS:
4318             eax_defer<Eax3SourceAllValidator>(call, props);
4319             break;
4320
4321         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4322             eax_defer_sub<Eax4ObstructionValidator, EAXOBSTRUCTIONPROPERTIES>(call, props.lObstruction);
4323             break;
4324
4325         case EAXSOURCE_OCCLUSIONPARAMETERS:
4326             eax_defer_sub<Eax4OcclusionValidator, EAXOCCLUSIONPROPERTIES>(call, props.lOcclusion);
4327             break;
4328
4329         case EAXSOURCE_EXCLUSIONPARAMETERS:
4330             eax_defer_sub<Eax4ExclusionValidator, EAXEXCLUSIONPROPERTIES>(call, props.lExclusion);
4331             break;
4332
4333         case EAXSOURCE_DIRECT:
4334             eax_defer<Eax2SourceDirectValidator>(call, props.lDirect);
4335             break;
4336
4337         case EAXSOURCE_DIRECTHF:
4338             eax_defer<Eax2SourceDirectHfValidator>(call, props.lDirectHF);
4339             break;
4340
4341         case EAXSOURCE_ROOM:
4342             eax_defer<Eax2SourceRoomValidator>(call, props.lRoom);
4343             break;
4344
4345         case EAXSOURCE_ROOMHF:
4346             eax_defer<Eax2SourceRoomHfValidator>(call, props.lRoomHF);
4347             break;
4348
4349         case EAXSOURCE_OBSTRUCTION:
4350             eax_defer<Eax2SourceObstructionValidator>(call, props.lObstruction);
4351             break;
4352
4353         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4354             eax_defer<Eax2SourceObstructionLfRatioValidator>(call, props.flObstructionLFRatio);
4355             break;
4356
4357         case EAXSOURCE_OCCLUSION:
4358             eax_defer<Eax2SourceOcclusionValidator>(call, props.lOcclusion);
4359             break;
4360
4361         case EAXSOURCE_OCCLUSIONLFRATIO:
4362             eax_defer<Eax2SourceOcclusionLfRatioValidator>(call, props.flOcclusionLFRatio);
4363             break;
4364
4365         case EAXSOURCE_OCCLUSIONROOMRATIO:
4366             eax_defer<Eax2SourceOcclusionRoomRatioValidator>(call, props.flOcclusionRoomRatio);
4367             break;
4368
4369         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4370             eax_defer<Eax3SourceOcclusionDirectRatioValidator>(call, props.flOcclusionDirectRatio);
4371             break;
4372
4373         case EAXSOURCE_EXCLUSION:
4374             eax_defer<Eax3SourceExclusionValidator>(call, props.lExclusion);
4375             break;
4376
4377         case EAXSOURCE_EXCLUSIONLFRATIO:
4378             eax_defer<Eax3SourceExclusionLfRatioValidator>(call, props.flExclusionLFRatio);
4379             break;
4380
4381         case EAXSOURCE_OUTSIDEVOLUMEHF:
4382             eax_defer<Eax2SourceOutsideVolumeHfValidator>(call, props.lOutsideVolumeHF);
4383             break;
4384
4385         case EAXSOURCE_DOPPLERFACTOR:
4386             eax_defer<Eax3SourceDopplerFactorValidator>(call, props.flDopplerFactor);
4387             break;
4388
4389         case EAXSOURCE_ROLLOFFFACTOR:
4390             eax_defer<Eax3SourceRolloffFactorValidator>(call, props.flRolloffFactor);
4391             break;
4392
4393         case EAXSOURCE_ROOMROLLOFFFACTOR:
4394             eax_defer<Eax2SourceRoomRolloffFactorValidator>(call, props.flRoomRolloffFactor);
4395             break;
4396
4397         case EAXSOURCE_AIRABSORPTIONFACTOR:
4398             eax_defer<Eax2SourceAirAbsorptionFactorValidator>(call, props.flAirAbsorptionFactor);
4399             break;
4400
4401         case EAXSOURCE_FLAGS:
4402             eax_defer<Eax2SourceFlagsValidator>(call, props.ulFlags);
4403             break;
4404
4405         default:
4406             eax_fail_unknown_property_id();
4407     }
4408 }
4409
4410 void ALsource::eax4_set(const EaxCall& call, Eax4Props& props)
4411 {
4412     switch (call.get_property_id()) {
4413         case EAXSOURCE_NONE:
4414         case EAXSOURCE_ALLPARAMETERS:
4415         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4416         case EAXSOURCE_OCCLUSIONPARAMETERS:
4417         case EAXSOURCE_EXCLUSIONPARAMETERS:
4418         case EAXSOURCE_DIRECT:
4419         case EAXSOURCE_DIRECTHF:
4420         case EAXSOURCE_ROOM:
4421         case EAXSOURCE_ROOMHF:
4422         case EAXSOURCE_OBSTRUCTION:
4423         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4424         case EAXSOURCE_OCCLUSION:
4425         case EAXSOURCE_OCCLUSIONLFRATIO:
4426         case EAXSOURCE_OCCLUSIONROOMRATIO:
4427         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4428         case EAXSOURCE_EXCLUSION:
4429         case EAXSOURCE_EXCLUSIONLFRATIO:
4430         case EAXSOURCE_OUTSIDEVOLUMEHF:
4431         case EAXSOURCE_DOPPLERFACTOR:
4432         case EAXSOURCE_ROLLOFFFACTOR:
4433         case EAXSOURCE_ROOMROLLOFFFACTOR:
4434         case EAXSOURCE_AIRABSORPTIONFACTOR:
4435         case EAXSOURCE_FLAGS:
4436             eax3_set(call, props.source);
4437             break;
4438
4439         case EAXSOURCE_SENDPARAMETERS:
4440             eax4_defer_sends<Eax4SendValidator, EAXSOURCESENDPROPERTIES>(call, props.sends);
4441             break;
4442
4443         case EAXSOURCE_ALLSENDPARAMETERS:
4444             eax4_defer_sends<Eax4AllSendValidator, EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4445             break;
4446
4447         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4448             eax4_defer_sends<Eax4OcclusionSendValidator, EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4449             break;
4450
4451         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4452             eax4_defer_sends<Eax4ExclusionSendValidator, EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4453             break;
4454
4455         case EAXSOURCE_ACTIVEFXSLOTID:
4456             eax4_defer_active_fx_slot_id(call, al::span{props.active_fx_slots.guidActiveFXSlots});
4457             break;
4458
4459         default:
4460             eax_fail_unknown_property_id();
4461     }
4462 }
4463
4464 void ALsource::eax5_defer_all_2d(const EaxCall& call, EAX50SOURCEPROPERTIES& props)
4465 {
4466     const auto& src_props = call.get_value<Exception, const EAXSOURCE2DPROPERTIES>();
4467     Eax5SourceAll2dValidator{}(src_props);
4468     props.lDirect = src_props.lDirect;
4469     props.lDirectHF = src_props.lDirectHF;
4470     props.lRoom = src_props.lRoom;
4471     props.lRoomHF = src_props.lRoomHF;
4472     props.ulFlags = src_props.ulFlags;
4473 }
4474
4475 void ALsource::eax5_defer_speaker_levels(const EaxCall& call, EaxSpeakerLevels& props)
4476 {
4477     const auto values = call.get_values<const EAXSPEAKERLEVELPROPERTIES>(eax_max_speakers);
4478     std::for_each(values.cbegin(), values.cend(), Eax5SpeakerAllValidator{});
4479
4480     for (const auto& value : values) {
4481         const auto index = static_cast<size_t>(value.lSpeakerID - EAXSPEAKER_FRONT_LEFT);
4482         props[index].lLevel = value.lLevel;
4483     }
4484 }
4485
4486 void ALsource::eax5_set(const EaxCall& call, Eax5Props& props)
4487 {
4488     switch (call.get_property_id()) {
4489         case EAXSOURCE_NONE:
4490             break;
4491
4492         case EAXSOURCE_ALLPARAMETERS:
4493             eax_defer<Eax5SourceAllValidator>(call, props.source);
4494             break;
4495
4496         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4497         case EAXSOURCE_OCCLUSIONPARAMETERS:
4498         case EAXSOURCE_EXCLUSIONPARAMETERS:
4499         case EAXSOURCE_DIRECT:
4500         case EAXSOURCE_DIRECTHF:
4501         case EAXSOURCE_ROOM:
4502         case EAXSOURCE_ROOMHF:
4503         case EAXSOURCE_OBSTRUCTION:
4504         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4505         case EAXSOURCE_OCCLUSION:
4506         case EAXSOURCE_OCCLUSIONLFRATIO:
4507         case EAXSOURCE_OCCLUSIONROOMRATIO:
4508         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4509         case EAXSOURCE_EXCLUSION:
4510         case EAXSOURCE_EXCLUSIONLFRATIO:
4511         case EAXSOURCE_OUTSIDEVOLUMEHF:
4512         case EAXSOURCE_DOPPLERFACTOR:
4513         case EAXSOURCE_ROLLOFFFACTOR:
4514         case EAXSOURCE_ROOMROLLOFFFACTOR:
4515         case EAXSOURCE_AIRABSORPTIONFACTOR:
4516             eax3_set(call, props.source);
4517             break;
4518
4519         case EAXSOURCE_FLAGS:
4520             eax_defer<Eax5SourceFlagsValidator>(call, props.source.ulFlags);
4521             break;
4522
4523         case EAXSOURCE_SENDPARAMETERS:
4524             eax5_defer_sends<Eax5SendValidator, EAXSOURCESENDPROPERTIES>(call, props.sends);
4525             break;
4526
4527         case EAXSOURCE_ALLSENDPARAMETERS:
4528             eax5_defer_sends<Eax5AllSendValidator, EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4529             break;
4530
4531         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4532             eax5_defer_sends<Eax5OcclusionSendValidator, EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4533             break;
4534
4535         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4536             eax5_defer_sends<Eax5ExclusionSendValidator, EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4537             break;
4538
4539         case EAXSOURCE_ACTIVEFXSLOTID:
4540             eax5_defer_active_fx_slot_id(call, al::span{props.active_fx_slots.guidActiveFXSlots});
4541             break;
4542
4543         case EAXSOURCE_MACROFXFACTOR:
4544             eax_defer<Eax5SourceMacroFXFactorValidator>(call, props.source.flMacroFXFactor);
4545             break;
4546
4547         case EAXSOURCE_SPEAKERLEVELS:
4548             eax5_defer_speaker_levels(call, props.speaker_levels);
4549             break;
4550
4551         case EAXSOURCE_ALL2DPARAMETERS:
4552             eax5_defer_all_2d(call, props.source);
4553             break;
4554
4555         default:
4556             eax_fail_unknown_property_id();
4557     }
4558 }
4559
4560 void ALsource::eax_set(const EaxCall& call)
4561 {
4562     const auto eax_version = call.get_version();
4563     switch(eax_version)
4564     {
4565     case 1: eax1_set(call, mEax1.d); break;
4566     case 2: eax2_set(call, mEax2.d); break;
4567     case 3: eax3_set(call, mEax3.d); break;
4568     case 4: eax4_set(call, mEax4.d); break;
4569     case 5: eax5_set(call, mEax5.d); break;
4570     default: eax_fail_unknown_property_id();
4571     }
4572     mEaxChanged = true;
4573     mEaxVersion = eax_version;
4574 }
4575
4576 void ALsource::eax_get_active_fx_slot_id(const EaxCall& call, const al::span<const GUID> src_ids)
4577 {
4578     assert(src_ids.size()==EAX40_MAX_ACTIVE_FXSLOTS || src_ids.size()==EAX50_MAX_ACTIVE_FXSLOTS);
4579     const auto dst_ids = call.get_values<GUID>(src_ids.size());
4580     std::uninitialized_copy_n(src_ids.begin(), dst_ids.size(), dst_ids.begin());
4581 }
4582
4583 void ALsource::eax1_get(const EaxCall& call, const Eax1Props& props)
4584 {
4585     switch (call.get_property_id()) {
4586         case DSPROPERTY_EAXBUFFER_ALL:
4587         case DSPROPERTY_EAXBUFFER_REVERBMIX:
4588             call.set_value<Exception>(props.fMix);
4589             break;
4590
4591         default:
4592             eax_fail_unknown_property_id();
4593     }
4594 }
4595
4596 void ALsource::eax2_get(const EaxCall& call, const Eax2Props& props)
4597 {
4598     switch (call.get_property_id()) {
4599         case DSPROPERTY_EAX20BUFFER_NONE:
4600             break;
4601
4602         case DSPROPERTY_EAX20BUFFER_ALLPARAMETERS:
4603             call.set_value<Exception>(props);
4604             break;
4605
4606         case DSPROPERTY_EAX20BUFFER_DIRECT:
4607             call.set_value<Exception>(props.lDirect);
4608             break;
4609
4610         case DSPROPERTY_EAX20BUFFER_DIRECTHF:
4611             call.set_value<Exception>(props.lDirectHF);
4612             break;
4613
4614         case DSPROPERTY_EAX20BUFFER_ROOM:
4615             call.set_value<Exception>(props.lRoom);
4616             break;
4617
4618         case DSPROPERTY_EAX20BUFFER_ROOMHF:
4619             call.set_value<Exception>(props.lRoomHF);
4620             break;
4621
4622         case DSPROPERTY_EAX20BUFFER_ROOMROLLOFFFACTOR:
4623             call.set_value<Exception>(props.flRoomRolloffFactor);
4624             break;
4625
4626         case DSPROPERTY_EAX20BUFFER_OBSTRUCTION:
4627             call.set_value<Exception>(props.lObstruction);
4628             break;
4629
4630         case DSPROPERTY_EAX20BUFFER_OBSTRUCTIONLFRATIO:
4631             call.set_value<Exception>(props.flObstructionLFRatio);
4632             break;
4633
4634         case DSPROPERTY_EAX20BUFFER_OCCLUSION:
4635             call.set_value<Exception>(props.lOcclusion);
4636             break;
4637
4638         case DSPROPERTY_EAX20BUFFER_OCCLUSIONLFRATIO:
4639             call.set_value<Exception>(props.flOcclusionLFRatio);
4640             break;
4641
4642         case DSPROPERTY_EAX20BUFFER_OCCLUSIONROOMRATIO:
4643             call.set_value<Exception>(props.flOcclusionRoomRatio);
4644             break;
4645
4646         case DSPROPERTY_EAX20BUFFER_OUTSIDEVOLUMEHF:
4647             call.set_value<Exception>(props.lOutsideVolumeHF);
4648             break;
4649
4650         case DSPROPERTY_EAX20BUFFER_AIRABSORPTIONFACTOR:
4651             call.set_value<Exception>(props.flAirAbsorptionFactor);
4652             break;
4653
4654         case DSPROPERTY_EAX20BUFFER_FLAGS:
4655             call.set_value<Exception>(props.dwFlags);
4656             break;
4657
4658         default:
4659             eax_fail_unknown_property_id();
4660     }
4661 }
4662
4663 void ALsource::eax3_get_obstruction(const EaxCall& call, const Eax3Props& props)
4664 {
4665     const auto& subprops = reinterpret_cast<const EAXOBSTRUCTIONPROPERTIES&>(props.lObstruction);
4666     call.set_value<Exception>(subprops);
4667 }
4668
4669 void ALsource::eax3_get_occlusion(const EaxCall& call, const Eax3Props& props)
4670 {
4671     const auto& subprops = reinterpret_cast<const EAXOCCLUSIONPROPERTIES&>(props.lOcclusion);
4672     call.set_value<Exception>(subprops);
4673 }
4674
4675 void ALsource::eax3_get_exclusion(const EaxCall& call, const Eax3Props& props)
4676 {
4677     const auto& subprops = reinterpret_cast<const EAXEXCLUSIONPROPERTIES&>(props.lExclusion);
4678     call.set_value<Exception>(subprops);
4679 }
4680
4681 void ALsource::eax3_get(const EaxCall& call, const Eax3Props& props)
4682 {
4683     switch (call.get_property_id()) {
4684         case EAXSOURCE_NONE:
4685             break;
4686
4687         case EAXSOURCE_ALLPARAMETERS:
4688             call.set_value<Exception>(props);
4689             break;
4690
4691         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4692             eax3_get_obstruction(call, props);
4693             break;
4694
4695         case EAXSOURCE_OCCLUSIONPARAMETERS:
4696             eax3_get_occlusion(call, props);
4697             break;
4698
4699         case EAXSOURCE_EXCLUSIONPARAMETERS:
4700             eax3_get_exclusion(call, props);
4701             break;
4702
4703         case EAXSOURCE_DIRECT:
4704             call.set_value<Exception>(props.lDirect);
4705             break;
4706
4707         case EAXSOURCE_DIRECTHF:
4708             call.set_value<Exception>(props.lDirectHF);
4709             break;
4710
4711         case EAXSOURCE_ROOM:
4712             call.set_value<Exception>(props.lRoom);
4713             break;
4714
4715         case EAXSOURCE_ROOMHF:
4716             call.set_value<Exception>(props.lRoomHF);
4717             break;
4718
4719         case EAXSOURCE_OBSTRUCTION:
4720             call.set_value<Exception>(props.lObstruction);
4721             break;
4722
4723         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4724             call.set_value<Exception>(props.flObstructionLFRatio);
4725             break;
4726
4727         case EAXSOURCE_OCCLUSION:
4728             call.set_value<Exception>(props.lOcclusion);
4729             break;
4730
4731         case EAXSOURCE_OCCLUSIONLFRATIO:
4732             call.set_value<Exception>(props.flOcclusionLFRatio);
4733             break;
4734
4735         case EAXSOURCE_OCCLUSIONROOMRATIO:
4736             call.set_value<Exception>(props.flOcclusionRoomRatio);
4737             break;
4738
4739         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4740             call.set_value<Exception>(props.flOcclusionDirectRatio);
4741             break;
4742
4743         case EAXSOURCE_EXCLUSION:
4744             call.set_value<Exception>(props.lExclusion);
4745             break;
4746
4747         case EAXSOURCE_EXCLUSIONLFRATIO:
4748             call.set_value<Exception>(props.flExclusionLFRatio);
4749             break;
4750
4751         case EAXSOURCE_OUTSIDEVOLUMEHF:
4752             call.set_value<Exception>(props.lOutsideVolumeHF);
4753             break;
4754
4755         case EAXSOURCE_DOPPLERFACTOR:
4756             call.set_value<Exception>(props.flDopplerFactor);
4757             break;
4758
4759         case EAXSOURCE_ROLLOFFFACTOR:
4760             call.set_value<Exception>(props.flRolloffFactor);
4761             break;
4762
4763         case EAXSOURCE_ROOMROLLOFFFACTOR:
4764             call.set_value<Exception>(props.flRoomRolloffFactor);
4765             break;
4766
4767         case EAXSOURCE_AIRABSORPTIONFACTOR:
4768             call.set_value<Exception>(props.flAirAbsorptionFactor);
4769             break;
4770
4771         case EAXSOURCE_FLAGS:
4772             call.set_value<Exception>(props.ulFlags);
4773             break;
4774
4775         default:
4776             eax_fail_unknown_property_id();
4777     }
4778 }
4779
4780 void ALsource::eax4_get(const EaxCall& call, const Eax4Props& props)
4781 {
4782     switch (call.get_property_id()) {
4783         case EAXSOURCE_NONE:
4784             break;
4785
4786         case EAXSOURCE_ALLPARAMETERS:
4787         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4788         case EAXSOURCE_OCCLUSIONPARAMETERS:
4789         case EAXSOURCE_EXCLUSIONPARAMETERS:
4790         case EAXSOURCE_DIRECT:
4791         case EAXSOURCE_DIRECTHF:
4792         case EAXSOURCE_ROOM:
4793         case EAXSOURCE_ROOMHF:
4794         case EAXSOURCE_OBSTRUCTION:
4795         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4796         case EAXSOURCE_OCCLUSION:
4797         case EAXSOURCE_OCCLUSIONLFRATIO:
4798         case EAXSOURCE_OCCLUSIONROOMRATIO:
4799         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4800         case EAXSOURCE_EXCLUSION:
4801         case EAXSOURCE_EXCLUSIONLFRATIO:
4802         case EAXSOURCE_OUTSIDEVOLUMEHF:
4803         case EAXSOURCE_DOPPLERFACTOR:
4804         case EAXSOURCE_ROLLOFFFACTOR:
4805         case EAXSOURCE_ROOMROLLOFFFACTOR:
4806         case EAXSOURCE_AIRABSORPTIONFACTOR:
4807         case EAXSOURCE_FLAGS:
4808             eax3_get(call, props.source);
4809             break;
4810
4811         case EAXSOURCE_SENDPARAMETERS:
4812             eax_get_sends<EAXSOURCESENDPROPERTIES>(call, props.sends);
4813             break;
4814
4815         case EAXSOURCE_ALLSENDPARAMETERS:
4816             eax_get_sends<EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4817             break;
4818
4819         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4820             eax_get_sends<EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4821             break;
4822
4823         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4824             eax_get_sends<EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4825             break;
4826
4827         case EAXSOURCE_ACTIVEFXSLOTID:
4828             eax_get_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots);
4829             break;
4830
4831         default:
4832             eax_fail_unknown_property_id();
4833     }
4834 }
4835
4836 void ALsource::eax5_get_all_2d(const EaxCall& call, const EAX50SOURCEPROPERTIES& props)
4837 {
4838     auto& subprops = call.get_value<Exception, EAXSOURCE2DPROPERTIES>();
4839     subprops.lDirect = props.lDirect;
4840     subprops.lDirectHF = props.lDirectHF;
4841     subprops.lRoom = props.lRoom;
4842     subprops.lRoomHF = props.lRoomHF;
4843     subprops.ulFlags = props.ulFlags;
4844 }
4845
4846 void ALsource::eax5_get_speaker_levels(const EaxCall& call, const EaxSpeakerLevels& props)
4847 {
4848     const auto subprops = call.get_values<EAXSPEAKERLEVELPROPERTIES>(eax_max_speakers);
4849     std::uninitialized_copy_n(props.cbegin(), subprops.size(), subprops.begin());
4850 }
4851
4852 void ALsource::eax5_get(const EaxCall& call, const Eax5Props& props)
4853 {
4854     switch (call.get_property_id()) {
4855         case EAXSOURCE_NONE:
4856             break;
4857
4858         case EAXSOURCE_ALLPARAMETERS:
4859         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4860         case EAXSOURCE_OCCLUSIONPARAMETERS:
4861         case EAXSOURCE_EXCLUSIONPARAMETERS:
4862         case EAXSOURCE_DIRECT:
4863         case EAXSOURCE_DIRECTHF:
4864         case EAXSOURCE_ROOM:
4865         case EAXSOURCE_ROOMHF:
4866         case EAXSOURCE_OBSTRUCTION:
4867         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4868         case EAXSOURCE_OCCLUSION:
4869         case EAXSOURCE_OCCLUSIONLFRATIO:
4870         case EAXSOURCE_OCCLUSIONROOMRATIO:
4871         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4872         case EAXSOURCE_EXCLUSION:
4873         case EAXSOURCE_EXCLUSIONLFRATIO:
4874         case EAXSOURCE_OUTSIDEVOLUMEHF:
4875         case EAXSOURCE_DOPPLERFACTOR:
4876         case EAXSOURCE_ROLLOFFFACTOR:
4877         case EAXSOURCE_ROOMROLLOFFFACTOR:
4878         case EAXSOURCE_AIRABSORPTIONFACTOR:
4879         case EAXSOURCE_FLAGS:
4880             eax3_get(call, props.source);
4881             break;
4882
4883         case EAXSOURCE_SENDPARAMETERS:
4884             eax_get_sends<EAXSOURCESENDPROPERTIES>(call, props.sends);
4885             break;
4886
4887         case EAXSOURCE_ALLSENDPARAMETERS:
4888             eax_get_sends<EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4889             break;
4890
4891         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4892             eax_get_sends<EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4893             break;
4894
4895         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4896             eax_get_sends<EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4897             break;
4898
4899         case EAXSOURCE_ACTIVEFXSLOTID:
4900             eax_get_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots);
4901             break;
4902
4903         case EAXSOURCE_MACROFXFACTOR:
4904             call.set_value<Exception>(props.source.flMacroFXFactor);
4905             break;
4906
4907         case EAXSOURCE_SPEAKERLEVELS:
4908             call.set_value<Exception>(props.speaker_levels);
4909             break;
4910
4911         case EAXSOURCE_ALL2DPARAMETERS:
4912             eax5_get_all_2d(call, props.source);
4913             break;
4914
4915         default:
4916             eax_fail_unknown_property_id();
4917     }
4918 }
4919
4920 void ALsource::eax_get(const EaxCall& call)
4921 {
4922     switch (call.get_version()) {
4923         case 1: eax1_get(call, mEax1.i); break;
4924         case 2: eax2_get(call, mEax2.i); break;
4925         case 3: eax3_get(call, mEax3.i); break;
4926         case 4: eax4_get(call, mEax4.i); break;
4927         case 5: eax5_get(call, mEax5.i); break;
4928         default: eax_fail_unknown_version();
4929     }
4930 }
4931
4932 void ALsource::eax_set_al_source_send(ALeffectslot *slot, size_t sendidx, const EaxAlLowPassParam &filter)
4933 {
4934     if(sendidx >= EAX_MAX_FXSLOTS)
4935         return;
4936
4937     auto &send = Send[sendidx];
4938     send.Gain = filter.gain;
4939     send.GainHF = filter.gain_hf;
4940     send.HFReference = LowPassFreqRef;
4941     send.GainLF = 1.0f;
4942     send.LFReference = HighPassFreqRef;
4943
4944     if(slot != nullptr)
4945         IncrementRef(slot->ref);
4946     if(auto *oldslot = send.Slot)
4947         DecrementRef(oldslot->ref);
4948
4949     send.Slot = slot;
4950     mPropsDirty = true;
4951 }
4952
4953 void ALsource::eax_commit_active_fx_slots()
4954 {
4955     // Clear all slots to an inactive state.
4956     mEaxActiveFxSlots.fill(false);
4957
4958     // Mark the set slots as active.
4959     for(const auto& slot_id : mEax.active_fx_slots.guidActiveFXSlots)
4960     {
4961         if(slot_id == EAX_NULL_GUID)
4962         {
4963         }
4964         else if(slot_id == EAX_PrimaryFXSlotID)
4965         {
4966             // Mark primary FX slot as active.
4967             if(mEaxPrimaryFxSlotId.has_value())
4968                 mEaxActiveFxSlots[*mEaxPrimaryFxSlotId] = true;
4969         }
4970         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot0)
4971             mEaxActiveFxSlots[0] = true;
4972         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot1)
4973             mEaxActiveFxSlots[1] = true;
4974         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot2)
4975             mEaxActiveFxSlots[2] = true;
4976         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot3)
4977             mEaxActiveFxSlots[3] = true;
4978     }
4979
4980     // Deactivate EFX auxiliary effect slots for inactive slots. Active slots
4981     // will be updated with the room filters.
4982     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4983     {
4984         if(!mEaxActiveFxSlots[i])
4985             eax_set_al_source_send(nullptr, i, EaxAlLowPassParam{1.0f, 1.0f});
4986     }
4987 }
4988
4989 void ALsource::eax_commit_filters()
4990 {
4991     eax_update_direct_filter();
4992     eax_update_room_filters();
4993 }
4994
4995 void ALsource::eaxCommit()
4996 {
4997     const auto primary_fx_slot_id = mEaxAlContext->eaxGetPrimaryFxSlotIndex();
4998     const auto is_primary_fx_slot_id_changed = (mEaxPrimaryFxSlotId != primary_fx_slot_id);
4999
5000     if(!mEaxChanged && !is_primary_fx_slot_id_changed)
5001         return;
5002
5003     mEaxPrimaryFxSlotId = primary_fx_slot_id;
5004     mEaxChanged = false;
5005
5006     switch(mEaxVersion)
5007     {
5008     case 1:
5009         mEax1.i = mEax1.d;
5010         eax1_translate(mEax1.i, mEax);
5011         break;
5012     case 2:
5013         mEax2.i = mEax2.d;
5014         eax2_translate(mEax2.i, mEax);
5015         break;
5016     case 3:
5017         mEax3.i = mEax3.d;
5018         eax3_translate(mEax3.i, mEax);
5019         break;
5020     case 4:
5021         mEax4.i = mEax4.d;
5022         eax4_translate(mEax4.i, mEax);
5023         break;
5024     case 5:
5025         mEax5.i = mEax5.d;
5026         mEax = mEax5.d;
5027         break;
5028     }
5029
5030     eax_set_efx_outer_gain_hf();
5031     eax_set_efx_doppler_factor();
5032     eax_set_efx_rolloff_factor();
5033     eax_set_efx_room_rolloff_factor();
5034     eax_set_efx_air_absorption_factor();
5035     eax_set_efx_dry_gain_hf_auto();
5036     eax_set_efx_wet_gain_auto();
5037     eax_set_efx_wet_gain_hf_auto();
5038
5039     eax_commit_active_fx_slots();
5040     eax_commit_filters();
5041 }
5042
5043 #endif // ALSOFT_EAX